A matriz de LED é um componente que vem em vários kits de Arduino, mas muitos podem ficar confusos por sua aparente complexidade e acabam não usando. Portanto, neste post, vamos entender a matriz de LED e ver como acioná-la.

O que é

A matriz de LED é um componente que possui 64 LEDs distribuídos em 8 linhas e 8 colunas, formando assim um quadrado. Veja o exemplo de uma na imagem abaixo:

Matriz de LED
Fonte: Wikipedia

Ela é feita de modo a facilitar o acionamento de cada LED individualmente. Portanto, ao invés de 65 pinos (64 pinos + o terra), ela possui apenas 16.

Essa solução é alcançada interligando os LEDs por linhas e colunas da seguinte forma: os LEDs de cada coluna tem os ânodos interligados e os LEDs de cada linha tem os cátodos interligados. Entretanto, essa interligação pode ser invertida dependendo do modelo da matriz: em cada coluna o cátodo é interligado e em cada linha o ânodo é interligado.

Normalmente a ligação obedece um dos esquemas abaixo:

matriz de led esquema
Fonte: circuitspecialist

Repare que, não é possível criar certos padrões com os LEDs, pois acionando um LED, você interfere no funcionamento de outro. Para resolver isso, você pode acender e apagar cada LED por vez e criar um delay muito pequeno entre os acionamentos. Esse delay pequeno, para nossos olhos, é imperceptível e o resultado final será algo constante. Recomendo usar em torno de 20 microssegundos.

Como usar

Acesso aos pinos

Antes de começar a energizar a matriz de LED, temos um pequeno problema para resolver: ela não cabe nas protoboards de forma a possibilitar seu acionamento. Pelos testes que fiz, ela fica muito larga e não dá para acessas seus pinos. E, para resolver esse problema, existem duas formas usando protoboards: colocando uma do lado da outra ou passando vários fios por baixo dela e ligando eles em outro ponto da protoboard.

Como muitos não tem uma protoboard de sobra, é melhor optar pela segunda opção. Na imagem abaixo, primeiro eu passei os fios (fios de cabo de rede) e liguei eles em trilhas fora da matriz.

matriz de led fios

Depois, com a matriz encaixada, eu consigo acessar todos os pinos.

matriz de led ligação

Obs.: A parte inferior é a que possui o escrito na lateral da matriz.

Ligação

Para acionar corretamente os LEDs, precisamos descobrir a numeração correta dos pinos da matriz. Para isso, liguei o último pino (da esquerda pra direita) da parte inferior no 5v. E fui ligando o GND em outros pinos. Com isso, comparei com o esquema que mostrei antes:

matriz de led esquema
Fonte: circuitspecialist

Dessa forma, descobri que a minha matriz corresponde a da imagem da direita. E, o último pino (o mesmo de antes) é o pino 8. Obs.: Na imagem acima, você deve olhar o número que está dentro de um círculo para descobrir qual é o pino correspondente. Portanto, meu resultado foi:

matriz de led pinos

Obs.: A imagem acima mostra a placa de cabeça para baixo, então a numeração parece estar invertida em relação ao que falei logo acima. Por fim, basta seguir o esquema de ligação para saber quais pinos você quer acionar. Por exemplo, quero ligar o LED da 1ª linha e 1ª coluna: De acordo com o diagrama da direita, o pino 9 deve ser ligado no 5v e o pino 13 no GND.

Obs²: Não esqueça de usar resistores.

Finalmente, vamos então as formas de controlar a matriz de LED.

Arduino

Ligação

Agora que nós vimos como fazer a ligação, não tem muito segredo para acionar os LEDs. Você só deve ficar atento ao seguinte fato: a matriz de LED possui 16 pinos e o Arduino UNO possui 13 pinos digitais. Portanto, você deve ligar o restante dos pinos nas portas analógicas (A0-A5). Não tem problema algum em fazer isso, pois os pinos analógicos também são pinos digitais no fim das contas. Essa separação só é feita pra simplificar o entendimento para novatos.

Além disso, vale lembrar que, se você for usar os pinos D0 e D1 do Arduino, não pode usar a comunicação serial. Isso, porque são os pinos padrões utilizados para a comunicação. Então, é só pular os dois caso você queira utilizar a comunicação serial.

Agora, você pode usar a lógica que preferir. Para exemplificar, vou ligar os pinos (da matriz) correspondentes às linhas nos pinos D0-D7 de maneira sequencial (D0 – linha 1, D1 – linha 2…). No meu caso são os pinos (da matriz): 9, 14, 8, 12, 1, 7, 2 e 5. Os pinos correspondentes as colunas eu liguei da mesma forma, porém do D8-D13 e do A0-A1.

Programação

Código para testar a matriz

Para testar os pinos e ver se a matriz está corretamente ligada, use o código abaixo. Se você não seguiu a mesma ligação que fiz, basta mudar os pinos no início do código e a lógica para apagar os LEDs. Usei vetores para definir os pinos, pois assim é mais fácil de controlá-los.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
int linhas[8] = {0, 1, 2, 3, 4, 5, 6, 7}; // Pinos que controlam as linhas
int colunas[8] = {8, 9, 10, 11, 12, 13, 14, 15}; // 14 corresponde ao A0 e 15 corresponde ao A1

void setup() {
  int i; // Variavel para o for

  for (i = 0; i < 16; i++) { // Vai de 0 até 16 definindo os pinos como saida
    pinMode(i, OUTPUT);

    if (i < 8) { // GND nos ânodos
      digitalWrite(i, LOW);
    } else { // 5v nos cátodos
      digitalWrite(i, HIGH);
    }
  }
}

void loop() {
  int i, j; // Variaveis para o for
  digitalWrite(colunas[0], LOW);

  for (i = 0; i < 8; i++) {
    for (j = 0; j < 8; j++) {
      digitalWrite(colunas[i], LOW);
      digitalWrite(linhas[j], HIGH);

      if (j > 0) { // Se não for a primeira linha, apaga a linha anterior
        digitalWrite(linhas[j - 1], LOW);
      }

      delay(500); // Delay entre os LEDs
    }
    digitalWrite(colunas[i], HIGH); // Depois de sair do for, apaga os ultimos leds acionados
    digitalWrite(linhas[j - 1], LOW);
  }
}

Código de exemplo

Para exemplificar, vou escrever na matriz a letra M e a letra P. Essas letras são impossíveis de serem escritas sem que o acionamento de um LED atrapalhe o outro. Para isso, vou usar a técnica de criar um delay muito pequeno (20µs) entre o acionamento de cada LED por coluna.

Novamente, para rodar o código, apenas mude os pinos para a configuração que você usou e mude a função limpar (feita para apagar os LEDs).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
int linhas[8] = {0, 1, 2, 3, 4, 5, 6, 7};
int colunas[8] = {8, 9, 10, 11, 12, 13, 14, 15}; // 14 corresponde ao A0 e 15 corresponde ao A1

void setup() {
  int i; // Variavel para o for

  for (i = 0; i < 16; i++) { // Vai de 0 até 16 definindo os pinos como saida
    pinMode(i, OUTPUT);
  }
}

void loop() {
  int i, j;

  // Letra M
  for (i = 0; i < 6250; i++) { // For criado para manter a letra M por 1 seg - Considerando que cada avanço do for dura 160us -> 160us x 6250 = 1segundo
    limpar();
    digitalWrite(colunas[0], LOW); // 1 coluna
    for (j = 0; j < 8; j++) {
      digitalWrite(linhas[j], HIGH);
    }

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[1], LOW); // 2 coluna
    digitalWrite(linhas[1], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[2], LOW); // 3 coluna...
    digitalWrite(linhas[1], HIGH);
    digitalWrite(linhas[2], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[3], LOW);
    digitalWrite(linhas[2], HIGH);
    digitalWrite(linhas[3], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[4], LOW);
    digitalWrite(linhas[2], HIGH);
    digitalWrite(linhas[3], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[5], LOW);
    digitalWrite(linhas[1], HIGH);
    digitalWrite(linhas[2], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[6], LOW);
    digitalWrite(linhas[1], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[7], LOW); // 1 coluna
    for (j = 0; j < 8; j++) {
      digitalWrite(linhas[j], HIGH);
    }
    delayMicroseconds(20);
  }

  // Letra P
  for (i = 0; i < 6250; i++) { // Mesma coisa da letra M
    limpar();
    digitalWrite(colunas[0], LOW); // 1 coluna
    for (j = 0; j < 8; j++) {
      digitalWrite(linhas[j], HIGH);
    }

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[1], LOW); //2 coluna
    digitalWrite(linhas[0], HIGH);
    digitalWrite(linhas[3], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[2], LOW); //3 coluna...
    digitalWrite(linhas[0], HIGH);
    digitalWrite(linhas[3], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[3], LOW);
    digitalWrite(linhas[0], HIGH);
    digitalWrite(linhas[3], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[4], LOW);
    digitalWrite(linhas[0], HIGH);
    digitalWrite(linhas[3], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[5], LOW);
    digitalWrite(linhas[0], HIGH);
    digitalWrite(linhas[3], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[6], LOW);
    digitalWrite(linhas[0], HIGH);
    digitalWrite(linhas[3], HIGH);

    delayMicroseconds(20);

    limpar();
    digitalWrite(colunas[7], LOW);
    digitalWrite(linhas[0], HIGH);
    digitalWrite(linhas[1], HIGH);
    digitalWrite(linhas[2], HIGH);
    digitalWrite(linhas[3], HIGH);

    delayMicroseconds(20);
  }
}

void limpar() { // Funçao criada para apagar todos os leds
  int i; // Variavel para o for

  for (i = 0; i < 16; i++) {
    if (i < 8) { // GND nos ânodos
      digitalWrite(i, LOW);
    } else { // 5v nos cátodos
      digitalWrite(i, HIGH);
    }
  }
}

Resultado (Uma das linhas da minha matriz está queimada):

matriz de led letra mmatriz de led letra p

Módulo com CI

Meu objetivo no post era focar no acionamento da matriz sem usar módulos ou bibliotecas. Portanto, vou apenas dar um direcionamento a respeito do uso da matriz com módulo.

Outra forma de controlar a matriz de LED e evitar a confusão de fios, é usar o módulo com o CI MAX7219. Esse módulo de matriz de LED, já vem com as ligações feitas com o CI. Se quiser acessar o datasheet dele, clique aqui.

De 16 pinos, nós temos apenas 5 agora: Vcc, GND, DIM, CS e CLK. Você pode acessar esta página para ler a documentação da biblioteca necessária e aprender sobre a ligação.

Você pode baixar a biblioteca aqui e rodar os códigos de exemplo para aprender a controlar a matriz.