Arduino + matriz led 8×8

Olá pessoal, vamos ver mais um projeto super legal utilizando o arduino pra controlar uma matriz de leds 8 X 8. Com isso podemos fazer varias formas desenhos e todo um letreiro com as letras do alfabeto.

 

O que vamos utilizar no projeto:

– Arduino Uno

– Protoboard ( se tiver 2 protobaords vai ajudar)

– Matrix led 8×8

Fritzing:

Está é a ligação correta das portas do arduino com a matriz de led. Esta imagem foi tirada do site oficial do arduino:

http://arduino.cc/playground/Main/DirectDriveLEDMatrix

Tentei criar no fritzing mas a matriz de led 8×8 tem apenas 6 pinos de cada extremidade, não sei porque não são 8 pinos.

Como vocês podem ver aqui no fritzing eu utilizei 2 protoboards pois a matriz de led é bem grande e vocês não vão conseguir ligar com apenas uma protoboard.

Outra solução foi a que eu usei foi soldar fios em cada pino da matriz de led 8×8:

Código:

/*
 * Projeto exemplo para uma matriz de LEDs 8 x 8
 *
 * 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[] = " MEET ARDUINO ";  //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;
}

Video:


Resultado final:

Anúncios
Esse post foi publicado em Arduino e marcado , , , , , , , . Guardar link permanente.

10 respostas para Arduino + matriz led 8×8

  1. Conheçi o Arduino recentemente, e estou impressionado pois me parece ser fácil de entender e é bem divertido.

  2. hugo disse:

    Amigo vc poderia descrever os materiais que voce utilizou por exemplo a quantidade de fios?
    Obrigado.

  3. Cristiane de Andrade disse:

    preciso saber como colocar os pinos, urgentemente !!!

      • Kica Andrade disse:

        bem, eu fiz uma matriz de Led com as cores verde e vermelho.
        mas quando eu coloco o código pra rodar, os leds que deveriam apagar ficam acesos, só que bem fraquinho.
        Enquanto que a outra matriz só com leds brancos roda normal.
        não sei qual é o problema, achei que era a forma como eu colocava os fios nos pinos, mas agora que testei com a matriz de leds brancos vejo que não !!!

    • carlos disse:

      como assim pinos da mariz ou do arduino

  4. carlos disse:

    gostei muinto bom

  5. carlos disse:

    sou novo o assunto e gostaria de saber como fazre para dar delay em determinada letra,montei a matriz com displey 5.7.

  6. carlos disse:

    Em breve postarei um video com matriz usando max 7219 com 4 max 8×32 .com codigo para copiar .

  7. Francisco Medeiros disse:

    Boas, tenho uma duvida.
    Como consigo meter as letras a aparecerem em sentido oposto?
    Ou seja está a aparecer da esquerda para a direita e eu queria por da direita para a esquerda.
    Alguem pode ajudar?

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s