Aprender

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

Intermediário

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: seis faces de dado em um array bidimensionalao vivo0.000 s 0.00x
Aperte Rodar e depois clique no interruptor de inclinação algumas vezes
Clique no interruptor de inclinação para agitar o dado. Cada face é uma linha de FACES, oito bytes para oito linhas de LEDs.

Um array bidimensional é uma tabela. int grid[3][4]; são 3 linhas de 4 números cada, e grid[1][2] é a linha 1, coluna 2, ambas contadas a partir de 0. Para percorrer a tabela inteira, coloque um for dentro do outro: o de fora para as linhas e o de dentro para as colunas.

O circuito acima é um dado numa matriz de LEDs 8x8 num Uno. O sketch dele guarda as seis faces em const byte FACES[6][8]: seis linhas, uma por face, de oito bytes, um por linha de LEDs. Aperte Rodar e clique algumas vezes no interruptor de inclinação para agitá-lo. A face rola, desacelera e para, o LED RGB fica verde, e o monitor serial imprime "rolled a" e o número.

Abaixo está a tabela de dados do dado, criando e preenchendo uma grade, contando linhas e colunas, passando uma tabela para uma função, uma tabela de palavras e quanto custa uma tabela grande num Uno, cada execução com o que ela imprimiu.

Seis faces, oito linhas cada

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 (as faces rodando acima)
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},
};

Criar, preencher, imprimir

Cada par interno de chaves é uma linha. O sketch abaixo imprime a grade como uma tabela, uma linha por linha de saída com uma tabulação entre os números, e depois grid[1][2], que imprimiu 7: a linha 1 é a segunda linha, e a coluna 2 é o terceiro número dela.

Escrever funciona igual a ler: grid[row][col] = value; dentro dos mesmos dois loops preenche a tabela inteira, linha por linha. Mantenha as linhas fora e as colunas dentro, porque essa é a ordem em que os números ficam na memória, e use nomes como row e col em vez de i e j, para que um par de índices trocado chame a atenção quando você reler o código.

Uma grade 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Quantas linhas e colunas

sizeof(grid) é o tamanho da tabela inteira em bytes: 24 para 12 ints de 2 bytes. Divida pelo tamanho de uma linha, sizeof(grid[0]), para o número de linhas, que imprimiu 3, e divida uma linha por um elemento, sizeof(grid[0]) / sizeof(grid[0][0]), para as colunas, que imprimiu 4. Loops escritos assim continuam funcionando quando a tabela cresce.

Os números ficam na memória uma linha depois da outra. Leia além do fim de uma linha e você chega ao começo da próxima: grid[1][4] imprimiu 9, o primeiro número da linha 2, com apenas um aviso, array index 4 is past the end of the array (that has type 'int[4]'). Além do fim da última linha não há próxima linha, só o que mais estiver na memória.

Passando uma tabela para uma função

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.

A contagem de colunas vai no 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Uma tabela de palavras

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.

Dois jeitos de guardar três palavras
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Tabelas grandes e 2 KB de RAM

Um Uno tem 2048 bytes de RAM para todas as variáveis do sketch. int big[30][40] quer 2400 deles, e a compilação parou: global variables do not fit in the 2 KB SRAM, overflowed by 538 bytes, contando as outras variáveis que todo sketch sempre tem. Uma tabela que nunca muda, como as faces do dado ou uma fonte, pode viver na flash: adicione PROGMEM e leia com pgm_read_byte(&FACES[1][2]), que imprimiu 6 de uma tabela pequena. A flash tem 32 KB.

Abra este circuito no editor. Arduino Uno: seis faces de dado num único array bidimensional, ligado como roda no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

How do I declare a 2D array in Arduino?

Dê as linhas, depois as colunas: int grid[3][4]; ou preencha na declaração, um par de chaves por linha. A contagem de linhas pode ficar de fora quando todas as linhas estão escritas.

How do I loop through a 2D array?

Coloque um for pelas colunas dentro de um for pelas linhas e leia grid[row][col]. Calcule as contagens com sizeof para os loops acompanharem a tabela se ela mudar.

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

Escreva a contagem de colunas no parâmetro, int g[][4], e passe a contagem de linhas como segundo parâmetro. Só o primeiro tamanho pode ficar vazio.

Como faço um array de strings no 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.

Qual o tamanho máximo de um array num Arduino Uno?

Tudo que está na RAM precisa caber em 2048 bytes, com espaço sobrando para a pilha. Uma tabela constante pode ir para os 32 KB de flash com PROGMEM.

Fontes

De onde vêm as informações desta página

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.