Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);
Rolagem de texto em matriz de LEDs
Veja projeto original em: http://www.instructables.com/id/Make-a-24X6-LED-matrix/?ALLSTEPS
Fazer um projeto de uma matriz de pontos para rolagem de textos recebidos de uma porta serial ou memória, éra um antigo sonho meu! Realizado, agora, com Arduino!
O conceito é muito simples:
Receber a mensagem por comunicação serial de um PC, ou então de uma memória com os dados armazenado, ou ainda com a mensagem pré-programada dentro do próprio programa. Enviar isso para uma matriz composta de 24 colunas e 6 linhas (cada simbolo ou caracter com 6x6), fazer o escaneamento das 24 colunas, transmitindo a informação dos símbolos através da matriz.
Sendo possível deixar essa mensagem estática na matriz (o que não é realmente o objetivo), ou rolar a mensagem da direita para a esquerda, ou ainda fazer efeitos de transição, por exemplo: de cima para baixo e vice-versa, piscar, etc...
Tudo isso torna-se possível com o uso do versátil Arduino e por um custo muito barato.
A utilidade torna-se muito grande (desde comercial, residêncial, ou educativo), ou por simples hobby.
Bom vamos ao que interessa:
Foram mais de 30 horas entre projeto e execução. Tudo muito bem projetado, para não haver erros.
Horas de: Prancheta, desenhos, EagleCad, medidas, gabaritos, testes, decisões, etc...
Confecção de placa, confecção da Matriz de LEDs, testes do programa.... e assim por diante.
Mas valeu a pena!
E agora vamos explicar tudinho, pra que você também possa fazer uma e desfrutar desse sonho também...
COMPONENTES & MATERIAIS:
Barra de pinos macho (3x8 pinos, 1x6 pinos)
Barra de pinos femea (1x8 furos)
4 x Soquetes para Circuito Integrado tipo DIL-16
Conectores para Flat-Cable (3x8 vias, 1x6 vias)
Placa perfurada padrão de 30x15 (será usado a metade)
144 x LEDs (na sua cor de preferência)(recomendo, azul ou verde)
3 x Shift Registers 74HC595
1 x Contador 4017
6 x Transistores de uso comum tipo BC546 ou 2N3904
6 x resistores de 1K
24 x resistores de 150
4 x Flat-Cable de 8 vias
Fios e Cabos
Material para corrosão (percloreto de ferro)
Ferramentas em geral (alicates de bico, alicates de corte, serra, perfurador de placa, riscador, régua, chaves de fenda, limas, ferro de soldar, estanho, etc...).
Multímetro
Material de apoio (fonte de alimentação, bread-board, garras, testador de LEDs, etc...)
DIAGRAMAS & MONTAGEM:
1. Matriz de LEDs 24x6:-
 |
| Esquema da Matriz de LEDs |
 |
| Placa matriz, face dupla |
Tomar como referência para o projeto:
Coluna 1 até 24, contando a partir da direita para a esquerda;
Linha 1 até 6, contando de cima para baixo;
Em cada linha de LEDS (24 LEDs por linha), todos os catodos dos LEDs são interconectados entre si, e o final de cada linha será a conexão de uma linha da matriz, conexão está ligada a uma das vias do flat-cable de 6 vias com conector fêmea na outra ponta.
Para cada coluna de LEDs (são 24 colunas e cada coluna com 6 x LEDs), teremos todos os anodos dos LEDs interconectados entre si, formando 24 vias. Cada 8 colunas serão ligadas via flat-cable a placa controladora por flat-cables de 8 vias com conector fêmea na outra ponta (serão usados 3 cabos como este).
Cortar a placa perfurada e deixá-la com 80x27 furos (serão usados 70x17, os que sobrarem são para dar uma folga na montagem e para poder fazer o acabamento futuro).
 |
| Placa perfurada padrão, lado cobreado. |
 |
| Placa perfurada padrão, lado dos componentes. |
 |
| Soldando os LEDs (detalhe parcial). |
 |
| LEDs soldados (detalhe parcial). |
 |
| Matriz Fiação Soldada |
 |
| Detalhe da fiação. |
 |
| Exemplo: LEDs na placa |
 |
| Matriz completa. |
Conselho:
Conforme for sendo executado a solda dos LEDs, também deve se executar a solda dos fios referentes às linhas, bem como, dobrados/soldados os terminais dos LEDs referente às colunas.
Deixar para soldar todos os LEDs e depois soldar os fios das linhas e dobrar/soldar os terminais dos LEDs das colunas; fica muito mais difícil e trabalhoso.
Como detalhe final, poderia por exemplo ser furado um acrílico verde (neste caso com 10mm de profundidade) para envolver todos o LEDs e a placa, ficando um único conjunto sem aparecer os LEDs ou placa. Fica bem profissional.
Mais alguns detalhes:
 |
| Confecção dos flatcables |
 |
| Soldando os cabos na matriz |
 |
| Detalhe da ligação dos cabos |
 |
| Matriz finalizada |
 |
| Passe cola quente para fixar bem os cabos e evitar rupturas na solda |
Exatamente pela proposta que foi dada antes.... fazer um acrílico verde para envolver todos os LEDs e a placa e dar um acabamento profissional (fios na placa seriam inconvenientes...).
 |
| Ainda para evitar rupturas, fixe os cabos na placa com fios amarrados nos furos |
 |
| Detalhe da fixação |
 |
| Detalhe da fixação |
Esquema elétrico:
 |
| Esquema Elétrico |
 |
| Placa de Controle, face única, proposta 1 |
 |
| Placa de controle, face única, proposta 2 |
No projeto inicial (desenhado a mão e com gabarito de componentes) a placa tinha 10 x 10 cm.
 |
| Placa e layout, face única |
Passado em papel milimetrado, somente furação.
 |
| Layout em papel milimetrado, para furação |
 |
| Ferramentas e placa envolvida pelo papel |
 |
| Furação iniciada |
 |
| Placa furada, lado cobreado |
 |
| Placa furada, lado componentes |
 |
| Passando o layout para a placa com caneta p/ circuito impresso |
 |
| Placa devidamente furada e corroída |
 |
| Teste de colocação dos soquetes e pinos para verificar a correta disposição |
OBS.: faça uma rigorosa verificação se existem trilahs/ilhas em curto ou em aberto antes de soldar os componentes.
 |
| Componentes soldados |
 |
| Detalhe da solda |
Coloque o ferro de solda na junção da ilha cobreada e o terminal do componente, aqueça por 1 segundo e aplique o estanho na junção ferro/ilha/terminal, assim você terá uma solda lisa e brilhante (nunca sopre a solda!!!).
Pojetos em Eagle 5.10.0 em: http://www.4shared.com/zip/4jYhsWyQ/projetos_arduino.html
BOM SERVIÇO!!!
AGORA VOCÊ TEM A PLACA DE CONTROLE E A MATRIZ DE LEDs MONTADAS!!!
Vamos continuar,
3. Interligação para os testes:-
Detalhes de pinos na placa de controle:
 |
| Pinos para o Arduino, controle do contador e ShiftRegister |
 |
| Pinos para a Matriz, colunas |
 |
| Pinos para a Matriz, linhas |
Na placa temos: 6, 2, 1, 3, 4, 5.
Na matriz Temos: 1, 2, 3, 4, 5, 6.
Os fios devem ser ligados de forma a coincidir os números
Detalhes de pinagem na placa Matriz LEDs:
 |
| Pinos da Matriz de LEDs, colunas |
 |
| Pinos da Matriz de LEDs, linhas |
 |
| Detalhe da pinagem no Arduino |
 |
| Mais um detalhe da pinagem na placa de controle |
 |
| Mais pinagens |
 |
| Pinos de alimentação |
 |
| Ligação com a Matriz |
 |
| Vista geral das conexões |
 |
| Matriz em funcionamento |
SOFTWARE(Comentados):
1. Rola mensagem pré-programada:
/*
################################################################################
# Arquivo: Matrix_24x6_Scrolling_Message_looping.ino
# Micro-processador: Arduino UNO
# Linguagem: Wiring / C /Processing /Fritzing / Arduino IDE
#
# Objetivo: Scrolling LED dot Matrix
#
# Funcionamento: Rola uma mensagem numa matriz de LEDs 24x6
# em loop
#
# Autor: Marcelo Moraes
# Data: 25/07/12
# Local: Sorocaba - SP
#
################################################################################
Este exemplo é um código de domínio público.
*/
#define A {B01110000,B10001000,B10001000,B11111000,B10001000,B10001000}
#define B {B11110000,B10001000,B10001000,B11110000,B10001000,B11111000}
#define C {B11111000,B10000000,B10000000,B10000000,B10000000,B11111000}
#define D {B11110000,B10001000,B10001000,B10001000,B10001000,B11110000}
#define E {B11111000,B10000000,B10000000,B11110000,B10000000,B11111000}
#define F {B11111000,B10000000,B10000000,B11110000,B10000000,B10000000}
#define G {B01110000,B10001000,B10000000,B10011000,B10001000,B01110000}
#define H {B10001000,B10001000,B11111000,B10001000,B10001000,B10001000}
#define I {B11111000,B00100000,B00100000,B00100000,B00100000,B11111000}
#define J {B00111000,B00010000,B00010000,B00010000,B10010000,B01100000}
#define M {B10001000,B11011000,B10101000,B10101000,B10001000,B10001000}
#define N {B10001000,B11001000,B10101000,B10101000,B10011000,B10001000}
#define L {B10000000,B10000000,B10000000,B10000000,B10000000,B11111000}
#define O {B01110000,B10001000,B10001000,B10001000,B10001000,B01110000}
#define P {B11110000,B10001000,B10001000,B11110000,B10000000,B10000000}
#define Q {B01110000,B10001000,B10101000,B10011000,B01111000,B00001000}
#define R {B11110000,B10001000,B10001000,B11110000,B10001000,B10001000}
#define S {B01110000,B10001000,B01100000,B00010000,B10001000,B01110000}
#define K {B10001000,B10010000,B11100000,B11100000,B10010000,B10001000}
#define T {B11111000,B00100000,B00100000,B00100000,B00100000,B00100000}
#define U {B10001000,B10001000,B10001000,B10001000,B10001000,B01110000}
#define V {B10001000,B10001000,B10001000,B10001000,B01010000,B00100000}
#define W {B10001000,B10001000,B10101000,B10101000,B10101000,B01010000}
#define X {B10001000,B01010000,B00100000,B00100000,B01010000,B10001000}
#define Y {B10001000,B01010000,B00100000,B00100000,B00100000,B00100000}
#define Z {B11111000,B00001000,B00110000,B01100000,B10000000,B11111000}
#define LA{B00000000,B01110000,B00001000,B01111000,B10001000,B01111000}
#define LB{B10000000,B10000000,B10110000,B11001000,B10001000,B11110000}
#define LC{B00000000,B01110000,B10000000,B10000000,B10001000,B01110000}
#define LD{B00001000,B00001000,B01111000,B10001000,B10001000,B01111000}
#define LE{B00000000,B01110000,B10001000,B11111000,B10000000,B01110000}
#define LF{B00110000,B01001000,B01000000,B11100000,B01000000,B01000000}
#define LG{B00000000,B01111000,B10001000,B01111000,B00001000,B01110000}
#define LH{B10000000,B10000000,B10110000,B11001000,B10001000,B10001000}
#define LI{B00100000,B00000000,B01100000,B00100000,B00100000,B01111000}
#define LJ{B00010000,B00000000,B00111000,B00010000,B10010000,B01100000}
#define LK{B10000000,B10010000,B10100000,B11000000,B10100000,B10010000}
#define LL{B01100000,B00100000,B00100000,B00100000,B00100000,B01111000}
#define LM{B00000000,B00000000,B11010000,B10101000,B10101000,B10001000}
#define LN{B00000000,B00000000,B10110000,B11001000,B10001000,B10001000}
#define LO{B00000000,B01110000,B10001000,B10001000,B10001000,B01110000}
#define LP{B00000000,B11110000,B10001000,B11110000,B10000000,B10000000}
#define LQ{B00000000,B01101000,B10011000,B01111000,B00001000,B00001000}
#define LR{B00000000,B00000000,B10110000,B11001000,B10000000,B10000000}
#define LS{B00000000,B01110000,B10000000,B01110000,B00001000,B11110000}
#define LT{B01000000,B01000000,B11100000,B01000000,B01001000,B00110000}
#define LU{B00000000,B00000000,B10001000,B10001000,B10011000,B01101000}
#define LV{B00000000,B00000000,B10001000,B10001000,B01010000,B00100000}
#define LW{B00000000,B00000000,B10001000,B10101000,B10101000,B01010000}
#define LX{B00000000,B10001000,B01010000,B00100000,B01010000,B10001000}
#define LY{B00000000,B10001000,B10001000,B01111000,B00001000,B01110000}
#define LZ{B00000000,B11111000,B00010000,B00100000,B01000000,B11111000}
#define SPACE{B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
#define NUM0{B01110000,B10011000,B10101000,B10101000,B11001000,B01110000}
#define NUM1{B00100000,B01100000,B10100000,B00100000,B00100000,B01110000}
#define NUM2{B01110000,B10001000,B00001000,B01110000,B10000000,B11111000}
#define NUM3{B11110000,B00001000,B00001000,B01111000,B00001000,B11110000}
#define NUM4{B10001000,B10001000,B10001000,B11111000,B00001000,B00001000}
#define NUM5{B11111000,B10000000,B11110000,B00001000,B10001000,B01110000}
#define NUM6{B11111000,B10000000,B11111000,B10001000,B10001000,B11111000}
#define NUM7{B11111000,B00001000,B00001000,B01111000,B00001000,B00001000}
#define NUM8{B11111000,B10001000,B11111000,B10001000,B10001000,B11111000}
#define NUM9{B11111000,B10001000,B11111000,B00001000,B00001000,B11111000}
#define DEVIDE{B00001000,B00010000,B00100000,B00100000,B01000000,B10000000}
#define TWODOTS{B01100000,B01100000,B00000000,B00000000,B01100000,B01100000}
#define DOT{B00000000,B00000000,B00000000,B00000000,B01100000,B01100000}
#define COMA{B00000000,B00000000,B00000000,B00110000,B00110000,B01100000}
#define LINE{B00000000,B00000000,B11111000,B11111000,B00000000,B00000000}
#define QUASTION{B01110000,B10001000,B00010000,B00100000,B00000000,B00100000}
#define MARK{B00100000,B01110000,B01110000,B00100000,B00000000,B00100000}
int latchPin = 10;
int clockPin = 13;
int dataPin = 11;
int clock = 9;
int Reset = 8;
int latchPinPORTB = latchPin - 8;
int clockPinPORTB = clockPin - 8;
int dataPinPORTB = dataPin - 8;
int i = 0;
long scrolling_word[6];
int array_turn=0;
byte your_text[29][6]={M,LA,LT,LR,LI,LZ,SPACE,NUM2,NUM4,LX,NUM6,SPACE,T,LH,LA,LN,LK,LS,SPACE,LT,LO,SPACE,S,LY,LS,LT,NUM3,LM,X}; //PUT YOU TEXT HERE
void setup(){
Serial.begin(9600);
pinMode(dataPin,OUTPUT);
pinMode(clockPin,OUTPUT);
pinMode(latchPin,OUTPUT);
pinMode(clock,OUTPUT);
pinMode(Reset,OUTPUT);
digitalWrite(Reset,HIGH);
digitalWrite(Reset,LOW);
setupSPI();
}
void display_word(int loops,byte word_print[][6],int num_patterns,int delay_langth){// this function displays your symbols
i = 0;// resets the counter fot the 4017
for(int g=0;g<6;g++)//resets the the long int where your word goes
scrolling_word[g] = 0;
for(int x=0;x<num_patterns;x++){//main loop, goes over your symbols
// you will need to find a better way to make the symbols scroll my way is limited for 24 columns
for(int r=0;r<6;r++)//puts the buildes the first symbol
scrolling_word[r] |= word_print[x][r];
for (int z=0;z<6;z++){//the sctolling action
for(int p=0;p<6;p++)
scrolling_word[p] = scrolling_word[p] << 1;
// end of the scrolling funcion
for(int t=0;t<delay_langth;t++){// delay function, it just loops over the same display
for(int y=0;y<6;y++){// scaning the display
if(i == 6){// counting up to 6 with the 4017
digitalWrite(Reset,HIGH);
digitalWrite(Reset,LOW);
i = 0;
}
latchOff();
spi_transfer(make_word(0x01000000,y));// sending the data
spi_transfer(make_word(0x00010000,y));
spi_transfer(make_word(0x00000100,y));
latchOn();
delayMicroseconds(800);//waiting a bit
latchOff();
spi_transfer(0);// clearing the data
spi_transfer(0);
spi_transfer(0);
latchOn();
digitalWrite(clock,HIGH);//counting up with the 4017
digitalWrite(clock,LOW);
i++;
}
}
}
}
finish_scroll(delay_langth);
}
void finish_scroll(int delay_scroll){// this function is the same as the funcion above, it just finishing scrolling
for (int n=0;n<24;n++){
for(int h=0;h<6;h++)
scrolling_word[h] = scrolling_word[h] << 1;
for(int w=0;w<delay_scroll;w++){
for(int k=0;k<6;k++){
if(i == 6){
digitalWrite(Reset,HIGH);
digitalWrite(Reset,LOW);
i = 0;
}
latchOff();
spi_transfer(make_word(0x01000000,k));
spi_transfer(make_word(0x00010000,k));
spi_transfer(make_word(0x00000100,k));
latchOn();
delayMicroseconds(800);
latchOff();
spi_transfer(0);
spi_transfer(0);
spi_transfer(0);
latchOn();
digitalWrite(clock,HIGH);
digitalWrite(clock,LOW);
i++;
}
}
}
}
byte make_word (long posistion,byte turn){
byte dummy_word = 0;
for(int q=0;q<8;q++){
if(scrolling_word[turn] & (posistion<<q))
dummy_word |= 0x01<<q;
}
return dummy_word;
}
void loop() {
display_word(1,your_text,29,15);// calls for the display_pattern function and says that int loop = 15(if you do more loop the pattern whould scrole slower).
}
void latchOn(){
bitSet(PORTB,latchPinPORTB);
}
void latchOff(){
bitClear(PORTB,latchPinPORTB);
}
void setupSPI(){
byte clr;
SPCR |= ( (1<<SPE) | (1<<MSTR) ); // enable SPI as master
//SPCR |= ( (1<<SPR1) | (1<<SPR0) ); // set prescaler bits
SPCR &= ~( (1<<SPR1) | (1<<SPR0) ); // clear prescaler bits
clr=SPSR; // clear SPI status reg
clr=SPDR; // clear SPI data reg
SPSR |= (1<<SPI2X); // set prescaler bits
//SPSR &= ~(1<<SPI2X); // clear prescaler bits
delay(10);
}
byte spi_transfer(byte data)
{
SPDR = data; // Start the transmission
while (!(SPSR & (1<<SPIF))) // Wait the end of the transmission
{
};
return SPDR; // return the received byte, we don't need that
}
2. Rola mensagem recebida por comunicação serial:
/*
################################################################################
# Arquivo: Matrix_24x6_Scrolling_Message_MPM.ino
# Micro-processador: Arduino UNO
# Linguagem: Wiring / C /Processing /Fritzing / Arduino IDE
#
# Objetivo: Scrolling LED dot Matrix
#
# Funcionamento: Rola uma mensagem numa matriz de LEDs 24x6
# Recebe a mensagem via comunicação serial e
# mostra no display da matriz
#
# Autor: Marcelo Moraes
# Data: 24/07/12
# Local: Sorocaba - SP
#
################################################################################
Este exemplo é um código de domínio público.
*/
// definindo todos os símbolos
#define BA {B01110000,B10001000,B10001000,B11111000,B10001000,B10001000} // 0
#define BB {B11110000,B10001000,B10001000,B11110000,B10001000,B11111000}
#define BC {B11111000,B10000000,B10000000,B10000000,B10000000,B11111000}
#define BD {B11110000,B10001000,B10001000,B10001000,B10001000,B11110000}
#define BE {B11111000,B10000000,B10000000,B11110000,B10000000,B11111000}
#define BF {B11111000,B10000000,B10000000,B11110000,B10000000,B10000000}
#define BG {B01110000,B10001000,B10000000,B10011000,B10001000,B01110000}
#define BH {B10001000,B10001000,B11111000,B10001000,B10001000,B10001000}
#define BI {B11111000,B00100000,B00100000,B00100000,B00100000,B11111000}
#define BJ {B00111000,B00010000,B00010000,B00010000,B10010000,B01100000}
#define BM {B10001000,B11011000,B10101000,B10101000,B10001000,B10001000}
#define BN {B10001000,B11001000,B10101000,B10101000,B10011000,B10001000}
#define BL {B10000000,B10000000,B10000000,B10000000,B10000000,B11111000}
#define BO {B01110000,B10001000,B10001000,B10001000,B10001000,B01110000}
#define BP {B11110000,B10001000,B10001000,B11110000,B10000000,B10000000}
#define BQ {B01110000,B10001000,B10101000,B10011000,B01111000,B00001000}
#define BR {B11110000,B10001000,B10001000,B11110000,B10001000,B10001000}
#define BS {B01110000,B10001000,B01100000,B00010000,B10001000,B01110000}
#define BK {B10001000,B10010000,B11100000,B11100000,B10010000,B10001000}
#define BT {B11111000,B00100000,B00100000,B00100000,B00100000,B00100000}
#define BU {B10001000,B10001000,B10001000,B10001000,B10001000,B01110000}
#define BV {B10001000,B10001000,B10001000,B10001000,B01010000,B00100000}
#define BW {B10001000,B10001000,B10101000,B10101000,B10101000,B01010000}
#define BX {B10001000,B01010000,B00100000,B00100000,B01010000,B10001000}
#define BY {B10001000,B01010000,B00100000,B00100000,B00100000,B00100000}
#define BZ {B11111000,B00001000,B00110000,B01100000,B10000000,B11111000}
#define LA{B00000000,B01110000,B00001000,B01111000,B10001000,B01111000}
#define LB{B10000000,B10000000,B10110000,B11001000,B10001000,B11110000}
#define LC{B00000000,B01110000,B10000000,B10000000,B10001000,B01110000}
#define LD{B00001000,B00001000,B01111000,B10001000,B10001000,B01111000}
#define LE{B00000000,B01110000,B10001000,B11111000,B10000000,B01110000}
#define LF{B00110000,B01001000,B01000000,B11100000,B01000000,B01000000}
#define LG{B00000000,B01111000,B10001000,B01111000,B00001000,B01110000}
#define LH{B10000000,B10000000,B10110000,B11001000,B10001000,B10001000}
#define LI{B00100000,B00000000,B01100000,B00100000,B00100000,B01111000}
#define LJ{B00010000,B00000000,B00111000,B00010000,B10010000,B01100000}
#define LK{B10000000,B10010000,B10100000,B11000000,B10100000,B10010000}
#define LL{B01100000,B00100000,B00100000,B00100000,B00100000,B01111000}
#define LM{B00000000,B00000000,B11010000,B10101000,B10101000,B10001000}
#define LN{B00000000,B00000000,B10110000,B11001000,B10001000,B10001000}
#define LO{B00000000,B01110000,B10001000,B10001000,B10001000,B01110000}
#define LP{B00000000,B11110000,B10001000,B11110000,B10000000,B10000000}
#define LQ{B00000000,B01101000,B10011000,B01111000,B00001000,B00001000}
#define LR{B00000000,B00000000,B10110000,B11001000,B10000000,B10000000}
#define LS{B00000000,B01110000,B10000000,B01110000,B00001000,B11110000}
#define LT{B01000000,B01000000,B11100000,B01000000,B01001000,B00110000}
#define LU{B00000000,B00000000,B10001000,B10001000,B10011000,B01101000}
#define LV{B00000000,B00000000,B10001000,B10001000,B01010000,B00100000}
#define LW{B00000000,B00000000,B10001000,B10101000,B10101000,B01010000}
#define LX{B00000000,B10001000,B01010000,B00100000,B01010000,B10001000}
#define LY{B00000000,B10001000,B10001000,B01111000,B00001000,B01110000}
#define LZ{B00000000,B11111000,B00010000,B00100000,B01000000,B11111000}
#define SPACE{B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
#define NUM0{B01110000,B10011000,B10101000,B10101000,B11001000,B01110000}
#define NUM1{B00100000,B01100000,B10100000,B00100000,B00100000,B01110000}
#define NUM2{B01110000,B10001000,B00001000,B01110000,B10000000,B11111000}
#define NUM3{B11110000,B00001000,B00001000,B01111000,B00001000,B11110000}
#define NUM4{B10001000,B10001000,B10001000,B11111000,B00001000,B00001000}
#define NUM5{B11111000,B10000000,B11110000,B00001000,B10001000,B01110000}
#define NUM6{B11111000,B10000000,B11111000,B10001000,B10001000,B11111000}
#define NUM7{B11111000,B00001000,B00001000,B01111000,B00001000,B00001000}
#define NUM8{B11111000,B10001000,B11111000,B10001000,B10001000,B11111000}
#define NUM9{B11111000,B10001000,B11111000,B00001000,B00001000,B11111000}
#define DEVIDE{B00001000,B00010000,B00100000,B00100000,B01000000,B10000000}
#define TWODOTS{B01100000,B01100000,B00000000,B00000000,B01100000,B01100000}
#define DOT{B00000000,B00000000,B00000000,B00000000,B01100000,B01100000}
#define COMA{B00000000,B00000000,B00000000,B00110000,B00110000,B01100000}
#define LINE{B00000000,B00000000,B11111000,B11111000,B00000000,B00000000}
#define QUASTION{B01110000,B10001000,B00010000,B00100000,B00000000,B00100000}
#define MARK{B00100000,B01110000,B01110000,B00100000,B00000000,B00100000} // 69
#define NUM{B00000000,B01010000,B11111000,B01010000,B11111000,B01010000} // 70
#define SMILE{B00000000,B00010000,B11001000,B00001000,B11001000,B00010000}
#define HEART{B00000000,B01010000,B10101000,B10001000,B01010000,B00100000}
#define ASP{B00100000,B00100000,B00010000,B00000000,B00000000,B00000000}
#define PARH{B00100000,B01000000,B01000000,B01000000,B01000000,B00100000}
#define PARL{B00100000,B00010000,B00010000,B00010000,B00010000,B00100000}
#define AST{B10101000,B01110000,B11111000,B01110000,B10101000,B00000000}
#define PLU{B00000000,B00100000,B00100000,B11111000,B00100000,B00100000}
#define POV{B01100000,B01100000,B00000000,B01100000,B00100000,B01000000}
#define EQU{B00000000,B00000000,B01110000,B00000000,B01110000,B00000000}
#define BRR{B01100000,B01000000,B01000000,B01000000,B01000000,B01100000} // 80
#define BAR{B10000000,B01000000,B00100000,B00100000,B00010000,B00001000}
#define BRL{B00110000,B00010000,B00010000,B00010000,B00010000,B00110000}
#define UND{B00000000,B00000000,B00000000,B00000000,B00000000,B11111000}
#define PIP{B00100000,B00100000,B00100000,B00100000,B00100000,B00100000}
#define PACM{B01110000,B10111000,B11111000,B00111000,B11111000,B01110000} // 85
#define CHAP{B00000000,B01000000,B10101000,B00010000,B00000000,B00000000}
#define TIL{B00000000,B00100000,B01010000,B10001000,B00000000,B00000000}
#define ROB{B10110100,B10000100,B01111000,B00110000,B01001000,B11001100}
#define SQR{B10101000,B01010100,B10101000,B01010100,B10101000,B01010100}
#define MAJ{B00000000,B10000000,B01000000,B00100000,B01000000,B10000000}
#define MIN{B00000000,B00000100,B00001000,B00010000,B00001000,B00000100}
#define SQUARE{B11111100,B10000100,B10000100,B10000100,B10000100,B11111100}
// fim da definição de símbolos
// definição de pinos do Arduino
int latchPin = 10; // pino latch do registrador de deslocamento "shift register"
int clockPin = 13; // pino clock do registrador de deslocamento "shift register"
int dataPin = 11; //pino data do registrador de deslocamento "shift register"
int clock = 9; // pino clock do contador 4017
int Reset = 8; // pino reset do contador 4017
// fim da definição de pinos do Arduino
// configuração de pinos para fácil operação com o PORTB do Arduino
int latchPinPORTB = latchPin - 8; // pino de latch
int clockPinPORTB = clockPin - 8; // pino de clock
int dataPinPORTB = dataPin - 8; //pino de dados
// definição e inicialização de variáveis
int i = 0; // inicia variável auxiliar de contagem
int incomingByte[44]; // matriz que armazena o byte entrante
byte scrolling_word[6][3]; // isto é para o ralamento de texto
int array_turn=0; // matriz auxiliar
byte patterns[100][6]; // esta matriz armazena o texto a ser rolado no display
// matriz contendo cada um dos símbolos, 86 simbolos, cada símbolo com 8 colunas e 6 linhas de bits
byte dummy_array[93][6] ={BA,BB,BC,BD,BE,BF,BG,BH,BI,BJ,BK,BL,BM,BN,BO,BP,BQ,BR,BS,BT,BU,BV,BW,BX,BY,BZ,SPACE,NUM0,NUM1,NUM2,NUM3,NUM4,NUM5,NUM6,NUM7,NUM8,NUM9,DEVIDE,TWODOTS,DOT,COMA,LINE,QUASTION,MARK,LA,LB,LC,LD,LE,LF,LG,LH,LI,LJ,LK,LL,LM,LN,LO,LP,LQ,LR,LS,LT,LU,LV,LW,LX,LY,LZ,NUM,SMILE,HEART,ASP,PARH,PARL,AST,PLU,POV,EQU,BRR,BAR,BRL,UND,PIP,PACM,TIL,CHAP,ROB,SQR,MAJ,MIN,SQUARE,};
// loop inicial do Arduino; executa uma única vez na inicialização
void setup(){
Serial.begin(9600);// inicializa a comunicação serial com o PC a 9600 boud
// configura todos os pinos
pinMode(dataPin,OUTPUT);
pinMode(clockPin,OUTPUT);
pinMode(latchPin,OUTPUT);
pinMode(clock,OUTPUT);
pinMode(Reset,OUTPUT);
// reinicia o contador 4017
digitalWrite(Reset,HIGH);
digitalWrite(Reset,LOW);
setupSPI(); // inicializa a comunicação SPI
}
// fim do loop inicial
// função pricipal para mostrar e rolar as palavras
void display_word(int loops,byte word_print[][6],int num_patterns,int delay_langth){
// argumentos usados:
// loops - quantidade de vezes a ser executado
// word_print - matriz que armazena a palavra a ser mostrada
// num_patterns - quantidade de simbolos na matriz
// delay_langth - atraso do laço (quantas vezes será executado, aumentando este valor a mensagem rola mais devagar e vice-versa)
i = 0; // variável auxiliar em contagens
for(int first=0;first<6;first++){ // reinicializando a matriz scrolling_word
for(int second=0;second<5;second++)
scrolling_word[first][second] = 0x00; // coloca 0x00 em cada posição da matriz (inicia vazia)
}
for(int x=0;x<num_patterns;x++){// loop principal que passa sobre todos os símbolos
for(int scroll=0;scroll<6;scroll++){// loop para rolagem, cada símbolo rola por 6 colunas
for(int r=0;r<6;r++){// passando por cima de todas as linhas
// esta é a função de rolagem é como fazer uma palavra de 3 byte para se deslocar de uma só vez
scrolling_word[r][2] = (scrolling_word[r][2] << 1)+((scrolling_word[r][1] & 0x80) >> 7);
scrolling_word[r][1] = (scrolling_word[r][1] << 1)+((scrolling_word[r][0] & 0x80) >> 7);
scrolling_word[r][0] = (scrolling_word[r][0] << 1)+(((word_print[x][r]<<scroll)&0x80)>>7);
}
// rola os mesmos dados pelas 6 linhas delay_langht vezes (causa atraso e persistÊncia da informação
for(int t=0;t<delay_langth;t++){ // um loop de atraso que só mostra o mesmo quadro mais e mais para criar um atraso
for(int y=0;y<6;y++){ // o laço de varredura que passa sobre todas as 6 linhas
if(i == 6){ // se o contador 4017 contou até 6, reinicializa
digitalWrite(Reset,HIGH);
digitalWrite(Reset,LOW);
i = 0; // reinicializa o contador
}
latchOff();// começando a comunicação com os registadores de deslocamento
spi_transfer(scrolling_word[y][2]); // enviando informação (3 bytes)
spi_transfer(scrolling_word[y][1]);
spi_transfer(scrolling_word[y][0]);
latchOn(); // chama função
delayMicroseconds(800); // um pequeno atraso para cada linha
latchOff(); // chama função
// limpando os registradores de deslocamento para ter certeza que não vai haver um efeito fantasma
spi_transfer(0); // manda nada na comunicação SPI
spi_transfer(0);
spi_transfer(0);
latchOn(); // chama função
// avançar o contador 4017 em um (nos acabamos de enviar um pulso positivo)
digitalWrite(clock,HIGH); // clock vai para alto
digitalWrite(clock,LOW); // clock vai para baixo
i++; // próxima iteração
}
}
}
}
finish_scroll(delay_langth); // chamando uma função para terminar de rolar os últimos 4 símbolos
}
// fim desta função
// esta função termina a rolagem e é muito similar a função display_word
void finish_scroll(int delay_scroll){
for (int n=0;n<26;n++){
for(int h=0;h<6;h++){
scrolling_word[h][2] = (scrolling_word[h][2] << 1) | ((scrolling_word[h][1] & 0x80) >> 7);
scrolling_word[h][1] = (scrolling_word[h][1] << 1) | ((scrolling_word[h][0] & 0x80) >> 7);
scrolling_word[h][0] = (scrolling_word[h][0] << 1) | 0 ;
}
for(int t=0;t<delay_scroll;t++){
for(int y=0;y<6;y++){
if(i == 6){
digitalWrite(Reset,HIGH);
digitalWrite(Reset,LOW);
i = 0;
}
latchOff();
spi_transfer(scrolling_word[y][2]);
spi_transfer(scrolling_word[y][1]);
spi_transfer(scrolling_word[y][0]);
latchOn();
delayMicroseconds(800);
latchOff();
spi_transfer(0);
spi_transfer(0);
spi_transfer(0);
latchOn();
digitalWrite(clock,HIGH);
digitalWrite(clock,LOW);
i++;
}
}
}
}
// fim desta função
// loop principal do Arduino
void loop() {
// envia dados somente quando for recebido dados
if(Serial.available() > 0){ // se existem dados a serem lidos
delay(100); // pequeno atraso
incomingByte[array_turn] = Serial.read();// colocando o símbolo na matriz
array_turn++; // contando o número de símbolos entrantes
}
else{ // caso contrário...
// esta parte é para obter a informação que temos e colocá-la em uma forma possamos trabalhar com ela
if(array_turn != 0){ // se variável array_turn não é 0, significa que temos símboloa a serem mostrados
for(int az=0;az<array_turn;az++){// verifica cada simbolo, se são letras, entre "65 e 90" ou "97 e 122" em ASCII
// números estão entre "53 e 62" em ASCII
if((incomingByte[az] > 64 && incomingByte[az] < 91) || (incomingByte[az] > 96 && incomingByte[az] < 123)){
if(incomingByte[az] > 64 && incomingByte[az] < 91){ // para letras entre "65 e 90"
for(int lol=0;lol<6;lol++) // para cada indice de matriz
patterns[az][lol] = dummy_array[incomingByte[az] - 65][lol]; // subtrai 65 para ter o indice na matriz de padrão (acha na matiz o símbolo "letra" recebido)
}
else{ // para números
for(int lol=0;lol<6;lol++) // para cada indice de matriz
patterns[az][lol] = dummy_array[incomingByte[az] - 53][lol]; // subtrai 53 para ter o indice na matriz de padrão (acha na matiz o símbolo "número" recebido)
}}
else{ // para outros simbolos
switch(incomingByte[az]){
case 32: // espaço
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[26][lol];
break;
case 33: // exclamação
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[43][lol];
break;
case 35: // tralha
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[70][lol];
break;
case 37: // smile
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[71][lol];
break;
case 36: // pacmam
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[85][lol];
break;
case 38: // heart
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[72][lol];
break;
case 39: // aspas
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[73][lol];
break;
case 40: // parenteses direita
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[74][lol];
break;
case 41: // parenteses esquerda
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[75][lol];
break;
case 42: // asterisco
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[76][lol];
break;
case 43: // mais
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[77][lol];
break;
case 45: // linha
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[41][lol];
break;
case 44: // vírgula
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[40][lol];
break;
case 46: // ponto
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[39][lol];
break;
case 47: // barra divisão
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[37][lol];
break;
case 48: //0
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[27][lol];
break;
case 49: //1
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[28][lol];
break;
case 50: // 2
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[29][lol];
break;
case 51: // 3
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[30][lol];
break;
case 52: // 4
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[31][lol];
break;
case 53: // 5
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[32][lol];
break;
case 54: // 6
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[33][lol];
break;
case 55: // 7
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[34][lol];
break;
case 56: // 8
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[35][lol];
break;
case 57: // 9
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[36][lol];
break;
case 58: // dois pontos
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[38][lol];
break;
case 59: // ponto e virgula
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[78][lol];
break;
case 60: // menor
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[91][lol];
break;
case 61: // igual
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[79][lol];
break;
case 62: // maior
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[90][lol];
break;
case 63: // interrogação
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[42][lol];
break;
case 64: // xadrez
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[89][lol];
break;
case 91: // [
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[80][lol];
break;
case 92: // barra inveritda
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[81][lol];
break;
case 93: // ]
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[82][lol];
break;
case 94: // til
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[86][lol];
break;
case 95: // underline
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[83][lol];
break;
case 96: // robot
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[88][lol];
break;
case 124: // pipe
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[84][lol];
break;
case 126: // circunflexo
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[87][lol];
break;
default:
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[92][lol];
break;
}
}
}
}
display_word(1,patterns,array_turn,15); // chama a função com os argumentos (loops=1, word_print=patterns, num_patterns=array_turn, delay_langth=15)
array_turn =0; // limpa a variável array_turn
}
}
// display_word(1,patterns,43,15);
// chamadas para a função display_pattern usam o laço int = 15 (se você fizer mais laços o padrão irá rolar mais lento).
void latchOn(){
bitSet(PORTB,latchPinPORTB); // configura o bit de latch para 1 (set)
}
void latchOff(){
bitClear(PORTB,latchPinPORTB); // configura o bit de latch para 0 (reset)
}
void setupSPI(){ // configura todos os registros para comunicação SPI
byte clr; // inicializa
SPCR |= ( (1<<SPE) | (1<<MSTR) ); // habilita SPI como master
//SPCR |= ( (1<<SPR1) | (1<<SPR0) ); // configura os bits de prescaler
SPCR &= ~( (1<<SPR1) | (1<<SPR0) ); // limpaos bits de prescaler
clr=SPSR; // limpa o reg status do SPI
clr=SPDR; // limpa o reg data do SPI
SPSR |= (1<<SPI2X); // configura os bits de prescaler
//SPSR &= ~(1<<SPI2X); // limpa os bits de prescaler
delay(10); // pequeno atraso
}
byte spi_transfer(byte data)
{
SPDR = data; // inicia transmissão
while (!(SPSR & (1<<SPIF))) // espera o fim da transmissão
{
};
return SPDR; // retorna com o bayte recebido, não precisamos dele
}
// FIM DA COMPILÇÃO
TESTES (Vídeos):
Assista também no Youtube:
Dúvidas e sugestões enviem para: arduinobymyself@gmail.com
http://www.youtube.com/watch?v=uRSsRZ9nJTU
http://www.youtube.com/watch?v=WL-Gj6Cu7j4&feature=youtu.be