segunda-feira, 30 de abril de 2012

Matriz LED 8x8 - Mensagem

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);



Nesta experiência, será possível rolar uma mensagem pré-definida em uma matriz de LEDs de 8x8 pontos.

Você pode facilmente criar novos padrões de mensagens e ou ícones.

Consulte: http://www.instructables.com/id/Arduino-Expermentation-Kit-How-to-get-Started-wi/?ALLSTEPS
para maiores informações sobre LEDs e circuitos com Arduino.

O HARDWARE:
1 x Arduino UNO ou Duemilanove
1 x Bread Board
1 x Matriz de LEDs 8x8 catodo comum
8 x Resistores de 220O
Fios e Cabos

O CIRCUITO:
Ligar a matriz conforme a figura.

Matriz 8x8 HSN-1088UR

Como Ligar a Matriz


Detalhes Construtivos


Detalhes Construtivos

Tabela de Pinagem:


LINHA
PINO
ARDUINO
1
9
13
2
14
8
3
8
17
4
12
10
5
1
5
6
7
16
7
2
4
8
5
14



COLUNA
PINO
ARDUINO
1
13
9
2
3
3
3
4
2
4
10
12
5
6
15
6
11
11
7
15
7
8
16
6







O SOFTWARE:

MATRIX TEST:-


int speed = 5; //tempo de atraso em milisegundos

int pauseDelay = 1;    //número de milisegundos para mostrar cada linha

//definição de pinos
int rowA[] = {13,8,17,10,5,16,4,14}; //matriz que define quais são os pinos
                                     //de cada linha no Arduino
                                     //(linhas são anodo comum (acionada com HIGH))
int colA[] = {9,3,2,12,15,11,7,6};  //matris que define quais são os pinos
                                    //de cada coluna no Arduino
                                    //(colunas são catodo comum (acionada com LOW))

//matriz usada para armazenar um mapa de bits do display 
//se você desejar algum outro padrão de rolagem mude os dados desta
//variável)
byte data[] = {0,0,0,0,0,0,0,0};    


//roda somente na inicialização do sistema Arduino
void setup()

  Serial.begin(9600);         //inicializa a porta serial para debugging
  for(int i = 0; i <8; i++){  //configura os pinos usados para controle da matriz como saída
    pinMode(rowA[i], OUTPUT);
    pinMode(colA[i], OUTPUT);
  }
}

//loop principal do programa
void loop()
{
 //Examplo #1 - padrão de teste
 //roda um pequeno programa de teste
  test();
  
 //Example #2 - imagem estática
 //Define um mapa de bits a ser mostrado
 /*
  data[0] = B10101010; //row 1s bit mask (1 LED is on 0 LED is off)
  data[1] = B01010101; //row 1s bit mask (1 LED is on 0 LED is off)
  data[2] = B10101010; //row 1s bit mask (1 LED is on 0 LED is off)
  data[3] = B01010101; //row 1s bit mask (1 LED is on 0 LED is off)
  data[4] = B10101010; //row 1s bit mask (1 LED is on 0 LED is off)
  data[5] = B01010101; //row 1s bit mask (1 LED is on 0 LED is off)
  data[6] = B10101010; //row 1s bit mask (1 LED is on 0 LED is off)  
  data[7] = B01010101; //row 1s bit mask (1 LED is on 0 LED is off)  
  showSprite(speed);
 */
}

//uma matriz contendo a potência de 2 usada como máscara de 
//bits para calcular o que mostrar
const int powers[] = {1,2,4,8,16,32,64,128};

//roda um padrão onde cada LED é aceso um após o outro
void test(){
  for(int i = 0; i < 8; i++){
    for(int ii = 0; ii< 8; ii++){
    data[i] = data[i]+ powers[ii];   //vai através de cada linha de luzes
                                     //acendendo cada coluna uma depois da outra
    showSprite(speed); //mostra padrão
    }
  }
  
  for(int i = 0; i < 8; i++){
    for(int ii = 0; ii< 8; ii++){
    data[i] = data[i] - powers[ii];   //vai através de cada linha de luzes
                                      //apagando cada coluna uma após a outra
    showSprite(speed); //mostra padrão
    }
  }  
}

//mostra um padrão no display
void showSprite(int speed2){
 for(int iii = 0; iii < speed2; iii++){  //mostra o frame corrente speed2 vezes
  for(int column = 0; column < 8; column++){ //iteração de colunas
   for(int i = 0; i < 8; i++){                          
       digitalWrite(rowA[i], LOW);   //apaga todos os pinos das linhas
   }
   for(int i = 0; i < 8; i++){ //configura apenas um pino
     if(i == column){     digitalWrite(colA[i], LOW);}  //habilita a linha corrente somente
     else{                digitalWrite(colA[i], HIGH); }//desliga o restante das linhas
   }

   for(int row = 0; row < 8; row++){ //iteração de cada pixel na coluna corrente
    int bit = (data[column] >> row) & 1;
    if(bit == 1){ 
       digitalWrite(rowA[row], HIGH);   //se o bit na matriz de dados 
                                        //está setado, liga o LED
    }

   }
   delay(pauseDelay);    //deixa a coluna ligada por pauseDelay em microsecondos 
                         //(delay muito alto causa tremulação)
  } 
 }
}
//FIM DA COMPILAÇÃO


MATRIX SCROLL:-

/*
 * Código exemplo para uma mtriz de LEDs 8 x 8
 * Para maiores detalhes veja http://www.tinyurl.com/yhwxv6h
 *
 * Rola uma mensagem através da matriz de LEDs
 * Para ajustar a velocidade, mude a variável speed.
 * A mensagem é armazenada em requestString[]
 */


int speed = 20; //número de vezes que o frame será repetido
int pauseDelay = 500;  //microsecondos para deixar cada linha acesa antes
                       //de mover para o próximo

char requestString[] = " MARCELO % ";  //Mensagem a ser mostrada
                                        //para mudar a mensagem no código
                                        //você simplesmente escreve outra
                                        //mude estes dados e reset o indice e 
                                        //offset para 0
//Variáveis usadas para rolagem ambas começam em 0
int index = 0;  //este é o caracter corrente na string sendo mostrada
int offset = 0; //esta são quantas colunas de offset

//definição de pinos
int rowA[] = {13,8,17,10,5,16,4,14}; //matriz que define quais são os pinos
                                     //de cada linha no Arduino
                                     //(linhas são anodo comum (acionada com HIGH))
int colA[] = {9,3,2,12,15,11,7,6};  //matris que define quais são os pinos
                                    //de cada coluna no Arduino
                                    //(colunas são catodo comum (acionada com LOW))

//constantes definindo cada posição de caracter numa matriz de inteiros
//Letras
const int A = 0;  const int B = 1;  const int C = 2;  const int D = 3;  const int E = 4;
const int F = 5;  const int G = 6;  const int H = 7;  const int I = 8;  const int J = 9;  
const int K = 10; const int L =11;  const int M = 12; const int N = 13; const int O = 14; 
const int P = 15; const int Q =16;  const int R = 17; const int S = 18; const int T = 19; 
const int U = 20; const int V =21;  const int W = 22; const int X = 23; const int Y = 24; 
const int Z = 25;

//Pontuação
const int COL =26; const int DASH = 27; const int BRA2 = 28; const int  _ = 29; const int LINE = 34;
const int DOT =36;

//Caracteres extras
const int  FULL =30; const int CHECK = 31; const int B2 = 32; const int TEMP = 33; 
const int SMILE =35; const int COLDOT = 36;


//Matriz usada para armazenar um mapa de bits a ser mostrado 
//(se você desejar fazer algum outro modifique os dados desta
//variável)
byte data[] = {0,0,0,0,0,0,0,0};        

//O alfabeto
//cada caracter é um mapa de bit de 8 x 7 onde 1 é ligado e 0 é desligado
const int _A[] = {B0001000,
                  B0010100,
                  B0100010,
                  B1000001,
                  B1111111,
                  B1000001,
                  B1000001,
                  B0000000};

const int _B[] = {B1111110,
                  B0100001,
                  B0100001,
                  B0111110,
                  B0100001,
                  B0100001,
                  B1111110,
                  B0000000};

const int _C[] = {B0011111,
                  B0100000,
                  B1000000,
                  B1000000,
                  B1000000,
                  B0100000,
                  B0011111,
                  B0000000};

const int _D[] = {B1111100,
                  B0100010,
                  B0100001,
                  B0100001,
                  B0100001,
                  B0100010,
                  B1111100,
                  B0000000};

const int _E[] = {B1111111,
                  B1000000,
                  B1000000,
                  B1111100,
                  B1000000,
                  B1000000,
                  B1111111,
                  B0000000};

const int _F[] = {B1111111,
                  B1000000,
                  B1000000,
                  B1111100,
                  B1000000,
                  B1000000,
                  B1000000,
                  B0000000};

const int _G[] = {B0011111,
                  B0100000,
                  B1000000,
                  B1001111,
                  B1000001,
                  B0100001,
                  B0011111,
                  B0000000};

const int _H[] = {B1000001,
                  B1000001,
                  B1000001,
                  B1111111,
                  B1000001,
                  B1000001,
                  B1000001,
                  B0000000};

const int _I[] = {B1111111,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B1111111,
                  B0000000};

const int _J[] = {B0001111,
                  B0000001,
                  B0000001,
                  B0000001,
                  B0000001,
                  B1000001,
                  B0111110,
                  B0000000};

const int _K[] = {B1000011,
                  B1000100,
                  B1001000,
                  B1110000,
                  B1001000,
                  B1000100,
                  B1000011,
                  B0000000};

const int _L[] = {B1000000,
                  B1000000,
                  B1000000,
                  B1000000,
                  B1000000,
                  B1000000,
                  B1111111,
                  B0000000};

const int _M[] = {B1110110,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B0000000};

const int _N[] = {B1000001,
                  B1100001,
                  B1010001,
                  B1001001,
                  B1000101,
                  B1000011,
                  B1000001,
                  B0000000};

const int _O[] = {B0011100,
                  B0100010,
                  B1000001,
                  B1001001,
                  B1000001,
                  B0100010,
                  B0011100,
                  B0000000};

const int _P[] = {B1111110,
                  B0100001,
                  B0100001,
                  B0111110,
                  B0100000,
                  B0100000,
                  B0100000,
                  B0000000};

const int _Q[] = {B0011100,
                  B0100010,
                  B1000001,
                  B1000001,
                  B1000101,
                  B0100010,
                  B0011101,
                  B0000000};

const int _R[] = {B1111110,
                  B0100001,
                  B0100001,
                  B0101110,
                  B0100100,
                  B0100010,
                  B0100001,
                  B0000000};

const int _S[] = {B0111111,
                  B1000000,
                  B1000000,
                  B0111110,
                  B0000001,
                  B0000001,
                  B1111110,
                  B0000000};

const int _T[] = {B1111111,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0000000};

const int _U[] = {B1000001,
                  B1000001,
                  B1000001,
                  B1000001,
                  B1000001,
                  B1000001,
                  B0111110,
                  B0000000};

const int _V[] = {B1000001,
                  B1000001,
                  B1000001,
                  B1000001,
                  B0100010,
                  B0010100,
                  B0001000,
                  B0000000};
                  
const int _W[] = {B1000001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B0110110,
                  B0000000};

const int _X[] = {B1000001,
                  B0100010,
                  B0010100,
                  B0001000,
                  B0010100,
                  B0100010,
                  B1000001,
                  B0000000};

const int _Y[] = {B1000001,
                  B0100010,
                  B0010100,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0000000};

const int _Z[] = {B1111111,
                  B0000010,
                  B0000100,
                  B0111110,
                  B0010000,
                  B0100000,
                  B1111111,
                  B0000000};

const int _COL[] = {B0000000,
                    B0011000,
                    B0011000,
                    B0000000,
                    B0011000,
                    B0011000,
                    B0000000,
                    B0000000};

const int _DASH[] = {B0000000,
                     B0000000,
                     B0000000,
                     B0111110,
                     B0000000,
                     B0000000,
                     B0000000,
                     B0000000};

const int _BRA2[] = {B0010000,
                     B0001000,
                     B0000100,
                     B0000100,
                     B0001000,
                     B0010000,
                     B0000000,
                     B0000000};                  

const int __[] = {B0000000,
                  B0000000,
                  B0000000,
                  B0000000,
                  B0000000,
                  B0000000,
                  B0000000,
                  B0000000};

const int _FULL[] = {B1111111,
                     B1111111,
                     B1111111,
                     B1111111,
                     B1111111,
                     B1111111,
                     B1111111,
                     B0000000};                  

const int _CHECK[] = {B1010101,
                      B0101010,
                      B1010101,
                      B0101010,
                      B1010101,
                      B0101010,
                      B1010101,
                      B0000000};
                  
const int _B2[] = {B0111110,
                   B0000001,
                   B0000001,
                   B0001111,
                   B0000001,
                   B1000001,
                   B0111110,
                   B0000000};

const int _TEMP[] = {B0000011,
                     B0011111,
                     B0111111,
                     B1111110,
                     B1111111,
                     B0011111,
                     B0000011,
                     B0000000};

const int _LINE[] = {B0000001,
                     B0000001,
                     B0000001,
                     B0000001,
                     B0000001,
                     B0000001,
                     B0000001,
                     B0000000};                     
                 
const int _SMILE[] = {B000000,
                      B1100100,
                      B1100010,
                      B0011001,
                      B1100010,
                      B1100100,
                      B0000000,
                      B0000000};                     
                  

const int _DOT[] = {B0000000,
                    B0000000,
                    B0000000,
                    B0000000,
                    B1100000,
                    B1100000,
                    B0000000,
                    B0000000};                     
                  
const int _COLDOT[] = {B0000000,
                       B0110000,
                       B0110000,
                       B0000000,
                       B0110011,
                       B0110011,
                       B0000000,
                       B0000000};                  

//carrega o mapa de bits de caracter numa matriz 
//cada posição de caracter corresponde ao seu indice previamente definido
//isto é _A (mapa de bits do "a") 
//se o indice 0 é do "A", então letters[A] retornará o mapa de bits de "A")
const int* letters[] = {_A,_B,_C,_D,_E,_F,_G,_H,_I,_J,_K,_L,_M,_N,_O,_P,_Q,_R,_S,_T,_U,_V,_W,_X,_Y,_Z,_COL,_DASH,_BRA2,__, _FULL, _CHECK, _B2, _TEMP, _LINE, _SMILE, _DOT, _COLDOT};

//definição do Arduino roda somente na inicialização
void setup()

  for(int i = 0; i <8; i++){  //configura os 16 pinos usados para controlar 
                              // a matriz como pinos de saída
    pinMode(rowA[i], OUTPUT);
    pinMode(colA[i], OUTPUT);
  }
}

//loop do programa principal   
void loop()
{
 updateMatrix(); //atualiza a matrix com informação a ser mostrada
}



void updateMatrix(){
  loadSprite(); //carrega mapa de bits
  showSprite(speed); //mostra o mapa com a velocidade programada
}


//uma matriz contendo a potência de 2 usada como máscara de 
//bits para calcular o que mostrar
const int powers[] = {1,2,4,8,16,32,64,128};

//carrega o estado atual do quadro a ser mostrado na matriz data[]
void loadSprite(){
  int currentChar = getChar(requestString[index]); //lê caracter da matriz
  int nextChar = getChar(requestString[index+1]); //lê o próximo
  
  for(int row=0; row < 8; row++){                    //iteração para cada linha
    data[row] = 0;                                   //reseta a linha de trabalho
    for(int column=0; column < 8; column++){         //iteração para cada coluna
     //carrega o caractere atual, compensado por pixels de deslocamento 
     data[row] = data[row] + ((powers[column] & (letters[currentChar][row] << offset)));   
     //carrega o próximo caracte compensado por pixels de deslocamento
     data[row] = data[row] + (powers[column] & (letters[nextChar][row] >> (8-offset) ));   
    }
  }
  offset++; //incrementa o offset de uma linha
  //se offset é de 8, carregar o par de caracteres a seguir na proxima vez 
  if(offset==8){offset = 0; index++; if(index==sizeof(requestString)-2){index=0;}}         
}

void showSprite(int speed2){
 for(int iii = 0; iii < speed2; iii++){                 //mostra o frame corrente de speed2
  for(int column = 0; column < 8; column++){            //iteração de cada coluna
   for(int i = 0; i < 8; i++){                          
       digitalWrite(rowA[i], LOW);                      //desliga todos os pinos de linhas
   }
   for(int i = 0; i < 8; i++){ //configura somente um pino
     if(i == column){     digitalWrite(colA[i], LOW);}  //liga a linha corrente
     else{                digitalWrite(colA[i], HIGH); }//liga o restante das linhas
   }

   for(int row = 0; row < 8; row++){ //iteração através de cada pixel da coluna corrente
    int bit = (data[column] >> row) & 1;
    if(bit == 1){ 
      //se o bit na matriz de dados está definido, acende o LED 
      digitalWrite(rowA[row], HIGH);                   
    }

   }
   //deixar a coluna em pauseDelay microsecondos (muito alta a demora causa tremulação)
   delayMicroseconds(pauseDelay);                       
  } 
 }
}

//retorna o indice de um dado caractere
//para a conversão de uma string e 
//para a pesquisa na mtriz de mapa de bit de caracteres
int getChar(char charachter){
 int returnValue = Z;
 switch(charachter){
  case 'A': returnValue = A; break;
  case 'a': returnValue = A; break;
  case 'B': returnValue = B; break;
  case 'b': returnValue = B; break;
  case 'C': returnValue = C; break;
  case 'c': returnValue = C; break;
  case 'D': returnValue = D; break;
  case 'd': returnValue = D; break;
  case 'E': returnValue = E; break;
  case 'e': returnValue = E; break;
  case 'F': returnValue = F; break;
  case 'f': returnValue = F; break;
  case 'G': returnValue = G; break;
  case 'g': returnValue = G; break;
  case 'H': returnValue = H; break;
  case 'h': returnValue = H; break;
  case 'I': returnValue = I; break;
  case 'i': returnValue = I; break;
  case 'J': returnValue = J; break;
  case 'j': returnValue = J; break;
  case 'K': returnValue = K; break;
  case 'k': returnValue = K; break;
  case 'L': returnValue = L; break;
  case 'l': returnValue = L; break;
  case 'M': returnValue = M; break;
  case 'm': returnValue = M; break;
  case 'N': returnValue = N; break;
  case 'n': returnValue = N; break;
  case 'O': returnValue = O; break;
  case 'o': returnValue = O; break;
  case 'P': returnValue = P; break;
  case 'p': returnValue = P; break;
  case 'Q': returnValue = Q; break;
  case 'q': returnValue = Q; break;
  case 'R': returnValue = R; break;
  case 'r': returnValue = R; break;
  case 'S': returnValue = S; break;
  case 's': returnValue = S; break;
  case 'T': returnValue = T; break;
  case 't': returnValue = T; break;
  case 'U': returnValue = U; break;
  case 'u': returnValue = U; break;
  case 'V': returnValue = V; break;
  case 'v': returnValue = V; break;
  case 'W': returnValue = W; break;
  case 'w': returnValue = W; break;
  case 'X': returnValue = X; break;
  case 'x': returnValue = X; break;
  case 'Y': returnValue = Y; break;
  case 'y': returnValue = Y; break;
  case 'Z': returnValue = Z; break;
  case 'z': returnValue = Z; break;
  case ' ': returnValue = _; break;
  case '3': returnValue = B2; break;
  case '<': returnValue = TEMP; break;
  case '*': returnValue = FULL; break;
  case '|': returnValue = LINE; break;  
  case '_': returnValue = _; break;  
  case ':': returnValue = COL; break;  
  case '-': returnValue = DASH; break;  
  case ')': returnValue = BRA2; break;  
  case '%': returnValue = SMILE; break;  
  case '.': returnValue = DOT; break;    
  case '^': returnValue = COLDOT; break;      
  }
  return returnValue;
}
//FIM DA COMPILAÇÃO




O VÍDEO:

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

video