Aprender

Arduino 2D arrays, on a die drawn on an 8x8 matrix

Intermedio

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: seis caras de dado en un arreglo bidimensionalen vivo0.000 s 0.00x
Presiona Ejecutar y luego haz clic en el interruptor de inclinación varias veces
Haz clic en el interruptor de inclinación para agitarlo. Cada cara es una fila de FACES, ocho bytes para ocho líneas de LEDs.

Un arreglo bidimensional es una tabla. int grid[3][4]; son 3 filas de 4 números cada una, y grid[1][2] es la fila 1, columna 2, ambas contadas desde 0. Para recorrer toda la tabla, pon un bucle for dentro de otro: el externo para las filas y el interno para las columnas.

El circuito de arriba es un dado en una matriz de LEDs de 8x8 en un Uno. Su sketch guarda las seis caras en const byte FACES[6][8]: seis filas, una por cara, de ocho bytes, uno por línea de LEDs. Presiona Ejecutar y haz clic varias veces en el interruptor de inclinación para agitarlo. La cara rueda, se frena y se detiene, el LED RGB se pone verde y el monitor serie imprime "rolled a" y el número.

Abajo está la tabla de dados, crear y llenar una cuadrícula, contar filas y columnas, pasar una tabla a una función, una tabla de palabras y cuánto cuesta una tabla grande en un Uno, cada ejecución con lo que imprimió.

Seis caras, ocho filas cada una

Here is the table from the sketch running above and the function that draws a face. FACES[n - 1] is the whole face for the number n, and FACES[n - 1][row] is one line of it, a byte whose bits are the eight LEDs across. The face for 1 is all zeros but rows 3 and 4, where 0x18 lights the two middle LEDs: the single pip.

firmware/uno/examples/kcdice (las caras corriendo arriba)
const byte FACES[6][8] = {
    {0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00},
    {0x00, 0x06, 0x06, 0x00, 0x00, 0x60, 0x60, 0x00},
    {0xC0, 0xC0, 0x00, 0x18, 0x18, 0x00, 0x03, 0x03},
    {0x00, 0x66, 0x66, 0x00, 0x00, 0x66, 0x66, 0x00},
    {0xC3, 0xC3, 0x00, 0x18, 0x18, 0x00, 0xC3, 0xC3},
    {0x66, 0x66, 0x00, 0x66, 0x66, 0x00, 0x66, 0x66},
};

Crear una, llenarla, imprimirla

Cada par interno de llaves es una fila. El sketch de abajo imprime la cuadrícula como una tabla, una fila por línea con una tabulación entre los números, y luego grid[1][2], que imprimió 7: la fila 1 es la segunda fila, y la columna 2 es su tercer número.

Escribir funciona igual que leer: grid[row][col] = value; dentro de los mismos dos bucles llena toda la tabla, fila por fila. Mantén las filas afuera y las columnas adentro, porque ese es el orden en que los números están en memoria, y usa nombres como row y col en lugar de i y j, para que un par de índices intercambiados salte a la vista cuando lo releas.

Una cuadrícula de 3 por 4
int grid[3][4] = {
  {1, 2, 3, 4},
  {5, 6, 7, 8},
  {9, 10, 11, 12},
};

void setup() {
  Serial.begin(9600);
  for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 4; col++) {
      Serial.print(grid[row][col]);
      Serial.print('\t');
    }
    Serial.println();
  }
  Serial.println(grid[1][2]);
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Cuántas filas y columnas

sizeof(grid) es el tamaño de toda la tabla en bytes: 24 por 12 int de 2 bytes. Divídelo entre el tamaño de una fila, sizeof(grid[0]), para el número de filas, que imprimió 3, y divide una fila entre un elemento, sizeof(grid[0]) / sizeof(grid[0][0]), para las columnas, que imprimió 4. Los bucles escritos así siguen funcionando cuando la tabla crece.

Los números están en memoria una fila tras otra. Si lees pasado el final de una fila obtienes el inicio de la siguiente: grid[1][4] imprimió 9, el primer número de la fila 2, con solo una advertencia, array index 4 is past the end of the array (that has type 'int[4]'). Pasado el final de la última fila no hay siguiente fila, solo lo demás que haya en memoria.

Pasar una tabla a una función

A function that takes a 2D array has to be told how long a row is, so it can find row 2. Only the number of rows may be left out. The sketch below adds up the grid and printed 78. Write int g[][] with both sizes left out and the build stops with array has incomplete element type 'int[]'; GCC says declaration of 'g' as multidimensional array must have bounds for all dimensions except the first.

El número de columnas va en el parámetro
const int COLS = 4;

int total(int g[][COLS], int rows) {
  int sum = 0;
  for (int r = 0; r < rows; r++) {
    for (int c = 0; c < COLS; c++) {
      sum += g[r][c];
    }
  }
  return sum;
}

int grid[3][COLS] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

void setup() {
  Serial.begin(9600);
  Serial.println(total(grid, 3));
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Una tabla de palabras

Text can be stored two ways. char words[3][6] is a real 2D array: three rows of six characters, each word padded out, 18 bytes in all, and words[1][0] is the letter g. const char *names[] is an array of pointers, each to a word of its own length. Both printed "green" and "blue" the same way.

A row must have room for the longest word and its zero byte. With rows of 5, "green" did not fit: initializer-string for char array is too long, array size is 5 but initializer has size 6 (including the null terminating character). GCC says initializer-string for 'char [5]' is too long.

Dos formas de guardar tres palabras
const char *names[] = {"red", "green", "blue"};
char words[3][6] = {"red", "green", "blue"};

void setup() {
  Serial.begin(9600);
  Serial.println(names[1]);
  Serial.println(words[2]);
  Serial.println(words[1][0]);
  Serial.println(sizeof(words));
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Tablas grandes y 2 KB de RAM

Un Uno tiene 2048 bytes de RAM para todas las variables del sketch. int big[30][40] quiere 2400 de ellos, y la compilación se detuvo: global variables do not fit in the 2 KB SRAM, overflowed by 538 bytes, contando las otras variables que un sketch siempre tiene. Una tabla que nunca cambia, como las caras del dado o una fuente, puede vivir en la flash: agrega PROGMEM y léela con pgm_read_byte(&FACES[1][2]), que imprimió 6 de una tabla pequeña. La flash tiene 32 KB.

Abre este circuito en el editor. Arduino Uno: seis caras de dado en un arreglo bidimensional, cableado como corre al inicio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

How do I declare a 2D array in Arduino?

Dame las filas y luego las columnas: int grid[3][4]; o llénalo al declararlo, un par de llaves por fila. Se puede omitir el número de filas cuando todas las filas están escritas.

How do I loop through a 2D array?

Pon un ciclo for sobre las columnas dentro de un ciclo for sobre las filas y lee grid[row][col]. Calcula los conteos con sizeof para que los ciclos sigan a la tabla si cambia.

How do I pass a 2D array to a function?

Escribe el número de columnas en el parámetro, int g[][4], y pasa el número de filas como segundo parámetro. Solo el primer tamaño puede quedar vacío.

¿Cómo hago un arreglo de cadenas en Arduino?

Use const char *names[] = {"red", "green"}; for fixed words, or a char array with one row per word, char words[3][6], when the words have to change. Each row needs one extra byte for the zero at the end.

¿Qué tan grande puede ser un arreglo en un Arduino Uno?

Todo lo que esté en RAM debe caber en 2048 bytes, con espacio para la pila. Una tabla constante puede ir a los 32 KB de flash con PROGMEM.

Fuentes

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.