Construa uma Matriz LED Scrolling 48x8 com Arduino – Guia Passo a Passo
Componentes e Materiais
| Componente | Quantidade | Observações |
|---|---|---|
| Arduino UNO | 1 | |
| 74HC595 Registrador de Deslocamento Serial para Paralelo 8 bits | 7 | |
| Resistor 475 ohm | 56 | |
| Header Macho 40 Posições 1 Linha (0.1") | 2 | |
| Header Fêmea 8 Posições 1 Linha (0.1") | 21 | |
| Placa PCB de uso geral 6"x4" | 4 | |
| Matriz LED 8X8 | 6 | |
| Transistor BC 548 | 1 |
Ferramentas e Máquinas Necessárias
- Ferro de solda (genérico)
- Pistola de cola quente (genérica)
- Multímetro Digital Autorange Digilent Mastech MS8217
Aplicativos e Serviços Online
- Arduino IDE
Sobre o Projeto
Olá a todos!
Este projeto é sobre fazer uma Matriz LED Programável Scrolling 48x8 usando um Arduino UNO e registradores de deslocamento 74HC595.
Este foi meu primeiro projeto com uma placa de desenvolvimento Arduino. Foi um desafio dado pelo meu professor para tentar construir um. Na época que aceitei o desafio, eu nem sabia como piscar um LED usando um Arduino. Então, acho que até um iniciante pode fazer isso com um pouco de paciência e compreensão. Encontrei o diagrama do circuito online e essa foi minha única referência para construir este projeto. Comecei com uma pequena pesquisa sobre registradores de deslocamento e multiplexação no Arduino.
O Circuito

Reunindo Componentes
Reuni todos os componentes de diferentes fontes. Consegui este display de matriz LED 8x8 cátodo comum de 5mm de um site online.

Construindo o Protótipo
Como mostrado no circuito, um único registrador de deslocamento é usado para controlar as 8 linhas e, para controlar as colunas, usamos um registrador de deslocamento para cada 8 colunas.
Então, se você consegue fazer uma simples matriz 8x8, pode simplesmente replicar a parte do circuito para controle de colunas e estender a matriz para qualquer número de colunas. Você só precisa adicionar um 74HC595 para cada 8 colunas (um módulo 8x8) que adicionar ao circuito. Mantendo isso em mente, fiz meu protótipo 8x8.

Estágio de Soldagem
Usei placas de pontilhado separadas para fazer os controles de linha e coluna e estendi fios e headers para conectá-los.





Uma vez que você fez com sucesso uma matriz 8x8, só precisa encadear mais registradores de deslocamento com clock comum para controlar as colunas. Só precisa de um único 74HC595 para controlar todas as linhas. Então, baseado no número de colunas, mais registradores de deslocamento podem ser adicionados, não há limite para o número de colunas que você pode adicionar.
Construindo a Segunda Metade




Como não tinha acesso a impressão 3D na época, procurei um marceneiro local para fazer um case.

O case que ele fez era muito maior do que eu esperava, é melhor projetar um case menor usando Fusion 360 ou outro software de design e imprimir em 3D. Furos foram feitos no case para conectar cabos de alimentação e USB.
O Código
O código pode ser encontrado nos anexos deste projeto.
Aqui faremos varredura pelas linhas e alimentaremos as linhas de coluna com níveis lógicos apropriados. O código determinará a velocidade da mensagem rolante, bem como a mensagem que vamos exibir. A direção da rolagem é da direita para a esquerda por padrão no código, mas com uma pequena modificação, pode ser implementada em outras direções também.
O Resultado
Obrigado! :)
Código
Código Arduino para Matriz LED 48x8 (C/C++)
Código Arduino para matriz LED 48x8. As conexões e o código são explicados como comentários no próprio código.
/*////////////////////////////////////////////////////////////////////////////////
* Código Arduino para exibir caracteres rolantes em 6 ou mais matrizes LED 8x8.
*
* O número de matrizes pode ser aumentado com uma pequena mudança no código.
*
* Comentários são dados em cada declaração para edição.
*
* Codificado por Prasanth K S
*
* Contato: kksjunior@hotmail.com
* /*////////////////////////////////////////////////////////////////////////////////
char msg[] = "WELCOME WIZ"; // Altere o texto aqui.
int scrollspeed = 5; // Defina a velocidade de rolagem (menor = mais rápido)
int x;
int y;
// Colunas
int clockPin1 = 2; // Pino Arduino conectado ao Clock Pin 11 do 74HC595
int latchPin1 = 3; // Pino Arduino conectado ao Latch Pin 12 do 74HC595
int dataPin1 = 4; // Pino Arduino conectado ao Data Pin 14 do 74HC595
// Linhas
int clockPin2 = 5; // Pino Arduino conectado ao Clock Pin 11 do 74HC595
int latchPin2 = 6; // Pino Arduino conectado ao Latch Pin 12 do 74HC595
int dataPin2 = 7; // Pino Arduino conectado ao Data Pin 14 do 74HC595
// BITMAP
// Bits neste array representam um LED da matriz
// 8 é # de linhas, 6 é # de matrizes LED
byte bitmap[8][7];
int numZones = sizeof(bitmap) / 8; // Uma Zona refere-se a uma matriz 8x8 (Grupo de 8 colunas)
int maxZoneIndex = numZones - 1;
int numCols = numZones * 8;
// DEFINIÇÃO DA FONTE
byte alphabets[][8] = {
{0,0,0,0,0}, // @ como ESPAÇO
//{8,28,54,99,65}, // <<
{31, 36, 68, 36, 31}, // A
{127, 73, 73, 73, 54}, // B
{62, 65, 65, 65, 34}, // C
{127, 65, 65, 34, 28}, // D
{127, 73, 73, 65, 65}, // E
{127, 72, 72, 72, 64}, // F
{62, 65, 65, 69, 38}, // G
{127, 8, 8, 8, 127}, // H
{0, 65, 127, 65, 0}, // I
{2, 1, 1, 1, 126}, // J
{127, 8, 20, 34, 65}, // K
{127, 1, 1, 1, 1}, // L
{127, 32, 16, 32, 127}, // M
{127, 32, 16, 8, 127}, // N
{62, 65, 65, 65, 62}, // O
{127, 72, 72, 72, 48}, // P
{62, 65, 69, 66, 61}, // Q
{127, 72, 76, 74, 49}, // R
{50, 73, 73, 73, 38}, // S
{64, 64, 127, 64, 64}, // T
{126, 1, 1, 1, 126}, // U
{124, 2, 1, 2, 124}, // V
{126, 1, 6, 1, 126}, // W
{99, 20, 8, 20, 99}, // X
{96, 16, 15, 16, 96}, // Y
{67, 69, 73, 81, 97} // Z
};
void setup() {
pinMode(latchPin1, OUTPUT);
pinMode(clockPin1, OUTPUT);
pinMode(dataPin1, OUTPUT);
pinMode(latchPin2, OUTPUT);
pinMode(clockPin2, OUTPUT);
pinMode(dataPin2, OUTPUT);
// Limpa bitmap
for (int row = 0; row < 8; row++) {
for (int zone = 0; zone <= maxZoneIndex; zone++) {
bitmap[row][zone] = 0;
}
}
}
// FUNÇÕES
// Exibe array bitmap na matriz
void RefreshDisplay() {
for (int row = 0; row < 8; row++) {
int rowbit = 1 << row;
digitalWrite(latchPin2, LOW); // Mantém latchPin LOW para transmitir dados
shiftOut(dataPin2, clockPin2, MSBFIRST, rowbit); // Transmite dados
// Inicia envio de bytes de coluna
digitalWrite(latchPin1, LOW); // Mantém latchPin LOW para transmitir dados
// Shift out para cada matriz
for (int zone = maxZoneIndex; zone >= 0; zone--) {
shiftOut(dataPin1, clockPin1, MSBFIRST, bitmap[row][zone]);
}
// Inverte ambos latches de uma vez para eliminar flicker
digitalWrite(latchPin1, HIGH); // Retorna latch pin 1 high para sinalizar chip
digitalWrite(latchPin2, HIGH); // Retorna latch pin 2 high para sinalizar chip
// Espera
delayMicroseconds(300);
}
}
// Converte linha e coluna para bit do bitmap e liga/desliga
void Plot(int col, int row, bool isOn) {
int zone = col / 8;
int colBitIndex = x % 8;
byte colBit = 1 << colBitIndex;
if (isOn) bitmap[row][zone] = bitmap[y][zone] | colBit;
else bitmap[row][zone] = bitmap[y][zone] & (~colBit);
}
// Plota cada caractere da mensagem uma coluna por vez, atualiza display, desloca bitmap para esquerda.
void XProcess() {
for (int charIndex = 0; charIndex < (sizeof(msg) - 1); charIndex++) {
int alphabetIndex = msg[charIndex] - '@';
if (alphabetIndex < 0) alphabetIndex = 0;
// Desenha um caractere da mensagem
// Cada caractere tem 5 colunas de largura, loop mais duas vezes para criar espaço de 2 pixels entre caracteres
for (int col = 0; col < 7; col++) {
for (int row = 0; row < 8; row++) {
// Define o pixel para o que o alfabeto diz para colunas 0 a 4, mas sempre deixa colunas 5 e 6 em branco.
bool isOn = 0;
if (col < 5) isOn = bitRead(alphabets[alphabetIndex][col], 7 - row) == 1;
Plot(numCols - 1, row, isOn); // Desenha na coluna mais à direita, o loop de deslocamento abaixo rolará para esquerda.
}
for (int refreshCount = 0; refreshCount < scrollspeed; refreshCount++) RefreshDisplay();
// Desloca o bitmap uma coluna para esquerda
for (int row = 0; row < 8; row++) {
for (int zone = 0; zone < numZones; zone++) {
// Este right shift mostraria como rolagem para esquerda no display porque a coluna mais à esquerda é representada pelo bit menos significativo do byte.
bitmap[row][zone] = bitmap[row][zone] >> 1;
// Desloca o bit mais baixo da próxima zona como bit mais alto desta zona.
if (zone < maxZoneIndex) bitWrite(bitmap[row][zone], 7, bitRead(bitmap[row][zone + 1], 0));
}
}
}
}
}
void loop() {
XProcess();
}
Esquemáticos
Apenas para referência. Para conexões de pinos, consulte os comentários no código.

Processo de manufatura
- Crie um Sistema Ambilight Impressionante para Monitor com Arduino
- Controlar um LED via Bluetooth com Arduino – Guia DIY Simples
- Display Interativo de Matriz LED na Porta com Sensor PIR – Saudação de Férias Arduino
- Construa um Robô Quadrúpede Inteligente com Arduino: Guia Passo a Passo
- Controle Suave de Brilho de LED com Bolt IoT e Arduino UNO
- Relógio Flip Arduino com Matriz LED 8×8 – Projeto DIY de Relógio em Tempo Real
- Misturador de Cores RGB com Arduino – Projeto DIY para Iniciantes
- Controlando Matriz de LED 8×8 com Arduino Uno: Guia Passo a Passo
- Construa um Rádio FM Compacto com Arduino Nano e RDA5807M
- Projetores LED RGB Externos com DMX – Alta Performance e Custo Acessível