AULA 9 - Microcontroladores - Eng
Ir para navegação
Ir para pesquisar
TECLADO COM BUZZER
CONTROLADOR DE AQUARIOS
PLOTTER CNC
FECHADURA DE PORTA COM RFID
SEGUIDOR DE SOL PARA MODULOS FOTOVOLTAICOS
BAFOMETRO
Trabalho Ana Paula
Protótipo
Hardware/Eletrônica
Firmware
Trabalho Davi
Protótipo
O aluno Davi utilizou um módulo de matriz de leds 8x8 e programou todas as rotinas.
Hardware/Eletrônica
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.
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
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 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
Protótipo
Hardware/Eletrônica
Firmware
| < 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 > |
|---|