Controle de Matriz de LEDs Com Poteciômetros

Controle de Matriz de LEDs Com Poteciômetros

Neste post vamos rever um projeto para controle da matriz 8×8 da Wantronics. Vamos fazer o controle de matriz de LEDs com poteciômetros.

No vídeo a seguir são mostrados detalhes do projeto.

Material Utilizado

Em nosso projeto utilizamos as seguintes partes:
1 placa matriz de LEDs Wantronics;
1 Arduino Uno;
2 Potenciômetros de 5k

Podem ser utilizados outros microcontroladores para o controle da matriz de LEDs.

Diagrama esquemático

Na tabela abaixo são mostrados as ligações entre o Arduino e a matriz de LEDs 8×8:

Tabela com a ligação da matriz de LEDs Wantronics ao Arduino UNO

E na figura a seguir é apresentado o diagrama esquemático do circuito.

LEDsDescarregar

Código

Abaixo é mostrado o código utilizado no vídeo:

/*
 * Ligação das linhas da matriz no Hardware do Arduino
 * L1 -> D0; L8 -> D7
 * 
 * Ligação das colunas da matriz no Hardware do Arduino
 * C1 -> 8; C6 -> 13/ C7 - A0; C87 - A1
 * 
 */
  
// Linhas
#define row1 0
#define row2 1
#define row3 2
#define row4 3
#define row5 4
#define row6 5
#define row7 6
#define row8 7
  
// Colunas
#define column1 8
#define column2 9
#define column3 10
#define column4 11
#define column5 12
#define column6 13
#define column7 A0
#define column8 A1
  
// Variáveis para os laços de repetição
int i = 0;
int j = 0;
 
// Variáveis que recebem valor do ADC
int x = 0;
int y = 0;
 
// Variável de deslocamento do LED na matriz
int xi = 0;
int yi = 0;
 
// Variáveis das linhas e colunas
int row[] = {row1, row2, row3, row4, row5, row6, row7, row8};
int column[] = {column1, column2, column3, column4, column5, column6, column7, column8};
  
// Displays numbers
int matrix[8][8] = { // A  B  C  D  E  F  G
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                  };
 
void setup() {
  // Configuração dos GPIOs como saídas
  pinMode (row1, OUTPUT);
  pinMode (row2, OUTPUT);
  pinMode (row3, OUTPUT);
  pinMode (row4, OUTPUT);
  pinMode (row5, OUTPUT);
  pinMode (row6, OUTPUT);
  pinMode (row7, OUTPUT);
  pinMode (row8, OUTPUT);
  
  pinMode (column1, OUTPUT);
  pinMode (column2, OUTPUT);
  pinMode (column3, OUTPUT);
  pinMode (column4, OUTPUT);
  pinMode (column5, OUTPUT);
  pinMode (column6, OUTPUT);
  pinMode (column7, OUTPUT);
  pinMode (column8, OUTPUT);
   
   
  // Laço que limpa a matriz
  for (i = 0; i < 8; i++) {
    digitalWrite (row[i], LOW);
    digitalWrite (column[i], HIGH);
  }
}
  
void loop() {
  // Leitura dos canais ADC
  x = analogRead (A3);
  y = analogRead (A4);
   
  // Cursor X
  if ((x >= 0) && (x < 128)) {
    xi = 0;
  }
  else if ((x >= 128) && (x < 256)) {
    xi = 1;
  }
  else if ((x >= 256) && (x < 384)) {
    xi = 2;
  }
  else if ((x >= 384) && (x < 512)) {
    xi = 3;
  }
  else if ((x >= 512) && (x < 640)) {
    xi = 4;
  }
  else if ((x >= 640) && (x < 768)) {
    xi = 5;
  }
  else if ((x >= 768) && (x < 896)) {
    xi = 6;
  }
  else if ((x >= 896) && (x < 1023)) {
    xi = 7;
  }
   
  // Cursor Y
  if ((y >= 0) && (y < 128)) {
    yi = 0;
  }
  else if ((y >= 128) && (y < 256)) {
    yi = 1;
  }
  else if ((y >= 256) && (y < 384)) {
    yi = 2;
  }
  else if ((y >= 384) && (y < 512)) {
    yi = 3;
  }
  else if ((y >= 512) && (y < 640)) {
    yi = 4;
  }
  else if ((y >= 640) && (y < 768)) {
    yi = 5;
  }
  else if ((y >= 768) && (y < 896)) {
    yi = 6;
  }
  else if ((y >= 896) && (y < 1023)) {
    yi = 7;
  }
   
  // Displays numbers
  int matrix[8][8] = { // A  B  C  D  E  F  G
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0},
                  };
   
  matrix[yi][xi] = 1;
   
  for (j = 0; j < 8; j++){
    digitalWrite (row[j], HIGH);
    for (i = 0; i < 8; i++){
      digitalWrite (column[i], !matrix[j][i]);
    }
    for (i = 0; i < 8; i++){
      digitalWrite (column[i], HIGH);
    }
    digitalWrite (row[j], LOW);
  }
    
 // Laço que faz com que limpa a matriz
  for (i = 0; i < 8; i++) {
    digitalWrite (row[i], LOW);
    digitalWrite (column[i], HIGH);
  }
}

Simulação

Abaixo é possível fazer a simulação do circuito.

Conclusão

Neste post vimos o Controle de Matriz de LEDs Com Poteciômetros, revisitamos um projeto anterior e apresentamos mais detalhes a respeito do mesmo.

Isso é tudo pessoal, e até o próximo post!