Cómo Obtener la Longitud de un Array en Arduino

Es común usar arrays como parte del código que queremos subir a Arduino. Hay posibilidades de que en algún punto hayas declarado un array sin definir explícitamente su tamaño, sino que optas por poblar el array de inmediato como en el siguiente ejemplo:

int digitalPins[] = {2, 3, 4, 5, 6};

En algún punto de tu código, quieres ejecutar lógica usando cada elemento del array. Por lo tanto, piensas en usar un bucle for. Usar un bucle para iterar sobre cada elemento de un array significa que debemos conocer el número total de elementos del array, como en el siguiente ejemplo:

for (int i = 0; i < totalDigitalPins; i++) {
    // aplicar lógica a digitalPins[i]
  }

Quieres determinar el número de elementos de un array dinámicamente para asignar y obtener el valor de totalDigitalPins. Lo primero que encuentras en la documentación de Arduino es usar la función de utilidad sizeOf() sin entender completamente la definición de lo que hace.

int digitalPins[] = {2, 3, 4, 5, 6};
int totalDigitalPins = sizeOf(digitalPins);

for (int i = 0; i < totalDigitalPins; i++) {
    // aplicar lógica a digitalPins[i]
}

Desafortunadamente, rápidamente te das cuenta de que usar la función de utilidad sizeOf no obtiene realmente el número de elementos del array.

En este artículo, voy a explicar en detalle cómo encontrar el número de elementos de un array, hablar sobre las razones por las que no hay una función incorporada que obtenga la longitud de un array, compartir algunas recomendaciones así como compartir mi experiencia de por qué necesitaba una forma de obtener dinámicamente el tamaño del array.

¿Cómo encuentras el número de elementos de un array en Arduino?

El código de Arduino está escrito en C++, y la fórmula para obtener el número de elementos en un array en C++ es obtener el tamaño del array en bytes dividido por el tamaño de un solo elemento del array.

tamaño del array en bytes / tamaño de un solo elemento del array

Fórmula para encontrar el número de elementos en un array

En nuestro ejemplo inicial, habíamos declarado un array llamado digitalPins. Por lo tanto, si aplicamos esta fórmula para obtener el valor de totalDigitalPins, el código resultaría así:

int digitalPins[] = {2, 3, 4, 5, 6};
int totalDigitalPins = sizeOf(digitalPins) / sizeOf(digitalPins[0]);

for (int i = 0; i < totalDigitalPins; i++) {
    // aplicar lógica a digitalPins[i]
}

De esa manera, podemos iterar a través de cada elemento del array cuando usamos un bucle for.

Explicación

En Arduino, podemos determinar cuántos bytes se usan en memoria cada vez que declaramos una variable usando un tipo de datos usando la función sizeOf.

bool bo;
boolean boo;
byte byt;
char cha;
double doubl;
float floa;
int in;
long lon;
short shor;
size_t size_;

void setup() {
  Serial.begin(9600);

  Serial.println("total BYTES de un Tipo de Datos bool");
  Serial.println(sizeof(bo));

  Serial.println("total BYTES de un Tipo de Datos boolean");
  Serial.println(sizeof(boo));

  Serial.println("total BYTES de un Tipo de Datos byte");
  Serial.println(sizeof(byt));

  Serial.println("total BYTES de un Tipo de Datos char");
  Serial.println(sizeof(cha));

  Serial.println("total BYTES de un Tipo de Datos double");
  Serial.println(sizeof(doubl));

  Serial.println("total BYTES de un Tipo de Datos float");
  Serial.println(sizeof(floa));

  Serial.println("total BYTES de un Tipo de Datos int");
  Serial.println(sizeof(in));

  Serial.println("total BYTES de un Tipo de Datos long");
  Serial.println(sizeof(lon));

  Serial.println("total BYTES de un Tipo de Datos short");
  Serial.println(sizeof(shor));

  Serial.println("total BYTES de un Tipo de Datos size_t");
  Serial.println(sizeof(size_));
}

Si ejecutas la lógica anterior en Arduino mientras tienes el Monitor Serial abierto para leer los registros usando la función Serial.println(), pronto entenderás cuánto espacio ocupan estos tipos de datos en memoria. Por ejemplo, los tipos de datos bool, boolean, byte y char usan un byte, mientras que los tipos de datos double, float y long usan 4 bytes en Arduino UNO R3.

De manera similar, podemos hacer esto con un array.

int digitalPins[] = {2, 3, 4, 5, 6};

void setup() {
  Serial.begin(9600);

  Serial.println("total BYTES de un array digitalPins");
  Serial.println(sizeof(digitalPins));
}

En este caso, los bytes usados en digitalPins con 5 elementos dentro del array es 10.

Si agregas más elementos o quitas más elementos, los bytes ocupados en este array variarán. Sin embargo, ¿qué pasaría si tenemos otro array con el mismo número de elementos pero con un tipo de datos diferente, digamos el tipo de datos char? ¿Usará el mismo número de bytes que digitalPins?

char letters[] = {'a', 'r', 'd', 'u', 'c'};

void setup() {
  Serial.begin(9600);

  Serial.println("total BYTES de un array letters");
  Serial.println(sizeof(letters));
}

Dependiendo de qué tipos de datos se usen en los dos arrays, la respuesta podría ser sí o no. En este caso, la respuesta es no.

¿Por qué está pasando esto?

Recuerda, cada tipo de datos puede usar un número diferente de bytes. Como vimos anteriormente, un tipo de datos int usa dos bytes, y un tipo de datos char usa un byte.

Por lo tanto, para calcular el número de bytes en un array, necesitas determinar el número de elementos de ese array multiplicado por el tamaño en bytes del tipo de datos usado en el array.

tamaño del tipo de datos x número de elementos en el array

Tamaño de un array en bytes

Por lo tanto, en el caso de digitalPins, sabemos que tiene 5 elementos y su tipo de datos es int, y el tipo de datos int usa 2 bytes. Si multiplicamos estos dos números, obtenemos 10.

digitalPins bytes = 5 x 2 = 10

Si hacemos lo mismo para el array letters, obtenemos el siguiente cálculo:

letters bytes = 5 x 1 = 5

Sin embargo, sabemos que sizeOf ya obtiene los bytes de cualquier variable, y no necesariamente tendríamos que calcular el tamaño de bytes de un array.

int digitalPins[] = {2, 3, 4, 5, 6};
char letters[] = {'a', 'r', 'd', 'u', 'c'};

void setup() {
  Serial.begin(9600);

  Serial.println(sizeof(digitalPins));
  Serial.println(sizeof(letters));
}

Sin embargo, usando esta información, podemos determinar el número de elementos de un array en caso de que quieras obtener ese valor dinámicamente.

char letters[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int totalLetters = sizeOf(letters) / sizeOf(letters[0]);

¿Por qué no hay una función incorporada que obtenga la longitud de un array en Arduino?

Si tienes la oportunidad de ser un ingeniero de software, desarrollador de software o programador, probablemente has trabajado con otros lenguajes de programación como JavaScript, PHP, C#, Java, etc. Similar a C/C++, esos lenguajes de programación también usan arrays.

Sin embargo, estos lenguajes tienen métodos o propiedades incorporados para obtener la longitud de un array. Por ejemplo, en Javascript, obtener el número de elementos de un array sería así:

const myArray = [1,2,3,4,5,6,7];
const totalElementsOfArray = myArray.length;

¿Por qué no hay una función incorporada en C/C++ para obtener la longitud de un array?

Mucho de esto tiene que ver con cómo estos dos lenguajes de programación se usaron en una época en que las computadoras tenían recursos limitados. Si lo piensas, Arduino no es tan poderoso como un teléfono o una computadora, y también tiene limitaciones cuando se trata de almacenamiento de memoria. Agregar funciones incorporadas significa usar parte de ese espacio extra que podría usarse para escribir la lógica a usar en Arduino.

Otra buena razón es que C/C++, contrario a lenguajes de programación de alto nivel como JavaScript, no puedes agregar elementos a un array. Por lo tanto, si creas un array en JavaScript sin declarar el número de elementos que el array puede tener, puedes agregar más elementos al array, y estar limitado por un tamaño de array. Por otro lado, en C/C++ no hay manera de agregar más elementos a un array de tamaño fijo.

Recomendación

La recomendación general es definir el tamaño del array antes de declarar el array. De esa manera, evitas tratar de calcular el número de elementos de un array.

int arraySize = 5;
int digitalPins[arraySize] = {2, 3, 4, 5, 6};
char letters[arraySize] = {'a', 'r', 'd', 'u', 'c'};

Casos de Uso

El otro día, estaba trabajando en construir un circuito simple para conectar múltiples LEDs usando múltiples pines de Arduino. El código consistía en definir un array de pines LED y usar un bucle for para configurar todos los pines digitales de Arduino en modo OUTPUT para enviar señales HIGH o LOW desde esos pines de Arduino para encender y apagar múltiples luces LED. El código era este:

/*
    Conectar Múltiples LEDs usando Múltiples Pines de Arduino.
    Para más guías y tutoriales: https://www.thecircuitmaker.com
*/
// configurar variable de array para almacenar todos los números de pin que encenderán los LEDs
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
int totalPins = sizeof(ledPins) / sizeof(int);
// retraso de 1 segundo
int delayTime = 1000;
void setup() {
  // configurar los pines LED para comportarse como modo OUTPUT para enviar señales HIGH o LOW
  for (int i = 0; i < totalPins; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}
void loop() {
  blinkRandomLED();
}
void blinkAllLeds() {
  for (int i = 0; i < totalPins; i++) {
    // encender el LED
    digitalWrite(ledPins[i], HIGH);
  }
  // esperar 1 segundo
  delay(delayTime);
  for (int i = 0; i < totalPins; i++) {
    // apagar el LED
    digitalWrite(ledPins[i], LOW);
  }
  // esperar un segundo
  delay(delayTime);
}
void blinkOneLEDAtATime() {
  for (int i = 0; i < totalPins; i++) {
    // encender el LED
    digitalWrite(ledPins[i], HIGH);
    // esperar 1 segundo
    delay(delayTime);
    // apagar el LED
    digitalWrite(ledPins[i], LOW);
    // esperar un segundo
    delay(delayTime);
  }
}
void blinkRandomLED() {
  // seleccionar número de pin aleatorio
  int randomIndex = random(totalPins);
  int pinSelected = ledPins[randomIndex];
  
  // encender el LED
  digitalWrite(pinSelected, HIGH);
  // esperar 1 segundo
  delay(delayTime);
  // apagar el LED
  digitalWrite(pinSelected, LOW);
  // esperar un segundo
  delay(delayTime);
}

Observa cómo estoy usando totalPins o el número de elementos del ledPins para ejecutar lógica para parpadear los LEDs.

Conclusión

En este artículo, aprendiste cómo calcular el número de elementos de un array en C++, el lenguaje de programación usado en Arduino. Aunque no hay una función incorporada que calcule la longitud de un array, aún podemos determinar el número total de elementos del array usando sizeOf. Sin embargo, se recomienda definir en una variable el tamaño del array para evitar hacer cálculos adicionales.

¿Te gustó este artículo?

Espero que este artículo haya sido no solo útil sino también educativo. Si te gustó, comparte este artículo con amigos que estén interesados en electrónica y disfruten haciendo proyectos divertidos usando Arduino.

Si tienes dudas, preguntas, o encuentras problemas mientras sigues este tutorial, no dudes en dejar un comentario en la sección de abajo.

Ten en cuenta que los comentarios se mantienen para moderación para prevenir spam.