Arreglos en Arduino: una lista de cosas bajo un solo nombre
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Un arreglo es una lista de valores del mismo tipo bajo un solo nombre. int pins[] = {13, 12, 11}; crea una lista de tres números, pins[0] es el primero, y un ciclo for puede recorrer toda la lista. Los arreglos son la forma en que un sketch guarda una fila de pines de LED, una melodía, un conjunto de patrones de luz o las últimas diez lecturas de un sensor.
El circuito de arriba guarda ocho patrones de luz en un arreglo y los muestra en ocho lámparas mediante un registro de desplazamiento. Presiona Ejecutar. El monitor serie imprime "patterns in the list: 8", luego "step 0 = 1", "step 1 = 11" y así hasta "step 7 = 11111111" mientras la barra se llena lámpara por lámpara. Cada paso es una entrada de la lista.
Abajo verás cómo crear un arreglo y contarlo, por qué la primera entrada es la número 0, y los dos errores que cuestan más tiempo: leer o escribir más allá del final, y preguntarle a una función qué tan grande es un arreglo.
¿Quieres la versión paso a paso? La lección "Un ciclo sobre una lista" lo explica con puntos de control.
Abrir la lecciónCrea uno, y cuenta desde cero
Escribe el tipo, el nombre, corchetes y los valores entre llaves. Deja los corchetes vacíos y el compilador cuenta los valores por ti. Las entradas se numeran desde 0, así que un arreglo de ocho tiene de PATTERNS[0] a PATTERNS[7], y no existe un PATTERNS[8].
You can also give the size and fill it in later: int readings[10]; makes ten ints. A global array like that starts as all zeros. One made inside a function starts with whatever was in memory, so fill it before you read it.
const byte PATTERNS[] = {
0b00000001,
0b00000011,
0b00000111,
0b00001111,
0b00011111,
0b00111111,
0b01111111,
0b11111111,
};
const int COUNT = (int)(sizeof(PATTERNS) / sizeof(PATTERNS[0]));Cuántos: sizeof
sizeof da el tamaño de algo en bytes, no el número de entradas. Así que el conteo es el tamaño del arreglo completo dividido entre el tamaño de una entrada. Para cinco ints en un Uno, sizeof(scores) imprimió 10, porque un int allí es de 2 bytes. El mismo sketch en un ESP32-C3 imprimió 20, porque allí un int es de 4. Dividido entre el tamaño de una entrada, ambos dijeron 5.
Calcula el conteo de esta manera en vez de escribir 8 a mano. Agrega un noveno patrón a la lista de arriba y presiona Ejecutar: la primera línea se vuelve "patterns in the list: 9", el ciclo corre nueve pasos, y no tocaste nada más que la lista.
int scores[5] = {10, 20, 30, 40, 50};
void setup() {
Serial.begin(9600);
Serial.println(sizeof(scores));
Serial.println(sizeof(scores) / sizeof(scores[0]));
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Un arreglo de pines
El arreglo más útil en un Arduino es una lista de pines. Pon los números de pin en un arreglo y un solo ciclo los configura todos, y otro los enciende por turno. El sketch de abajo corre en las tres lámparas del banco de código (pines 13, 12 y 11) e imprimió "pin 13 on", "pin 12 on" y "pin 11 on" en orden. Agrega un pin a la lista, conecta un LED más, y se une.
Arrays of text work the same way. const char *names[] = {"red", "yellow", "green"}; is a list of three words, and names[1] is "yellow". The random numbers page uses one to make a magic eight ball.
Un arreglo también puede guardar filas. const byte GRID[2][3] = {{1, 2, 3}, {4, 5, 6}}; son dos filas de tres, GRID[1][0] imprimió 4, y sizeof(GRID) imprimió 6, dos filas de tres bytes. Dos ciclos for, uno dentro del otro, recorren cada entrada, que es cómo un sketch guarda los puntos de una matriz de LED o las teclas de un teclado.
const int LAMPS[] = {13, 12, 11};
const int COUNT = sizeof(LAMPS) / sizeof(LAMPS[0]);
void setup() {
Serial.begin(9600);
for (int i = 0; i < COUNT; i++) {
pinMode(LAMPS[i], OUTPUT);
}
}
void loop() {
for (int i = 0; i < COUNT; i++) {
digitalWrite(LAMPS[i], HIGH);
Serial.print("pin ");
Serial.print(LAMPS[i]);
Serial.println(" on");
delay(300);
digitalWrite(LAMPS[i], LOW);
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Más allá del final: sin error, respuestas incorrectas
Nothing checks an index while the sketch runs. Ask for entry 5 of a five-entry array and the board does not stop or complain; it reads whatever two bytes come next in memory. Our a[5] printed 280, a number that was never in the list. The build tab did warn about that one, because the 5 was written right there in the code: array index 5 is past the end of the array (that has type 'int[5]').
Escribir más allá del final es peor, y normalmente no da ningún aviso, porque el índice es un contador de ciclo. Llenamos un arreglo de cinco elementos con un ciclo que decía i <= 5, y una variable llamada other, declarada en la línea siguiente, cambió de 99 a 0. No se imprimió nada y nada se detuvo. Un sketch que hace esto falla en un lugar completamente distinto, y por eso el bug es tan difícil de encontrar. Usa < contra el contador, siempre.
int a[5] = {10, 20, 30, 40, 50};
int other = 99;
void setup() {
Serial.begin(9600);
for (int i = 0; i <= 5; i++) a[i] = 0;
Serial.println(other);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Pasar un arreglo a una función
Un arreglo entregado a una función llega como la dirección de su primer elemento, no como una copia de la lista. Eso tiene dos efectos. La función puede cambiar el arreglo de quien la llama, que muchas veces es lo que quieres. Y dentro de la función, sizeof ya no sabe qué tan largo es: el mismo scores que medía 10 bytes en setup() medía 2 dentro de una función, el tamaño de una dirección en un Uno. La pestaña de compilación advirtió: sizeof on array function parameter will return size of 'int *' instead of 'int[]'.
Así que pasa el contador junto con el arreglo, como average(scores, 5), o calcúlalo con sizeof donde se creó el arreglo y pasa eso. Todas las bibliotecas de Arduino que reciben un búfer lo hacen así.
Abre este circuito en el editor. Arduino Uno: ocho patrones en un arreglo, en ocho lámparas, cableado como se ejecuta al inicio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Preguntas
¿Los arreglos de Arduino empiezan en 0 o en 1?
En 0. El primer elemento de un arreglo es name[0] y el último de un arreglo de ocho es name[7]. Un ciclo sobre él es for (int i = 0; i < 8; i++).
¿Cómo sé la longitud de un arreglo en Arduino?
Divide su tamaño en bytes entre el tamaño de un elemento: sizeof(list) / sizeof(list[0]). Esto solo funciona donde se declaró el arreglo; dentro de una función que recibió el arreglo, sizeof da el tamaño de una dirección.
¿Puedo cambiar el tamaño de un arreglo?
No. Su tamaño queda fijo cuando se compila el sketch. Hazlo tan grande como lo vayas a necesitar y lleva un contador aparte de cuántos elementos están en uso.
¿Qué pasa si me paso del final de un arreglo?
Nada lo detiene. Leer más allá del final da lo que sea que esté después en memoria, y escribir más allá del final cambia otra variable. En nuestra prueba, escribir un elemento de más cambió una variable vecina de 99 a 0 sin ningún error.
¿Un arreglo puede contener texto?
Yes. const char *names[] = {"red", "yellow", "green"}; is an array of three strings, and names[0] is "red". A single piece of text is itself an array of char, ending in a zero byte.
Sigue así
De dónde vienen los datos de esta página
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.