Início / Projetos Arduino / Projetos Squids / Básico / Projeto 68 - Usando uma matriz de LEDs 8 X 8 com Arduino

---

Projeto 68 - Usando uma matriz de LEDs 8 X 8 com Arduino

Angelo Luis Ferreira | 07/10/2019 Acessos: 10.976

Objetivo

Neste projeto vamos mostrar como utilizar uma matriz de leds 8 X 8 com um microcontrolador Arduino. No projeto veremos como criar e exibir letras, números ou símbolos de forma simplificada. Também criaremos uma rotina para tornar a matriz de leds em um display de mensagens.

Definições

Matriz de leds é um componente eletrônico que possui 64 LEDs de 3mm ou 5mm distribuídos em 8 linhas e 8 colunas formando uma matriz quadrada. A matriz de leds é um componente muito utilizado no desenvolvimento de projetos com efeitos visuais, exibição de textos, imagens ou números.

Existem vários modelos de matizes de leds no mercado, mas para a montagem e programação precisamos saber basicamente qual é o tipo organização interna do componente, sendo eles:

1. Linhas (catodo comum) |  Colunas (anodo comum) - imagem à esquerda

2. Linhas (anodo comum)  |  Colunas (catodo comum) - imagem à direita

Obs.: Para você saber qual é a organização interna da matriz de leds é necessário conhecer o datasheet do componente ou fazer um teste prático para identificação que mostraremos mais abaixo neste artigo.

Observações:

1. Neste projeto utilizamos uma matriz de leds 8 X 8, modelo 1088AS  com organização interna Linhas (catodo comum) |  Colunas (anodo comum).

2. Se você utilizar uma matriz com outro tipo organização interna, ou seja, Linhas (anodo comum)  |  Colunas (catodo comum), mostraremos como adaptar os códigos para o uso correto neste tipo de componente.

3. Você poderá utilizar no projeto matriz 8 X 8 com leds de 3 mm ou leds de 5 mm de qualquer cor ou dimensão.

4. Leia também: Como declarar e utilizar arrays no Arduino - Vetores e Matrizes

Aplicação

Para fins didáticos e projetos com efeitos visuais, exibição de textos, imagens ou números.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		No mínimo utilizar protoboard com 830 pontos
Jumpers	Kit cabos ligação macho / macho	1
Matriz de led	Matrix de LED 8 X 8 modelo 1088AS			Cor emissão do led: vermelha Tipo: Linhas catodo / Colunas anodo Tensão de operação: 2,1V - 2,5V Corrente máxima: 20mA Dimensão led: 3mm (datasheet) Poderá ser utilizado qualquer modelo de matriz 8 X 8
Resistor	Resistor de 150Ω	8		Resistor de 150Ω ou superior
Arduino UNO R3	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito.

imagem obtida do blog Master Walker Shop

Atenção

1. Para a montagem da matriz de leds 8 X 8 é necessário primeiro encontrar a posição correta da matriz. Geralmente a parte de baixo da matriz, onde estão os pinos de 1 a 8, está identificada com o modelo impresso e/ou alguma identificação no componente.

2. Após conhecer a posição correta da matriz faça as conexões com o Arduino, conforme tabela abaixo:

Obs1: Não esqueça de colocar resistores nas linhas da matriz, ou seja, pinos 9, 14, 8, 12, 1, 7, 2 e 5. O resistor deverá ser de 150Ω ou superior.

Obs2: Os pinos 14, 15, 16 e 17 do Arduino UNO são referentes aos pinos A0, A1, A2, A3 do microcontrolador. Lembre-se que os pinos analógicos também podem ser pinos digitais quando definidos pela programação.

Obs3: Não utilizamos os pinos 0 e 1 do Arduino UNO para evitarmos conflitos no upload e na comunicação serial.

3. Para facilitar a montagem da matriz de leds, recomendo que use 2 protoboards em paralelo, como mostra a figura abaixo:

4. Caso não tenha 2 protoboards, proceda da seguinte forma:

4.1. Conecte cabos para conectar os pinos da matriz com trilhas fora da matriz.

4.2. Após ter conectado os cabos, encaixe a matriz:

5. Conhecendo as características da matriz podemos calcular o valor dos resistores, como sendo:

5.1. Dados da matriz utilizada no projeto (valores retirados da datasheet do componente utilizado):

• Tensão direta: 2,1 V (p/ segmento)
• Corrente máxima: 20 mA (p/ segmento)

5.2. Desta forma, utilizando-se a tensão de 5,0V do Arduino, pela lei de Ohms temos:

R = (5,0V - 2,1V) / 0,02A => R = 145 Ω => Portanto, por segurança, utilizaremos um resistor de no mínimo 150 Ω.

5.3 . Se você não tiver os dados do componente, utilize um resistor maior que 150 Ω. Lembre-se, quanto maior o valor do resistor menor será a intensidade do brilho dos leds da matriz.

Atenção: Para evitar danos no componente, não utilize resistores menores que 150 Ω. Para saber mais como calcular o resistor, leia Teste 02 - Leds ligados em série e em paralelo.

 6. Veja abaixo como realizamos a montagem do nosso projeto utilizando dois protoboards.

Entendendo como funciona uma matriz de leds - I

1. A matriz de leds funciona com o cruzamento entre colunas e linhas, onde podemos acender os leds das colunas e apagar os leds das linhas.

2. No exemplo abaixo vamos acender os leds da coluna 2 e apagar os leds da linha 2.

/*******************************************************************************
*
*               Como funciona uma matrix de leds 8X8
*                  http://squids.com.br/arduino
*
*******************************************************************************/
int linhas[8] = {13, 8, 17, 10, 5, 16, 4, 14}; // Pinos que controlam as linhas
int colunas[8] = {9, 3, 2, 12, 15, 11, 7, 6}; // Pinos que controlam as colunas 

//  CATODO COMUM - LINHA | ANODO COMUM - COLUNA
byte ON = 1, OFF = 0;
// ANODO COMUM - LINHA | CATODO COMUM - COLUNA
//byte ON = 0, OFF = 1;

void setup() {
  for (int i = 2; i < 18; i++) { // Vai de 2 até 17 definindo os pinos como saida
    pinMode(i, OUTPUT);
  }
} 

void loop() {
  digitalWrite(colunas[1],ON); // COLUNA 2
  digitalWrite(linhas[1], ON); // LINHA 2
  delay(10);  
}

 2.1. Primeiro definimos o array's linhas[] e colunas[] onde definimos os pontos que controlam as linhas e colunas da matriz.

2.2. Agora defina o tipo de organização interna da matriz de leds que você estiver utilizando. O código apresentado acima foi criado para uma matriz tipo "linhas (catodo comum) |  colunas (anodo comum)".

2.2.1. Se você tiver uma matriz de leds tipo "linhas (anodo comum) |  colunas (catodo comum)" basta colocar as duas barras de comentários na linha 11 e retirar a barra de comentários da linha 13.

2.2.2. Se você não sabe qual o tipo da sua matriz de leds, teste o código acima para os dois tipos.

2.3. Através da função pinMode() defina os pinos 2 ao 17 como OUTPUT. Desta forma, em um Arduino UNO, os pinos analógicos A0, A1, A2 e A3 passam a funcionar como pinos digitais 14, 15, 16 e 17.

2.4. Na estrutura void loop() vamos dizer para o Arduino:

2.4.1. Ligar a coluna 2 - digitalWrite(colunas[1], ON); -  acende a coluna 2.

Obs.: No array os seletores da variável começam com zero. Portanto a coluna 1 seria colunas[0].

2.4.2. Ligar a linha 2 - digitalWrite(linhas[1], ON); -  apaga a linha 2.

2.4.3. A pausa de 10ms - delay(10); - é muito importante para evitar interferência entre os leds. Este pequeno delay é imperceptível para os nossos olhos mas gera um resultado permanente. Para verificar isso, teste o código com e sem o delay.

3. Veja como deverá ser a exibição correta da matriz de leds em função do código de teste acima:

Obs.: Se a configuração dos leds da sua matriz for diferente da imagem abaixo, verifique o tipo da matriz ou se a conexão da coluna 2 e da linha 2 estão corretas.

Entendendo como funciona uma matriz de leds - II

1. Imagine agora que queremos que a coluna 3 se acenda mas só o led da linha 8 se apague.

2. Para isto, precisaremos criar uma função para desligar todas linhas e colunas. Veja o exemplo abaixo:

/*******************************************************************************
*
*               Como funciona uma matriz de leds 8X8
*                  http://squids.com.br/arduino
*
*******************************************************************************/
int linhas[8] = {13, 8, 17, 10, 5, 16, 4, 14}; // Pinos que controlam as linhas
int colunas[8] = {9, 3, 2, 12, 15, 11, 7, 6}; // Pinos que controlam as colunas 

//  CATODO COMUM - LINHA | ANODO COMUM - COLUNA
byte ON = 1, OFF = 0;
// ANODO COMUM - LINHA | CATODO COMUM - COLUNA
//byte ON = 0, OFF = 1;

void setup() {
  for (int i = 2; i < 18; i++) { // Vai de 2 até 17 definindo os pinos como saida
    pinMode(i, OUTPUT);
  }
} 

void loop() {
  digitalWrite(colunas[1],ON); // COLUNA 2
  digitalWrite(linhas[1],ON); // LINHA 2
  delay(10);
  desligar();
  digitalWrite(colunas[2],ON); // COLUNA 3
  digitalWrite(linhas[7],ON); // LINHA 8
  delay(10);
  desligar();   
}


void desligar() {
  for (int i=0;i<8;i++) { // 
    digitalWrite(linhas[i],OFF);
  }
  for (int i=0;i<8;i++) { // 
    digitalWrite(colunas[i],OFF);
  } 
}

2.1. A função desligar() desliga todas as linhas e colunas da matriz. Assim você pode criar rotinas para cada coluna:

2.1.1. Rotina para a coluna 2:

 2.1.2. Rotina para a coluna 3:

 2.2. Criando as rotinas para cada coluna, você poderá criar a imagem que desejar.

3. Veja como deverá ser a exibição correta da matriz de leds em função do código de teste acima:

Obs.: Se a configuração dos leds da sua matriz for diferente da imagem abaixo, verifique o tipo da matriz ou se a conexão da coluna 2 e da linha 2 estão corretas.

Verificando as conexões da matriz

Agora que sabemos mais como funciona uma matriz de leds, vamos verificar se todas as colunas e linhas foram conectadas corretamente no Arduino para continuarmos:

/*******************************************************************************
*
*               Testar conexção matriz de leds 8X8
*                  http://squids.com.br/arduino
*
*******************************************************************************/
int linhas[8] = {13, 8, 17, 10, 5, 16, 4, 14}; // Pinos que controlam as linhas
int colunas[8] = {9, 3, 2, 12, 15, 11, 7, 6}; // Pinos que controlam as colunas 

//  CATODO COMUM - LINHA | ANODO COMUM - COLUNA
byte ON = 1, OFF = 0;
// ANODO COMUM - LINHA | CATODO COMUM - COLUNA
//byte ON = 0, OFF = 1;

void setup() {
  for (byte i = 2; i < 18; i++) { // Vai de 2 até 17 definindo os pinos como saida
    pinMode(i, OUTPUT);
  }
} 

void loop() {
  for (byte j=0;j<8;j++) {
    digitalWrite(colunas[j],ON);
    delay(1000);
    }
  for (byte j=0;j<8;j++) {
    digitalWrite(linhas[j],ON);
    delay(1000);
    }

  desligar();

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

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

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

  desligar(); 
}


void desligar() {
  for (int i=0;i<8;i++) { // 
    digitalWrite(linhas[i],OFF);
  }
  for (int i=0;i<8;i++) { // 
    digitalWrite(colunas[i],OFF);
  } 
}

 Veja o vídeo abaixo como a matriz de leds deverá se comportar no teste acima:

Entendendo como funciona uma matriz de leds - III

1. Avançando um pouco mais, imagine agora que queremos acender apenas os leds específicos: coluna 2 com linha 2, coluna 3 com linha 1 e coluna 4 com linha 2.

2. Para isto, podemos criar uma função para apagar todas as linhas. Veja o código do nosso exemplo abaixo:

/*******************************************************************************
*
*               Como funciona uma matriz de leds 8X8
*                  http://squids.com.br/arduino
*
*******************************************************************************/
int linhas[8] = {13, 8, 17, 10, 5, 16, 4, 14}; // Pinos que controlam as linhas
int colunas[8] = {9, 3, 2, 12, 15, 11, 7, 6}; // Pinos que controlam as colunas 

//  CATODO COMUM - LINHA | ANODO COMUM - COLUNA
byte ON = 1, OFF = 0;
// ANODO COMUM - LINHA | CATODO COMUM - COLUNA
//byte ON = 0, OFF = 1;

void setup() {
  for (int i = 2; i < 18; i++) { // Vai de 2 até 17 definindo os pinos como saida
    pinMode(i, OUTPUT);
  }
} 

void loop() {
  apagar();
  digitalWrite(colunas[1],ON); // COLUNA 2
  digitalWrite(linhas[1], OFF); // ACENDE A LINHA 2 (desliga)
  delayMicroseconds(20);
  apagar();
  digitalWrite(colunas[2],ON); // COLUNA 3
  digitalWrite(linhas[0],OFF); // ACENDE A LINHA 1 (desliga)
  delayMicroseconds(20);
  apagar();  
  digitalWrite(colunas[3],ON); // COLUNA 3
  digitalWrite(linhas[1],OFF); // ACENDE A LINHA (desliga)
  delayMicroseconds(20);
}


void apagar() {
  for (int i=0;i<8;i++) { // 
    digitalWrite(linhas[i],ON); // apaga todas linhas
  }
  for (int i=0;i<8;i++) { // 
    digitalWrite(colunas[i],OFF); // apaga todas colunas
  } 
}

2.1. A função apagar() apaga todas as linhas e as colunas da matriz. Da mesma forma que no exemplo anterior, podemos criar rotinas para cada coluna.

2.2.1. Rotina para a coluna 2.

 Obs.: Para obtermos um resultado satisfatório na visualização dos leds vamos utilizar a função delayMicroseconds(20) ao invés do delay(10). Esta pausa é suficiente para obtermos um ótimo resultado final. Para você ter uma ideia de tempo, 1.000 microssegundos equivale a 1 milissegundo. Para saber mais sobre a função delayMicroseconds leia: Referência Arduino - funação delayMicroseconds() e Como usar temporizadores no Arduino.

2.2.2. Rotina para a coluna 3.

2.2.3. Rotina para a coluna 4.

3. Veja como deverá ser a exibição correta da matriz de leds em função do código de teste acima:

Obs.: Se a configuração dos leds da sua matriz for diferente da imagem abaixo, verifique o tipo da matriz ou se a conexão das colunas 2, 3 e 4 e das linhas 1 e 2 estão corretas.

Desenhando uma letra

1. Agora que já sabemos dominar as colunas da matriz de leds, podemos criar desenhos, números letras e símbolos. Vamos iniciar desenhando a letra "M".

2. Para identificar as linhas e colunas de cada led aceso, utilizei o Led Matrix Editor:

3. Vamos utilizar no nosso exemplo a função apagar() que criamos no tópico acima - Entendendo como funciona uma matriz de leds - III. Desta forma, precisaremos informar o Arduino, através do cruzamento entre colunas e linhas, quais são os leds que deverão ficar acesos.

/*******************************************************************************
*
*               Desenhando a letra M em uma matriz de leds
*                     http://squids.com.br/arduino
*
*******************************************************************************/
int linhas[8] = {13, 8, 17, 10, 5, 16, 4, 14}; // Pinos que controlam as linhas
int colunas[8] = {9, 3, 2, 12, 15, 11, 7, 6}; // Pinos que controlam as colunas

//  CATODO COMUM - LINHA | ANODO COMUM - COLUNA
byte ON = 1, OFF = 0;
// ANODO COMUM - LINHA | CATODO COMUM - COLUNA
//byte ON = 0, OFF = 1;

void setup() {
  for (int i = 2; i < 18; i++) { // Vai de 2 até 17 definindo os pinos como saida
    pinMode(i, OUTPUT);
  }
} 

void loop() {
  int i, j;

  // letra M
  digitalWrite(colunas[0], ON); // COLUNA 1
  for(i=0;i<8;i++) {
    digitalWrite(linhas[i], OFF); // ACENDE TODAS LINHAS
  }
  delayMicroseconds(20);
  apagar();
  
  digitalWrite(colunas[1], ON); // COLUNA 2
  digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
  delayMicroseconds(20);  
  apagar();
  
  digitalWrite(colunas[2], ON); // COLUNA 3
  digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
  digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE) 
  delayMicroseconds(20); 
  apagar();
  
  digitalWrite(colunas[3], ON); // COLUNA 4
  digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
  digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
  delayMicroseconds(20);  
  apagar();
  
  digitalWrite(colunas[4], ON); // COLUNA 5
  digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
  digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
  delayMicroseconds(20);      
  apagar();
  
  digitalWrite(colunas[5], ON); // COLUNA 6
  digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
  digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)   
  delayMicroseconds(20); 
  apagar();
  
  digitalWrite(colunas[6], ON); // COLUNA 7
  digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
  delayMicroseconds(20);  
  apagar();
  
  digitalWrite(colunas[7], ON); // COLUNA 8
  for(i=0;i<8;i++) {
    digitalWrite(linhas[i], OFF); // ACENDE TODAS LINHAS
  }
  delayMicroseconds(20);
  apagar();
}

void apagar() {
  for (int i=0;i<8;i++) { // 
    digitalWrite(linhas[i],ON); // apaga todas linhas
  }
  for (int i=0;i<8;i++) { // 
    digitalWrite(colunas[i],OFF); // apaga todas colunas
  } 
}

4. Veja como deverá ser a exibição correta da matriz de leds em função do código de teste acima:

5. Dica: Para entender melhor o funcionamento da matriz de leds, recomendo que refaça o exemplo abaixo e crie a letra "M" utilizando a função desligar() que desenvolvemos no tópico Entendendo como funciona uma matriz de leds - II.  Neste caso, ao utilizarmos a função desligar() precisaremos informar o Arduino quais são os leds que deverão ficar apagados e não os leds que deverão ficar acesos.

4. Bom, agora finalmente vamos ao nosso projeto 68 que roda as letras da palavra SQUIDS. Todas as letras foram primeiramente desenhadas no Led Matrix Editor.

Sketch do projeto

1. Faça o dowload e abra o arquivo projeto68.ino no IDE do Arduino:  DOWNLOAD - projeto68.ino

Ou se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*             Projeto 68 - Usando uma matriz de leds com Arduino
*             Autor: Angelo Luis Ferreira
*             Data: 15/10/2019 (dd/mm/AA)
*                     http://squids.com.br/arduino*                     
*
*******************************************************************************/
int linhas[8] = {13, 8, 17, 10, 5, 16, 4, 14}; // Pinos que controlam as linhas
int colunas[8] = {9, 3, 2, 12, 15, 11, 7, 6}; // Pinos que controlam as colunas

//  CATODO COMUM - LINHA | ANODO COMUM - COLUNA
byte ON = 1, OFF = 0;
// ANODO COMUM - LINHA | CATODO COMUM - COLUNA
//byte ON = 0, OFF = 1;

void setup() {
  for (int i = 2; i < 18; i++) { // Vai de 2 até 17 definindo os pinos como saida
    pinMode(i, OUTPUT);
  }
} 

void loop() {
  int i, j;

    for (i=0; i<1000; i++) {
    //letra S
    digitalWrite(colunas[2], ON); // COLUNA 3
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)  
    delayMicroseconds(20); 
    apagar();

    digitalWrite(colunas[3], ON); // COLUNA 4
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20); 
    apagar();

    digitalWrite(colunas[4], ON); // COLUNA 5
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[5], ON); // COLUNA 6
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[6], ON); // COLUNA 7
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    delayMicroseconds(20);  
    apagar();  
  } 

  for (i=0; i<1000; i++) {
    //letra Q    
    digitalWrite(colunas[2], ON); // COLUNA 3
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    delayMicroseconds(20);
    apagar();

    digitalWrite(colunas[3], ON); // COLUNA 4
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE))
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[4], ON); // COLUNA 5
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)    
    delayMicroseconds(20); 
    apagar();

    digitalWrite(colunas[5], ON); // COLUNA 6
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE))
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[6], ON); // COLUNA 7
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 6 (ACENDE)
    delayMicroseconds(20); 
    apagar();
  }

   for (i=0; i<1000; i++) {
    //letra U   
    digitalWrite(colunas[2], ON); // COLUNA 3
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    delayMicroseconds(20); 
    apagar();

    digitalWrite(colunas[3], ON); // COLUNA 4
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE))
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[4], ON); // COLUNA 5
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)    
    delayMicroseconds(20); 
    apagar();

    digitalWrite(colunas[5], ON); // COLUNA 6
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE))
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[6], ON); // COLUNA 7
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    delayMicroseconds(20); 
    apagar();
  } 

  for (i=0; i<1000; i++) {
    //letra I
    delayMicroseconds(20);  // coluna 3 - para manter o mesmo temo das outras letras
    apagar();
      
    digitalWrite(colunas[3], ON); // COLUNA 4
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[4], ON); // COLUNA 5
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[5], ON); // COLUNA 6
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20); 
    apagar();

    delayMicroseconds(20);  // coluna 7 - para manter o mesmo temo das outras letras
    apagar();
    
  }

  for (i=0; i<1000; i++) {
    //letra D
    digitalWrite(colunas[2], ON); // COLUNA 3   
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20); 
    apagar();

    digitalWrite(colunas[3], ON); // COLUNA 4
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE))
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[4], ON); // COLUNA 5
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE))    
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[5], ON); // COLUNA 6
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE))
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[6], ON); // COLUNA 7
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    delayMicroseconds(20);
    apagar();
  }

  for (i=0; i<1000; i++) {
    //letra S
    digitalWrite(colunas[2], ON); // COLUNA 3
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)  
    delayMicroseconds(20);
    apagar();

    digitalWrite(colunas[3], ON); // COLUNA 4
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[4], ON); // COLUNA 5
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20); 
    apagar();

    digitalWrite(colunas[5], ON); // COLUNA 6
    digitalWrite(linhas[0], OFF); // LINHA 1 (ACENDE)
    digitalWrite(linhas[3], OFF); // LINHA 4 (ACENDE)
    digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
    delayMicroseconds(20);  
    apagar();

    digitalWrite(colunas[6], ON); // COLUNA 7
    digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
    digitalWrite(linhas[4], OFF); // LINHA 5 (ACENDE)
    digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
    delayMicroseconds(20); 
    apagar();  
  } 

  for (i=0;i<1000;i++) {
  //emotion  
  digitalWrite(colunas[0], ON); // COLUNA 1 (ACENDE)
  digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
  delayMicroseconds(20);
  apagar();
  
  digitalWrite(colunas[1], ON); // COLUNA 2
  digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
  digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
  digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
  delayMicroseconds(20);  
  apagar();
  
  digitalWrite(colunas[2], ON); // COLUNA 3
  digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
  digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
  digitalWrite(linhas[7], OFF); // LINHA 8 (ACENDE)
  delayMicroseconds(20); 
  apagar();
  
  digitalWrite(colunas[3], ON); // COLUNA 4
  digitalWrite(linhas[7], OFF); // LINHA 8 (ACENDE)
  delayMicroseconds(20);  
  apagar();
  
  digitalWrite(colunas[4], ON); // COLUNA 5
  digitalWrite(linhas[7], OFF); // LINHA 8 (ACENDE)
  delayMicroseconds(20);;      
  apagar();
  
  digitalWrite(colunas[5], ON); // COLUNA 6
  digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
  digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
  digitalWrite(linhas[7], OFF); // LINHA 8 (ACENDE)  
  delayMicroseconds(20);
  apagar();
  
  digitalWrite(colunas[6], ON); // COLUNA 7
  digitalWrite(linhas[1], OFF); // LINHA 2 (ACENDE)
  digitalWrite(linhas[2], OFF); // LINHA 3 (ACENDE)
  digitalWrite(linhas[6], OFF); // LINHA 7 (ACENDE)
  delayMicroseconds(20);  
  apagar();
  
  digitalWrite(colunas[7], ON); // COLUNA 8
  digitalWrite(linhas[5], OFF); // LINHA 6 (ACENDE)
  delayMicroseconds(20);
  apagar();        
  }
}

void apagar() {
  for (int i=0;i<8;i++) { // 
    digitalWrite(linhas[i],ON); // apaga todas linhas
  }
  for (int i=0;i<8;i++) { // 
    digitalWrite(colunas[i],OFF); // apaga todas colunas
  } 
}

ATENÇÃO: Se a matriz de leds não acender verifique todas as conexões com o Arduino.

Vídeo

Como o projeto deve funcionar

1. Ao iniciar o programa, a matriz de leds irá exibir as letras da palavra SQUIDS a cada segundo.

Desafios

Com base neste projeto, resolva o seguinte desafio: Desafio 55

Comentários