sexta-feira, 27 de julho de 2012

Matriz de LEDs 24x6

Arduino by my Self

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.
Antes de soldar os componentes, limpe a placa, lado cobreado, com palha de aço fina a seco, e depois com papel toalha também a seco.

Soldando os LEDs (detalhe parcial).
Posicione os LEDs corretamente na placa de tal modo que não fique torto ou com alturas diferente (deixe bem rente à placa de circuito, ou se tiver use espaçadores para LED).

LEDs soldados (detalhe parcial).

Matriz Fiação Soldada

Detalhe da fiação.
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, 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
Porque não soldar os cabos inserindo nos furos da placa e sim por traz?
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
2. Placa de controle da matriz:-

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
Após o layout com o Software EagleCad, a placa ficou com 8x10.
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
Aqui, você pode utilizar qualquer método de transferência desejado ou para fazer o 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
Aqui vale lembrar aquela regrinha básica para soldar:
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
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 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

Vamos ao soft....

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

video




video

http://www.youtube.com/watch?v=WL-Gj6Cu7j4&feature=youtu.be