Está en la página 1de 38

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
memria, ra um antigo sonho meu! Realizado, agora, com Arduino!
O conceito muito simples:
Receber a mensagem por comunicao serial de um PC, ou ento de uma memria com os dados
armazenado, ou ainda com a mensagem pr-programada dentro do prprio 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 informao dos smbolos atravs da matriz.
Sendo possvel deixar essa mensagem esttica na matriz (o que no realmente o objetivo), ou
rolar a mensagem da direita para a esquerda, ou ainda fazer efeitos de transio, por exemplo: de
cima para baixo e vice-versa, piscar, etc...
Tudo isso torna-se possvel com o uso do verstil Arduino e por um custo muito barato.
A utilidade torna-se muito grande (desde comercial, residncial, ou educativo), ou por simples
hobby.

Bom vamos ao que interessa:


Foram mais de 30 horas entre projeto e execuo. Tudo muito bem projetado, para no haver
erros.
Horas de: Prancheta, desenhos, EagleCad, medidas, gabaritos, testes, decises, etc...
Confeco de placa, confeco da Matriz de LEDs, testes do programa.... e assim por diante.
Mas valeu a pena!
E agora vamos explicar tudinho, pra que voc tambm possa fazer uma e desfrutar desse sonho
tambm...
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 padro de 30x15 (ser usado a metade)
144 x LEDs (na sua cor de preferncia)(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 corroso (percloreto de ferro)
Ferramentas em geral (alicates de bico, alicates de corte, serra, perfurador de placa, riscador,
rgua, chaves de fenda, limas, ferro de soldar, estanho, etc...).
Multmetro
Material de apoio (fonte de alimentao, 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 referncia 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 so interconectados entre
si, e o final de cada linha ser a conexo de uma linha da matriz, conexo est ligada a uma das
vias do flat-cable de 6 vias com conector fmea na outra ponta.
Para cada coluna de LEDs (so 24 colunas e cada coluna com 6 x LEDs), teremos todos os
anodos dos LEDs interconectados entre si, formando 24 vias. Cada 8 colunas sero ligadas via
flat-cable a placa controladora por flat-cables de 8 vias com conector fmea na outra ponta (sero
usados 3 cabos como este).

Cortar a placa perfurada e deix-la com 80x27 furos (sero usados 70x17, os que sobrarem so
para dar uma folga na montagem e para poder fazer o acabamento futuro).

Placa perfurada padro, lado cobreado.

Placa perfurada padro, lado dos componentes.


Antes de soldar os componentes, limpe a placa, lado cobreado, com palha de ao fina a seco, e
depois com papel toalha tambm a seco.

Soldando os LEDs (detalhe parcial).


Posicione os LEDs corretamente na placa de tal modo que no fique torto ou com alturas diferente
(deixe bem rente placa de circuito, ou se tiver use espaadores para LED).

LEDs soldados (detalhe parcial).

Matriz Fiao Soldada

Detalhe da fiao.
Dobre somente os LEDs das pontas.... os LEDs do meio devem ser soldados a esses terminais.

Exemplo: LEDs na placa

Matriz completa.
Conselho:
Conforme for sendo executado a solda dos LEDs, tambm 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 difcil e trabalhoso.
Como detalhe final, poderia por exemplo ser furado um acrlico 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:

Confeco dos flatcables

Soldando os cabos na matriz

Detalhe da ligao dos cabos

Matriz finalizada

Passe cola quente para fixar bem os cabos e evitar rupturas na solda

Porque no soldar os cabos inserindo nos furos da placa e sim por traz?
Exatamente pela proposta que foi dada antes.... fazer um acrlico 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 fixao

Detalhe da fixao

2. Placa de controle da matriz:Esquema eltrico:

Esquema Eltrico

Placa de Controle, face nica, proposta 1

Placa de controle, face nica, proposta 2

No projeto inicial (desenhado a mo e com gabarito de componentes) a placa tinha 10 x 10 cm.

Placa e layout, face nica

Aps o layout com o Software EagleCad, a placa ficou com 8x10.


Passado em papel milimetrado, somente furao.

Layout em papel milimetrado, para furao

Ferramentas e placa envolvida pelo papel

Furao iniciada

Placa furada, lado cobreado

Placa furada, lado componentes

Passando o layout para a placa com caneta p/ circuito impresso

Aqui, voc pode utilizar qualquer mtodo de transferncia desejado ou para fazer o circuito
impresso.

Placa devidamente furada e corroda

Teste de colocao dos soquetes e pinos para verificar a correta disposio

OBS.: faa uma rigorosa verificao se existem trilahs/ilhas em curto ou em aberto antes de soldar
os componentes.

Componentes soldados

Detalhe da solda

Aqui vale lembrar aquela regrinha bsica para soldar:


Coloque o ferro de solda na juno da ilha cobreada e o terminal do componente, aquea por 1
segundo e aplique o estanho na juno 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 SERVIO!!!
AGORA VOC TEM A PLACA DE CONTROLE E A MATRIZ DE LEDs MONTADAS!!!

Vamos continuar,

3. Interligao 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

Observe muito bem..... essa pinagem, para poder confeccionar corretamente o flatcable.....!
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 nmeros

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 alimentao

Ligao com a Matriz

Vista geral das conexes

/*
###############################################################################
#
# 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 cdigo de domnio pblico.
*/
#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,SP
ACE,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 comunicao 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 comunicao serial e
#
mostra no display da matriz
#
# Autor:
Marcelo Moraes
# Data:
24/07/12
# Local:
Sorocaba - SP
#
###############################################################################
#
Este exemplo um cdigo de domnio pblico.
*/

// definindo todos os smbolos


#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 definio de smbolos
// definio 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 definio de pinos do Arduino
// configurao de pinos para fcil operao 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
// definio e inicializao de variveis
int i = 0; // inicia varivel 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 smbolos, 86 simbolos, cada smbolo 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,S
PACE,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 inicializao
void setup(){
Serial.begin(9600);// inicializa a comunicao 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 comunicao SPI
}
// fim do loop inicial
// funo 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 lao (quantas vezes ser executado, aumentando este valor a
mensagem rola mais devagar e vice-versa)
i = 0; // varivel 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 posio da matriz (inicia vazia)
}
for(int x=0;x<num_patterns;x++){// loop principal que passa sobre todos os smbolos
for(int scroll=0;scroll<6;scroll++){// loop para rolagem, cada smbolo rola por 6 colunas
for(int r=0;r<6;r++){// passando por cima de todas as linhas
// esta a funo 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 persistncia da
informao
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 lao 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();// comeando a comunicao com os registadores de deslocamento
spi_transfer(scrolling_word[y][2]); // enviando informao (3 bytes)
spi_transfer(scrolling_word[y][1]);
spi_transfer(scrolling_word[y][0]);
latchOn(); // chama funo
delayMicroseconds(800); // um pequeno atraso para cada linha
latchOff(); // chama funo
// limpando os registradores de deslocamento para ter certeza que no vai haver um efeito
fantasma
spi_transfer(0); // manda nada na comunicao SPI
spi_transfer(0);
spi_transfer(0);
latchOn(); // chama funo
// avanar 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++; // prxima iterao
}
}
}
}
finish_scroll(delay_langth); // chamando uma funo para terminar de rolar os ltimos 4 smbolos

}
// fim desta funo
// esta funo termina a rolagem e muito similar a funo 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 funo

// 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 smbolo na matriz
array_turn++; // contando o nmero de smbolos entrantes
}
else{ // caso contrrio...

// esta parte para obter a informao que temos e coloc-la em uma forma possamos
trabalhar com ela
if(array_turn != 0){ // se varivel array_turn no 0, significa que temos smboloa a serem
mostrados
for(int az=0;az<array_turn;az++){// verifica cada simbolo, se so letras, entre "65 e 90" ou
"97 e 122" em ASCII
// nmeros esto 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 padro (acha na matiz o smbolo "letra" recebido)
}
else{ // para nmeros
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 padro (acha na matiz o smbolo "nmero" recebido)
}}
else{ // para outros simbolos
switch(incomingByte[az]){
case 32: // espao
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[26][lol];
break;
case 33: // exclamao
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: // vrgula
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 diviso
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: // interrogao
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 funo com os argumentos (loops=1,
word_print=patterns, num_patterns=array_turn, delay_langth=15)

array_turn =0; // limpa a varivel array_turn


}
}
// display_word(1,patterns,43,15);
// chamadas para a funo display_pattern usam o lao int = 15 (se voc fizer mais laos o padro
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 comunicao 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 transmisso
while (!(SPSR & (1<<SPIF))) // espera o fim da transmisso
{
};
return SPDR; // retorna com o bayte recebido, no precisamos dele
}
// FIM DA COMPILO

También podría gustarte