AULA 9 - Microcontroladores - Eng

<< Página do curso

---

TECLADO COM BUZZER

CONTROLADOR DE AQUARIOS

PLOTTER CNC

FECHADURA DE PORTA COM RFID

SEGUIDOR DE SOL PARA MODULOS FOTOVOLTAICOS

BAFOMETRO

---

Trabalho Davi

Protótipo

O aluno Davi utilizou um módulo de matriz de leds 8x8 e programou todas as rotinas.

Hardware/Eletrônica

Vídeo do protótipo

Firmware

int velFrame = 25; //QUANTIDADE DE VEZES QUE O FRA SERÁ REPETIDO
 int pauseDelay = 500;  //INTERVALO DE 500 MILISSEGUNDOS ENTRE AS  LINHAS
String c;
char msgExibida[15];
//Variáveis usadas para rolagem ambas começam em 0
int index = 0;  //CARACTERE CORRENTE NA STRING QUE ESTÁ SENDO MOSTRADA
int offset = 0; //QUANTIDADE DE COLUNAS DO OFFSET
 
int rowA[] = {13,8,17,10,5,16,4,14}; //VARIÁVEL RECEBE A PINAGEM A SER UTILIZADA PARA CONTROLE DAS LINAHS DA MATRIZ
//AS LINHAS SÃO ANODO COMUM
 
int colA[] = {9,3,2,12,15,11,7,6}; //VARIÁVEL RECEBE A PINAGEM A SER UTILIZADA PARA CONTROLE DAS COLUNAS DA MATRIZ
//AS COLUNAS SÃO CATODO COMUM
 
//CONSTANTES DEFININDO CADA POSIÇÃO DE CARACTERE 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 / PODE SER ALTERADO CASO QUEIRA USAR OUTRO MAPA
byte data[] = {0,0,0,0,0,0,0,0};        
 
//CADA CARACTERE É UM MAPA DE BITS DE 8X7 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 CARACTERE NUMA MATRIZ
//CADA POSIÇÃO DE CARACTERE CORRESPONDE AO SEU INDICE DEFINIDO ANTERIORMENTE
//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};
 
void setup(){
  Serial.begin(9600);
  for(int i = 0; i <8; i++){  //PARA i IGUAL A 0, ENQUANTO i MENOR QUE 8, INCREMENTA i
    pinMode(rowA[i], OUTPUT); //DECLARA COMO SAÍDA
    pinMode(colA[i], OUTPUT);//DECLARA COMO SAÍDA
  }
}
 
void loop(){
  while(Serial.available())
  {
  
  c = Serial.readString();
  c.toCharArray(msgExibida,15);
  Serial.println( msgExibida);

   }
updateMatrix(); //ATUALIZA A MATRIZ COM INFORMAÇÃO A SER MOSTRADA
}
 
void updateMatrix(){
  loadSprite(); //CARREGA O MAPA DE BITS
  showSprite(velFrame); //MOSTRA O MAPA COM A VELOCIDADE DEFINIDO NA VARIÁVEL velFrame
}
 
//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(msgExibida[index]); //LÊ O CARACTERE DA MATRIZ
  int nextChar = getChar(msgExibida[index+1]); //LÊ O PRÓXIMO CARACTERE
  
  for(int row=0; row < 8; row++){ //PARA row IGUAL A 0, ENQUANTO row MENOR QUE 8, INCREMENTA row
    data[row] = 0;                                   //RESETA A LINHA
    for(int column=0; column < 8; column++){ //PARA column IGUAL A 0, ENQUANTO column MENOR QUE 8, INCREMENTA column
     data[row] = data[row] + ((powers[column] & (letters[currentChar][row] << offset))); //CARREGA O CARACTERE ATUAL, COMPENSADO POR PIXELS DE DESLOCAMENTO
     data[row] = data[row] + (powers[column] & (letters[nextChar][row] >> (8-offset) ));  //CARREGA O PRÓXIMO CARACTERE COMPENSADO POR PIXELS DE DESLOCAMENTO
    }
  }
  offset++; //INCREMENTA O OFFSET DE UMA LINHA
  
  if(offset==8){offset = 0; index++; if(index==sizeof(msgExibida)-2){index=0;}} //SE OFFSET É DE 8, CARREGAR O PAR DE CARACTERES A SEGUIR NA PRÓXIMA VEZ    
}
 
void showSprite(int velFrame2){
for(int iii = 0; iii < velFrame2; iii++){ //PARA iii IGUAL A 0, ENQUANTO velFrame2 MENOR QUE iii, INCREMENTA iii
  for(int column = 0; column < 8; column++){ ///PARA column IGUAL A 0, ENQUANTO column MENOR QUE 8, INCREMENTA column
   for(int i = 0; i < 8; i++){ //PARA i IGUAL A 0, ENQUANTO i MENOR QUE 8, INCREMENTA i              
       digitalWrite(rowA[i], LOW); //DESLIGA TODOS OS PINOS DE LINHAS
   }
   for(int i = 0; i < 8; i++){ //PARA i IGUAL A 0, ENQUANTO i MENOR QUE 8, INCREMENTA i  
     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++){ //PARA row IGUAL A 0, ENQUANTO row MENOR QUE 8, INCREMENTA row
    int bit = (data[column] >> row) & 1;
    if(bit == 1){
      digitalWrite(rowA[row], HIGH); //SE O BIT NA MATRIZ DE DADOS ESTÁ DEFINIDO, ACENDE O LED            
    }
   }
   delayMicroseconds(pauseDelay); //INTERVALO DE 500MS                    
  }
}
}
 
//RETORNA O INDICE DE UM DADO CARACTERE
//PARA A CONVERSÃO DE UMA STRING E PARA A PESQUISA NA MATRIZ DE MAPA DE BIT DE CARACTERES
int getChar(char charachter){
int returnValue = _ ;
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; //RETORNO DE INFORMAÇÃO
}

---

Trabalho Júlia

Protótipo

Hardware/Eletrônica

A aluna Júlia utilizou um módulo de matriz de leds 8x8 MAX7219 e programou todas as rotinas.

Vídeo do protótipo

Firmware

/*********************************************************

 Trabalho 1 - MIC2
 Matriz de LED 8x8 com Arduino
 Aluna: Júlia Pedro Matsunaga
 Curso: Engenharia Elétrica
 Módulo: 7 
 Semestre: 2018/2
 
*Da montagem
--------------
-Placa de arduino UNO (1)
-Cabo USB (1)
-Matriz de LED 8x8 (1)
-Resistores de 220Ohms (8)
-Cabos de arduino macho-macho (16)
-Cabos de arduino macho-fêmea (16)

********************************************************/
 
int vel = 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

String str;
char requestString[20];
//= " Trabalho de microcontroladores: Engenharia Eletrica IFSC Itajai";  //Mensagem a ser mostrada

//Variáveis usadas para rolagem ambas começam em 0
int index = 0;  //este é o caracter na string sendo mostrada
int offset = 0; //esta são quantas colunas de offset
 
//definição de pinos
int linhaA[] = {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};      //matriz 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,B1000001,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};

//Os carcteres especiais
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()
{
  Serial.begin(9600);
  for(int i = 0; i <8; i++){  //configura os 16 pinos usados para controlar a matriz como pinos de saída
    pinMode(linhaA[i], OUTPUT);
    pinMode(colA[i], OUTPUT);
  }
}
 
//loop do programa principal
void loop(){
   while(Serial.available()){
    str=Serial.readString();
    str.toCharArray(requestString,20);
    Serial.println(requestString);
   }
   updateMatrix(); //atualiza a matrix com informação a ser mostrada
}
 
void updateMatrix(){
  loadSprite(); //carrega mapa de bits
  showSprite(vel); //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 proximaVar = getChar(requestString[index+1]); //lê o próximo
 
  for(int linha=0; linha < 8; linha++){              //iteração para cada linha
    data[linha] = 0;                                 //reseta a linha de trabalho
    for(int coluna=0; coluna < 8; coluna++){         //iteração para cada coluna
     //carrega o caractere atual, compensado por pixels de deslocamento
     data[linha] = data[linha] + ((powers[coluna] & (letters[currentChar][linha] << offset)));
     //carrega o próximo caracte compensado por pixels de deslocamento
     data[linha] = data[linha] + (powers[coluna] & (letters[proximaVar][linha] >> (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 vel2){
 for(int iii = 0; iii < vel2; iii++){                 //mostra o frame de vel2
  for(int coluna = 0; coluna < 8; coluna++){          //iteração de cada coluna
   for(int i = 0; i < 8; i++){
       digitalWrite(linhaA[i], LOW);                  //desliga todos os pinos de linhas
   }
   for(int i = 0; i < 8; i++){ //configura somente um pino
     if(i == coluna){     digitalWrite(colA[i], LOW);}  //liga a linha corrente
     else{                digitalWrite(colA[i], HIGH); }//liga o restante das linhas
   }
 
   for(int linha = 0; linha < 8; linha++){ //iteração através de cada pixel da coluna corrente
    int bit = (data[coluna] >> linha) & 1;
    if(bit == 1){
      //se o bit na matriz de dados está definido, acende o LED
      digitalWrite(linhaA[linha], 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 matriz de mapa de bit de caracteres
int getChar(char charachter){
 int returnValue = _; //Retorna Z toda vez que não reconhece o caracter
 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;
}
 

---

Trabalho Nelson

Protótipo

Hardware/Eletrônica

O aluno Nelson utilizou o módulo MAX7219 e biblioteca MaxMatriz.h

Vídeo 1 do protótipo

Vídeo 2 do protótipo

Firmware

#include <MaxMatrix.h>

#include <avr/pgmspace.h>

PROGMEM const unsigned char CH[] = {

 3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
 1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
 3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
 5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
 4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
 5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
 5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
 1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
 3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
 3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
 5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
 5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
 2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
 4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
 2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
 4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
 4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
 3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
 4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
 4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
 4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
 4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
 4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
 4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
 4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
 4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
 2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
 2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
 3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
 3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
 3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
 4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
 5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
 4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
 4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
 4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
 4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
 4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
 4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
 4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
 4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
 3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
 4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
 4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
 4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
 5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
 5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
 4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
 4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
 4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
 4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
 4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
 5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
 4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
 5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
 5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
 5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
 5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
 4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
 2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
 4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
 2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
 3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
 4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
 2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
 4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
 4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
 4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
 4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
 4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
 3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
 4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
 4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
 3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
 4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
 4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
 3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
 5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
 4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
 4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
 4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
 4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
 4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
 4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
 3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
 4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
 5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
 5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
 5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
 4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
 3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
 3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
 1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
 3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
 4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~

};

int DIN = 7;   // DIN pin of MAX7219 module
int CLK = 6;   // CLK pin of MAX7219 module
int CS = 5;    // CS pin of MAX7219 module
int maxInUse = 2;

MaxMatrix m(DIN, CS, CLK, maxInUse);  
   
char text[]= "IFSC 2018 - 7o FASE - NELSON "; // texto deslizante
 
void setup() {
 
 m.init(); // module initialize
 m.setIntensity(15); // intensidade do brilho

}

void loop() {

  printStringWithShift(text, 80); // (texto, velocidade de deslizamento)

}

// Display=the extracted characters with scrolling
void printCharWithShift(char c, int shift_speed) {
 
 if (c < 32) return;
 c -= 32;

 byte buffer[100];

 memcpy_P(buffer, CH + 7 * c, 7);
 m.writeSprite(32, 0, buffer);
 m.setColumn(32 + buffer[0], 0);

 for (int i = 0; i < buffer[0] + 1; i++)
 {
   delay(shift_speed);
   m.shiftLeft(false, false);
 }

}

 // Extract the characters from the text string
void printStringWithShift(char* s, int shift_speed) {

 while (*s != 0) {
   printCharWithShift(*s, shift_speed);
   s++;
  }
 
}

---

Trabalho Thiago

Protótipo

Hardware/Eletrônica

O aluno Thiago utilizou um módulo de matriz de leds 8x8 e programou todas as rotinas. Utilizou também uma IDE para Arduino no smarthphone, que permite enviar os textos do celular.

Vídeo 1 do protótipo

Vídeo 2 do protótipo, enviando o texto pelo celular

Firmware

#define ROW_1 2
#define ROW_2 3
#define ROW_3 4
#define ROW_4 5
#define ROW_5 6
#define ROW_6 7
#define ROW_7 8
#define ROW_8 9

#define COL_1 10
#define COL_2 11
#define COL_3 12
#define COL_4 13
#define COL_5 A0
#define COL_6 A1
#define COL_7 A2
#define COL_8 A3

const byte rows[] = {
   ROW_1, ROW_2, ROW_3, ROW_4, ROW_5, ROW_6, ROW_7, ROW_8
};
const byte col[] = {
  COL_1,COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8
};
// It's prefilled with a smiling face (1 = ON, 0 = OFF)
//byte TODOS[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
//byte EX[] = {B00000000,B00010000,B00010000,B00010000,B00010000,B00000000,B00010000,B00000000};
//byte A[] = {B00000000,B00011000,B00100100,B00100100,B00111100,B00100100,B00100100,B00000000};
//byte B[] = {B01111000,B01001000,B01001000,B01110000,B01001000,B01000100,B01000100,B01111100};
//byte C[] = {B00000000,B00011110,B00100000,B01000000,B01000000,B01000000,B00100000,B00011110};
//byte D[] = {B00000000,B00111000,B00100100,B00100010,B00100010,B00100100,B00111000,B00000000};
//byte E[] = {B00000000,B00111100,B00100000,B00111000,B00100000,B00100000,B00111100,B00000000};
//byte F[] = {B00000000,B00111100,B00100000,B00111000,B00100000,B00100000,B00100000,B00000000};
//byte G[] = {B00000000,B00111110,B00100000,B00100000,B00101110,B00100010,B00111110,B00000000};
//byte H[] = {B00000000,B00100100,B00100100,B00111100,B00100100,B00100100,B00100100,B00000000};
//byte I[] = {B00000000,B00111000,B00010000,B00010000,B00010000,B00010000,B00111000,B00000000};
//byte J[] = {B00000000,B00011100,B00001000,B00001000,B00001000,B00101000,B00111000,B00000000};
//byte K[] = {B00000000,B00100100,B00101000,B00110000,B00101000,B00100100,B00100100,B00000000};
//byte L[] = {B00000000,B00100000,B00100000,B00100000,B00100000,B00100000,B00111100,B00000000};
//byte M[] = {B00000000,B00000000,B01000100,B10101010,B10010010,B10000010,B10000010,B00000000};
//byte N[] = {B00000000,B00100010,B00110010,B00101010,B00100110,B00100010,B00000000,B00000000};
//byte O[] = {B00000000,B00111100,B01000010,B01000010,B01000010,B01000010,B00111100,B00000000};
//byte P[] = {B00000000,B00111000,B00100100,B00100100,B00111000,B00100000,B00100000,B00000000};
//byte Q[] = {B00000000,B00111100,B01000010,B01000010,B01000010,B01000110,B00111110,B00000001};
//byte R[] = {B00000000,B00111000,B00100100,B00100100,B00111000,B00100100,B00100100,B00000000};
//byte S[] = {B00000000,B00111100,B00100000,B00111100,B00000100,B00000100,B00111100,B00000000};
//byte T[] = {B00000000,B01111100,B00010000,B00010000,B00010000,B00010000,B00010000,B00000000};
//byte U[] = {B00000000,B01000010,B01000010,B01000010,B01000010,B00100100,B00011000,B00000000};
//byte V[] = {B00000000,B00100010,B00100010,B00100010,B00010100,B00010100,B00001000,B00000000};
//byte W[] = {B00000000,B10000010,B10010010,B01010100,B01010100,B00101000,B00000000,B00000000};
//byte X[] = {B00000000,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B00000000};
//byte Y[] = {B00000000,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00000000};
//byte Z[] = {B00000000,B00111100,B00000100,B00001000,B00010000,B00100000,B00111100,B00000000};

// The display buffer
// It's prefilled with a smiling face (0 = ON, 1 = OFF)
int j=0;
byte TODOS[] = {B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000};
byte EX[] = {B11111111,B11101111,B11101111,B11101111,B11101111,B11111111,B11101111,B11111111};

byte A[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte AA[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100111};
byte AAA[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100111,B11011011};
byte AAAA[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11100111,B11011011,B11011011};
byte AAAAA[] = {B11111111,B11111111,B11111111,B11111111,B11100111,B11011011,B11011011,B11000011};
byte AAAAAA[] = {B11111111,B11111111,B11111111,B11100111,B11011011,B11011011,B11000011,B11011011};
byte AAAAAAA[] = {B11111111,B11111111,B11100111,B11011011,B11011011,B11000011,B11011011,B11011011};
byte AAAAAAAA[] = {B11111111,B11100111,B11011011,B11011011,B11000011,B11011011,B11011011,B11111111};
byte AAAAAAAAA[] = {B11100111,B11011011,B11011011,B11000011,B11011011,B11011011,B11111111,B11111111};
byte AAAAAAAAAA[] = {B11011011,B11011011,B11000011,B11011011,B11011011,B11111111,B11111111,B11111111};
byte AAAAAAAAAAA[] = {B11011011,B11000011,B11011011,B11011011,B11111111,B11111111,B11111111,B11111111};
byte AAAAAAAAAAAA[] = {B11000011,B11011011,B11011011,B11111111,B11111111,B11111111,B11111111,B11111111};
byte AAAAAAAAAAAAA[] = {B11011011,B11011011,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte AAAAAAAAAAAAAA[] = {B11011011,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte AAAAAAAAAAAAAAA[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};

byte B[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte BB[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B10000111};
byte BBB[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B10000111,B10110111};
byte BBBB[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B10000111,B10110111,B10110111};
byte BBBBB[] = {B11111111,B11111111,B11111111,B11111111,B10000111,B10110111,B10110111,B10001111};
byte BBBBBB[] = {B11111111,B11111111,B11111111,B10000111,B10110111,B10110111,B10001111,B10110111};
byte BBBBBBB[] = {B11111111,B10000111,B10110111,B10110111,B10001111,B10110111,B10111011,B10111011};
byte BBBBBBBB[] = {B10000111,B10110111,B10110111,B10001111,B10110111,B10111011,B10111011,B10000011};
byte BBBBBBBBB[] = {B10110111,B10110111,B10001111,B10110111,B10111011,B10111011,B10000011,B11111111};
byte BBBBBBBBBB[] = {B10110111,B10001111,B10110111,B10111011,B10111011,B10000011,B11111111,B11111111};
byte BBBBBBBBBBB[] = {B10110111,B10001111,B10110111,B10111011,B10111011,B11111111,B11111111,B11111111};
byte BBBBBBBBBBBB[] = {B10110111,B10001111,B10110111,B10111011,B11111111,B11111111,B11111111,B11111111};
byte BBBBBBBBBBBBB[] = {B10110111,B10001111,B10110111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte BBBBBBBBBBBBBB[] = {B10110111,B10001111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte BBBBBBBBBBBBBBB[] = {B10110111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte BBBBBBBBBBBBBBBB[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};

byte C[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte CC[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100001};
byte CCC[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100001,B11011111};
byte CCCC[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11100001,B11011111,B10111111c};
byte CCCCC[] = {B11111111,B11111111,B11011111,B11111111,B10111111,B10111111,B11011111,B11100001};
byte CCCCCC[] = {B11111111,B11111111,B11111111,B10111111,B10111111,B10111111,B11011111,B11100001};
byte CCCCCCC[] = {B11111111,B11111111,B11111111,B11100001,B11011111,B10111111,B10111111,B11011111};
byte CCCCCCCC[] = {B11111111,B11111111,B11100001,B11011111,B10111111,B10111111,B10111111,B11011111};
byte CCCCCCCCC[] = {B11111111,B11100001,B11011111,B10111111,B10111111,B10111111,B11011111,B11100001};
byte CCCCCCCCCC[] = {B11100001,B11011111,B10111111,B10111111,B10111111,B11011111,B11100001,B11111111};
byte CCCCCCCCCCC[] = {B11011111,B10111111,B10111111,B10111111,B11011111,B11100001,B11111111,B11111111};
byte CCCCCCCCCCCC[] = {B11011111,B10111111,B10111111,B10111111,B11011111,B11111111,B11111111,B11111111};
byte CCCCCCCCCCCCC[] = {B10111111,B10111111,B10111111,B11011111,B11111111,B11111111,B11111111,B11111111};
byte CCCCCCCCCCCCCC[] = {B10111111,B10111111,B11011111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte CCCCCCCCCCCCCCC[] = {B10111111,B11011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte CCCCCCCCCCCCCCCC[] = {B10111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte CCCCCCCCCCCCCCCCC[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};

byte D[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDDDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDDDDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDDDDDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};
byte DDDDDDDDDDDDDDDD[] = {B11111111,B11000111,B11011011,B11011101,B11011101,B11011011,B11000111,B11111111};

byte E[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEEEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEEEEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEEEEEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};
byte EEEEEEEEEEEEEEEE[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11000011,B11111111};

byte F[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFFFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFFFFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFFFFFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFFFFFFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};
byte FFFFFFFFFFFFFFFF[] = {B11111111,B11000011,B11011111,B11000111,B11011111,B11011111,B11011111,B11111111};

byte G[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGGGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGGGGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGGGGGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};
byte GGGGGGGGGGGGGGGG[] = {B11111111,B11000001,B11011111,B11011111,B11010001,B11011101,B11000001,B11111111};

byte H[] = {B11111111,B11011011,B11011011,B11000011,B11011011,B11011011,B11011011,B11111111};
byte I[] = {B11111111,B11000111,B11101111,B11101111,B11101111,B11101111,B11000111,B11111111}; 
byte J[] = {B11111111,B11100011,B11110111,B11110111,B11110111,B11010111,B11000111,B11111111};
byte K[] = {B11111111,B11011011,B11010111,B11001111,B11010111,B11011011,B11011011,B11111111};
byte L[] = {B11111111,B11011111,B11011111,B11011111,B11011111,B11011111,B11000011,B11111111};
byte M[] = {B11111111,B11111111,B10111011,B01010101,B01101101,B01111101,B01111101,B11111111};
byte N[] = {B11111111,B11011101,B11001101,B11010101,B11011001,B11011101,B11111111,B11111111};
byte O[] = {B11111111,B11000011,B10111101,B10111101,B10111101,B10111101,B11000011,B11111111};
byte P[] = {B11111111,B11000111,B11011011,B11011011,B11000111,B11011111,B11011111,B11111111};
byte Q[] = {B11111111,B11000011,B10111101,B10111101,B10111101,B10111001,B11000001,B11111110};
byte R[] = {B11111111,B11000111,B11011011,B11011011,B11000111,B11011011,B11011011,B11111111};
byte S[] = {B11111111,B11000011,B11011111,B11000011,B11111011,B11111011,B11000011,B11111111};
byte T[] = {B11111111,B10000011,B11101111,B11101111,B11101111,B11101111,B11101111,B11111111};
byte U[] = {B11111111,B10111101,B10111101,B10111101,B10111101,B11011011,B11100111,B11111111};
byte V[] = {B11111111,B11011101,B11011101,B11011101,B11101011,B11101011,B11110111,B11111111};
byte W[] = {B11111111,B01111101,B01101101,B10101011,B10101011,B11010111,B11111111,B11111111};
byte X[] = {B11111111,B10111101,B11011011,B11100111,B11100111,B11011011,B10111101,B11111111};
byte Y[] = {B11111111,B10111011,B11010111,B11101111,B11101111,B11101111,B11101111,B11111111};
byte Z[] = {B11111111,B11000011,B11111011,B11110111,B11101111,B11011111,B11000011,B11111111};
float timeCount = 0;

void setup() 
{
   // Open serial port
   Serial.begin(9600);
   String conteudo = "";
   // Set all used pins to OUTPUT
   // This is very important! If the pins are set to input
   // the display will be very dim.
   for (byte i = 2; i <= 13; i++)
       pinMode(i, OUTPUT);
   pinMode(A0, OUTPUT);
   pinMode(A1, OUTPUT);
   pinMode(A2, OUTPUT);
   pinMode(A3, OUTPUT);
}

String leStringSerial(){
 
   String conteudo = "";
 char caractere;

while(Serial.available() > 0) {
   // Lê byte da serial
   caractere = Serial.read();
   // Ignora caractere de quebra de linha
   if (caractere != '\n'){
     // Concatena valores
     conteudo.concat(caractere);
   }
   // Aguarda buffer serial ler próximo caractere
   delay(10);
 }
    
 Serial.print("Recebi: ");
 Serial.println(conteudo);
    
 return conteudo;
}

void showa()
{
 timeCount= 0;
 while(timeCount<320)
{       
timeCount += 1; 
if(timeCount <  20) 
{
drawScreen(A);
} 
else if (timeCount <  40) 
{
  drawScreen(AA);
} 
 else if (timeCount <  60) 
{
  drawScreen(AAA);
} 
  else if (timeCount <  80) 
{
 drawScreen(AAAA);
} 
else if (timeCount <  100) 
 {
  drawScreen(AAAAA);
} 
else if (timeCount <  120) 
{
  drawScreen(AAAAAA);
} 
else if (timeCount <  140) {
 drawScreen(AAAAAAA);
} 
else if (timeCount <  160) 
{
  drawScreen(AAAAAAAA);
 } 
else if (timeCount <  180) 
{
  drawScreen(AAAAAAAAA);
} 
 else if (timeCount <  200) 
{
  drawScreen(AAAAAAAAAA);
} 
  else if (timeCount <  220) 
{
 drawScreen(AAAAAAAAAAA);
} 
 else if (timeCount <  240) 
{
 drawScreen(AAAAAAAAAAAA);
} 
 else if (timeCount <  260) 
{
drawScreen(AAAAAAAAAAAAA);
} 
 else if (timeCount <  280) 
{
  drawScreen(AAAAAAAAAAAAAA);
} 
else if (timeCount <  300) 
{
 drawScreen(AAAAAAAAAAAAAAA);
} 

}
}

void showb()
{
  timeCount= 0;
  while(timeCount<320)
  {       
    timeCount += 1; 
    if(timeCount <  20) 
   {
   drawScreen(B);
   } 
  else if (timeCount <  40) 
  {
    drawScreen(BB);
  } 
else if (timeCount <  60) 
 {
   drawScreen(BBB);
 } 
 else if (timeCount <  80) 
{
 drawScreen(BBBB);
 } 
 else if (timeCount <  100) 
 {
   drawScreen(BBBBB);
 } 
 else if (timeCount <  120) 
{
  drawScreen(BBBBBB);
} 
 else if (timeCount <  140) {
  drawScreen(BBBBBBB);
} 
else if (timeCount <  160) 
{
  drawScreen(BBBBBBBB);
} 
else if (timeCount <  180) 
{
  drawScreen(BBBBBBBBB);
} 
else if (timeCount <  200) 
 {
   drawScreen(BBBBBBBBBB);
} 
 else if (timeCount <  220) 
{
  drawScreen(BBBBBBBBBBB);
} 
 else if (timeCount <  240) 
 {
  drawScreen(BBBBBBBBBBBB);
 } 
 else if (timeCount <  260) 
 {
drawScreen(BBBBBBBBBBBBB);
 } 
 else if (timeCount <  280) 
 {
  drawScreen(BBBBBBBBBBBBBB);
 } 
 else if (timeCount <  300) 
{
 drawScreen(BBBBBBBBBBBBBBB);
 } 

}
}
void showc()
{
 timeCount= 0;
 while(timeCount<320)
{       
timeCount += 1; 
if(timeCount <  20) 
{
 drawScreen(C);
} 
 else if (timeCount <  40) 
{
 drawScreen(CC);
} 
 else if (timeCount <  60) 
{
 drawScreen(CCC);
} 
 else if (timeCount <  80) 
{
 drawScreen(CCCC);
} 
else if (timeCount <  100) 
{
 drawScreen(CCCCC);
} 
else if (timeCount <  120) 
{
 drawScreen(CCCCCC);
} 
else if (timeCount <  140) {
 drawScreen(CCCCCCC);
} 
else if (timeCount <  160) 
{
 drawScreen(CCCCCCCC);
} 
else if (timeCount <  180) 
{
 drawScreen(CCCCCCCCC);
} 
else if (timeCount <  200) 
{
 drawScreen(CCCCCCCCCC);
} 
else if (timeCount <  220) 
{
 drawScreen(CCCCCCCCCCC);
} 
else if (timeCount <  240) 
{
 drawScreen(CCCCCCCCCCCC);
} 
else if (timeCount <  260) 
{
  drawScreen(CCCCCCCCCCCCC);
} 
else if (timeCount <  280) 
{
 drawScreen(CCCCCCCCCCCCCC);
} 
else if (timeCount <  300) 
{
 drawScreen(CCCCCCCCCCCCCCC);
} 

}
}

void loop() {
  
 // This could be rewritten to not use a delay, which would make it appear brighter
if (Serial.available() > 0){
   // Lê toda string recebida
   String recebido = leStringSerial();
   for (int i = 0; i < 10; i++){
  Serial.println(recebido[i]);
  delay(500);
   }
timeCount = 0;
   switch (recebido[0]){
case 'a': 
 showa();
break;

case 'b': showb(); break;
case 'c': showc(); break;
//case 'd': showd();
   }
switch (recebido[1]){
case 'a': showa(); break;
case 'b': showb(); break;
case 'c': showc(); break;
}  

switch (recebido[2]){
case 'a': showa(); break;
case 'b': showb(); break;
case 'c': showc(); break;
}

timeCount = 0;
      
  }
}

void  drawScreen(byte buffer2[])
{ 
  // Turn on each row in series
   for (byte i = 0; i < 8; i++)        // count next row
    {
       digitalWrite(rows[i], HIGH);    //initiate whole row
       for (byte a = 0; a < 8; a++)    // count next row
       {
         // if You set (~buffer2[i] >> a) then You will have positive
         digitalWrite(col[a], (buffer2[i] >> a) & 0x01); // initiate whole column
       

         delayMicroseconds(200);       // uncoment deley for diferent speed of display
         //delayMicroseconds(1000);
         //delay(10);
         //delay(100);
         
         digitalWrite(col[a], 1);      // reset whole column
       }
       digitalWrite(rows[i], LOW);     // reset whole row
       // otherwise last row will intersect with next row
   }
}
// 

 // this is siplest resemplation how for loop is working with each row.
//    digitalWrite(COL_1, (~b >> 0) & 0x01); // Get the 1st bit: 10000000
//    digitalWrite(COL_2, (~b >> 1) & 0x01); // Get the 2nd bit: 01000000
//    digitalWrite(COL_3, (~b >> 2) & 0x01); // Get the 3rd bit: 00100000
//    digitalWrite(COL_4, (~b >> 3) & 0x01); // Get the 4th bit: 00010000
//    digitalWrite(COL_5, (~b >> 4) & 0x01); // Get the 5th bit: 00001000
//    digitalWrite(COL_6, (~b >> 5) & 0x01); // Get the 6th bit: 00000100
//    digitalWrite(COL_7, (~b >> 6) & 0x01); // Get the 7th bit: 00000010
//    digitalWrite(COL_8, (~b >> 7) & 0x01); // Get the 8th bit: 00000001

---

Trabalho Vitor

Firmware

---

<< Página do curso

< Projeto 1 - Matriz de led com texto deslizante	AULA 9 - Projeto 1 - Protótipos dos Alunos - Apresentação	Projeto 2 - Alimentador automático de pets >