Documentos de Académico
Documentos de Profesional
Documentos de Cultura
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.
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).
Detalhe da fiao.
Dobre somente os LEDs das pontas.... os LEDs do meio devem ser soldados a esses terminais.
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:
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
Esquema Eltrico
Furao iniciada
Aqui, voc pode utilizar qualquer mtodo de transferncia desejado ou para fazer o circuito
impresso.
OBS.: faa uma rigorosa verificao se existem trilahs/ilhas em curto ou em aberto antes de soldar
os componentes.
Componentes soldados
Detalhe da solda
BOM SERVIO!!!
AGORA VOC TEM A PLACA DE CONTROLE E A MATRIZ DE LEDs MONTADAS!!!
Vamos continuar,
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
Mais pinagens
Pinos de alimentao
/*
###############################################################################
#
# 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
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
/*
###############################################################################
#
# 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.
*/
#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"
// 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
// 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)