Controle de matrizes de LED com Arduino

Igor Albuquerque
2 Comentários
matrizes

Este artigo mostra como controlar um array de matrizes de 8×8 LEDs utilizando o Arduino Uno. Esse tutorial pode ser usado para criação de um display simples (e relativamente barato) para exibição de letras, números e animações personalizadas.

Esse método tem sido aplicado no projeto de robótica “Robô da Alegria”, que visa desenvolver um robô para interação com crianças em ambiente hospitalar. Mais informações sobre o projeto podem ser obtidas através dos links abaixo:

https://hackaday.io/project/12873-rob-da-alegria-joy-robot
https://www.hackster.io/igorF2/robo-da-alegria-joy-robot-85e178
https://github.com/RoboAlegria/RoboAlegria
https://www.facebook.com/robodaalegria

Agradecimentos especiais à equipe envolvida no projeto, que participou da concepção e desenvolvimento deste artigo:

 

Materiais utilizados

Para esse projeto os seguintes componentes foram utilizados:

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA
  • Arduino Uno – placa de microcontrolador baseado no ATmega328, com 14 pinos de entradas/saídas digitais, 6 entradas analógicas, conexão USB (Figura 1);
  • Matriz de LEDs 8×8 com driver MAX7219 driver (x5) (Figura 2);
  • Jumpers fêmea-fêmea (4 jumpers de 5 cabos cada) (Figura 3);
  • Jumpers macho-fêmea  (1 jumper de 5 cabos) (Figura 4);
  • Placa de acrílico de 2mm para fixação dos componentes (opcional) (Figura 5);
  • Parafusos M2 x 10mm (x20) para fixação dos componentes (opcional) (Figura 6);
  • Porcas M2 x 1,5mm (x20) para fixação dos componentes (opcional) (Figura 7);
  • Um computador (para compilar e fazer o upload do código para o Arduino).
matrizes-LED-1
Figura 1 – Arduino Uno.
matrizes-LED-2
Figura 2 – Matriz de LEDs.
 
matrizes-LED-3
Figura 3 – Jumpers fêmea-fêmea.
matrizes-LED-4
Figura 4 – Jumpers macho-fêmea.
 
matrizes-LED-5
Figura 5 – Placa de acrílico de 2mm.
Figura 6 – Parafusos M2 x 10mm.
 
matrizes-LED-7
Figura 7 – Porcas M2 x 1,5mm.

Os jumpers fêmea-fêmea são utilizados para conexão entre as matrizes de LED, enquanto o jumper macho-fêmea é utilizado para conectar a primeira matriz de LEDs ao Arduino Uno.

O número de componentes pode variar em função da estrutura a ser montada. Não é necessária a utilização de ferramentas específicas para conceber este projeto, além disso, os materiais citados podem ser encontrados facilmente.

Montagem das  matrizes

Conecte todos os componentes de acordo com o esquemático apresentado nas Figura 8, 9 e 10.

Pinagem do Arduino:

  • Pino digital 13: conectar ao DIN do primeiro display
  • Pino digital 12: conectar ao CLK do primeiro display
  • Pino digital 11: conectar ao CS do primeiro display
  • Pino de 5V do Arduino: conectar ao Vcc do primeiro display
  • Pino de GND do Arduino: conectar ao Gnd do primeiro display
matrizes-LED-8
Figura 8 – Interligação entre Arduino Uno e cinco matrizes de LED.
matrizes-LED-9
Figura 9 – Detalhe da conexão do Arduino Uno à primeira matriz de LEDs.
matrizes de LED
Figura 10 – Detalhe da Interligação entre as matrizes de LED.

Caso desejado, pode-se fixar a posição dos displays utilizando uma placa de acrílico, alguns parafusos e porcas (quatro para cada display). Nenhuma ferramenta será necessária para a montagem do circuito, porém pode ser necessário uma chave Philips e furadeira ou ferramenta de corte para fixação dos displays.

No exemplo deste artigo, cinco displays foram arranjados na forma de rosto (dois olhos e uma boca), conforme exemplo da Figura 11.

matrizes-LED-11
Figura 11 – Montagem das matrizes de LED em placa de acrílico.

O Arduino Uno pode ser alimentado conectando-o a um computador por meio de um cabo USB tipo B, através de uma fonte externa ou bateria.

Programação do Arduino

Com a versão mais recente do IDE do Arduino instalada, adicione a biblioteca LedControl.h, utilizada para controle das matrizes de LED, e faça o download e upload do código para o Arduino.

O código é dividido em quatro partes:

  1. Definição dos olhos e boca: cada olho é configurado como um array de 8 bytes. A boca é definida como um array de 24 bytes;
    2. Setup: configuração dos displays e inicialização da comunicação;
    3. Loop: espera dos comandos pela porta serial e escolha da face a ser apresentada;
    4. Funções auxiliares: funções para configuração dos displays de olhos e boca.
// LED display v1.0 por Igor Fonseca Albuquerque, Thiago Farrauche, Diego Augustus e Yhan Christian

//incluir bibliotecas
#include "LedControl.h"

LedControl lc = LedControl(13,12,11,5); //Pino 13 = DIN, Pino 12 = CLK, Pino 11 = CS. 5 = número de displays

//************************
//  Definição das faces
//************************

// olho neutro
byte neutral_eye[8] = {B00000000,
                       B00011000,
                       B00111100,
                       B01111110,
                       B01111110,
                       B00111100,
                       B00011000,
                       B00000000};

// olho esbugalhado
byte spooky_eye[8] = {B00111100,
                      B01111110,
                      B11111111,
                      B11111111,
                      B11111111,
                      B11111111,
                      B01111110,
                      B00111100};

// olho fechado (para cima)
byte closed_eye_up[8] = {B00000000,
                         B00001100,
                         B00011000,
                         B00011000,
                         B00011000,
                         B00011000,
                         B00001100,
                         B00000000};
                        
// olho fechado (para baixo)
byte closed_eye_down[8] ={B00000000,
                          B00001100,
                          B00001100,
                          B00000110,
                          B00000110,
                          B00001100,
                          B00001100,
                          B00000000};                        

// boca feliz            //parte 1 
byte happy_mouth[24] = { B00000000,
                         B00000000,
                         B00000000,
                         B00000000,
                         B01100000,
                         B00110000,
                         B00011000,
                         B00001100,    
                         //parte 2
                         B00001110,
                         B00000110,
                         B00000110,
                         B00000110,
                         B00000110,
                         B00000110,
                         B00000110,
                         B00001100,
                         //parte 3 
                         B00001100,
                         B00011000,
                         B00110000,
                         B01100000,
                         B00000000,
                         B00000000,
                         B00000000,
                         B00000000 };
                         
                                                  
// boca triste           //parte 1
byte sad_mouth[24] = {   B00000000,
                         B00000000,
                         B00000000,
                         B00000000,
                         B00000110,
                         B00001100,
                         B00011000,
                         B00110000,
                         //parte 2
                         B00110000,
                         B01100000,
                         B01100000,
                         B01100000,
                         B01100000,
                         B01100000,
                         B01100000,
                         B00110000,
                         //parte 3
                         B00110000,
                         B00011000,
                         B00001100,
                         B00000110,
                         B00000000,
                         B00000000,
                         B00000000,
                         B00000000 };

// boca muito feliz           //parte 1
byte very_happy_mouth[24] = { B00000000,
                              B00000000,
                              B01110000,
                              B01111100,
                              B01100110,
                              B01100110,
                              B01100011,
                              B01100011,
                              //parte 2
                              B01100011,
                              B01100011,
                              B01100011,
                              B01100011,
                              B01100011,
                              B01100011,
                              B01100011,
                              B01100011,                        
                              //parte 3
                              B01100011,
                              B01100011,
                              B01100110,
                              B01100110,
                              B01111100,
                              B01110000,
                              B00000000,
                              B00000000 };                         
                         
// boca neutra                //parte 1
byte neutral_mouth[24] = {    B00000000,
                              B00000000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              //parte 2
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              //parte 3
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00010000,
                              B00000000,
                              B00000000 };
                         
// língua para fora      //parte 1
byte tongue_mouth[24] = {B00000000,
                         B00000000,
                         B00000100,
                         B11001110,
                         B01111110,
                         B00111110,
                         B00011100,
                         B00001100,    
                         //parte 2
                         B00001110,
                         B00000110,
                         B00000110,
                         B00000110,
                         B00000110,
                         B00000110,
                         B00000110,
                         B00001100,
                         //parte 3 
                         B00001100,
                         B00011000,
                         B00110000,
                         B01100000,
                         B00000000,
                         B00000000,
                         B00000000,
                         B00000000 };

// boca aberta             //parte 1
byte opened_mouth[24] = {  B00000000,
                           B00000000,
                           B00000000,
                           B00000000,
                           B00000000,
                           B00000000,
                           B00000000,
                           B00000000,
                           //parte 2
                           B00000000,
                           B00011100,
                           B00100010,
                           B01000001,
                           B01000001,
                           B00100010,
                           B00011100,
                           B00000000,
                           //parte 3
                           B00000000,
                           B00000000,
                           B00000000,
                           B00000000,
                           B00000000,
                           B00000000,
                           B00000000,
                           B00000000 };

//*****************
// Setup do Arduino
//*****************
void setup()
{
  //inicializar displays (configurar a intensidade de brilho e limpar tudo)
  lc.shutdown(0,false);
  lc.setIntensity(0,1);
  lc.clearDisplay(0);
  lc.shutdown(1,false);
  lc.setIntensity(1,1);
  lc.clearDisplay(1);
  lc.shutdown(2,false);
  lc.setIntensity(2,1);
  lc.clearDisplay(2);
  lc.shutdown(3,false);
  lc.setIntensity(3,1);
  lc.clearDisplay(3);
  lc.shutdown(4,false);
  lc.setIntensity(4,1);
  lc.clearDisplay(4);
 
  //iniciar comunicação serial
  Serial.begin(19200);
  
}

//***************
// Loop principal
//***************
void loop()
{
  
  if (Serial.available())  //verificar se foi recebido algum dado
  {
    char cmd = Serial.read();
                
    if(cmd == ':') {
      display_eyes(neutral_eye, neutral_eye);
    }
    if(cmd == ';') {
      display_eyes(neutral_eye, closed_eye_up);
    }
    if(cmd == '8') {
      display_eyes(spooky_eye, spooky_eye);
    }
    if(cmd == ')'){
      display_mouth(happy_mouth);
    }    
    if(cmd == '('){
      display_mouth(sad_mouth);
    }    
    if((cmd == 'D')||(cmd == 'd')){
      display_mouth(very_happy_mouth);
    }
    if((cmd == 'p')||(cmd == 'P')){
      display_mouth(tongue_mouth);
    }    
    if((cmd == 'o')||(cmd == 'O')){
      display_mouth(opened_mouth);
    }    
    if(cmd == '|'){
      display_mouth(neutral_mouth);
    }    

  }
}


//*******************
// Funções auxiliares
//*******************

//mudar olhos
void display_eyes(byte right_eye[], byte left_eye[]) {
  for(int i=0;i<8;i++) {
   lc.setRow(0,i,left_eye[i]);
   lc.setRow(1,i,right_eye[i]);
  } 
}


//mudar boca
void display_mouth(byte mouth[]) {
  for(int i=0;i<8;i++) {
    lc.setRow(2,i,mouth[i]);
    lc.setRow(3,i,mouth[i+8]);
    lc.setRow(4,i,mouth[i+16]);
  }
}

A função setRow foi usada para definir o estado dos LEDs de cada linha. Essa função foi utilizada ao invés da setColumn pois roda oito vezes mais rápido. Dessa forma, as matrizes que representam cada um dos desenhos dos displays tiveram que ser declarados rotacionados de 90 graus no sentido horário.

Os bits definidos como “0” representam os LEDs que permanecerão desligados, enquanto os bits com “1” indicam os LEDs que serão acesos quando a face for selecionada.

matrizes-LED-12
Figura 12 – Exemplo da codificação das imagens nos displays.

A função setIntensity foi utilizada para limitar o brilho dos LEDs, sendo configurada em 1 (em uma escala que vai de 0 a 15), a fim de reduzir o consumo de corrente dos módulos a um nível aceitável pela saída do regulador de tensão de 5V do Arduino.

Utilização

Após o upload do código, mantenha o Arduino conectado a porta USB do seu computador e abra o Serial Monitor.

O código é programada para apresentar um conjunto de emoticons na face composta pelas matrizes de LEDs, dependendo da mensagem recebida na porta serial.

Os seguintes comandos foram configurados:

Para os olhos:

  • : (olhos normais)
  • ; (piscando o olho)
  • 8 (olhos espantados)

Para a boca:

  • ) (feliz)
  • | (neutra)
  • ( (triste)
  • D or d (muito feliz)
  • O or o (supresa)
  • P or p (língua para fora)

Digite um par de caracteres (um para os olhos e outro para a boca) no Serial Monitor, aperte enter (ou enviar) e o display será atualizado de acordo com o comando recebido.

Você pode mudar os desenhos (adicionando novas faces, por exemplo) ou mudar o método de controle (incluindo uma interface Bluetooth ou Wi-Fi), de acordo com a sua necessidade.

matrizes-LED-13
Figura 13 – Exemplo das imagens apresentadas nos displays.

Referências

Igor Albuquerque
4 posts
Licença Creative Commons Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.
Comentários:
Notificações
Notificar
2 Comentários
recentes
antigos mais votados
Inline Feedbacks
View all comments
Héctor Muñoz Hidalgo
Héctor Muñoz Hidalgo
12/03/2020 06:18

Hola , probé el código y las conexiones que están bien ensambladas, tal como las imágenes, y los mismos componentes pero no puedo hacer correr el código.
Realizó todas las conexiones
Luego cargo el código al Arduino
Y lo alimento con el mismo PC y no funciona
Lo alimento con batería externa y nada.
Lo de monitor de serie no entiendo eso. Quizás esa es la falla mía??
Espero puedan ayudarme. Gracias

9
Pedro
Pedro
03/03/2017 22:19

Muito massa…adorei o projeto 😀

-24
Hardware, Maker, Placas de desenvolvimento
Arduino
Home » Arduino » Controle de matrizes de LED com Arduino

EM DESTAQUE

WEBINARS

VEJA TAMBÉM

JUNTE-SE HOJE À COMUNIDADE EMBARCADOS

Fazer Parte
Talvez você goste:

E-books

Usamos cookies em nosso site para fornecer a você a experiência mais relevante, lembrando suas preferências e visitas repetidas. Ao clicar em “Aceitar”, concorda com a utilização de TODOS os cookies. Termos de Uso