AULA 9 - Microcontroladores - Eng: mudanças entre as edições
Ir para navegação
Ir para pesquisar
imported>Fargoud |
imported>Fargoud |
||
| Linha 19: | Linha 19: | ||
O aluno Davi utilizou um módulo de matriz de leds 8x8 e programou todas as rotinas. | O aluno Davi utilizou um módulo de matriz de leds 8x8 e programou todas as rotinas. | ||
[[image: matrizled8x8Davi.png|center]] | |||
===Hardware/Eletrônica=== | ===Hardware/Eletrônica=== | ||
Edição das 15h36min de 19 de setembro de 2018
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 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 > |
|---|