Armazenando dados pela Serial

Esse programa mostra como tratar informações vindas da serial, armazenando-as em variáveis do tipo char. A partir disso podemos tratar cada informação individualmente, executando assim uma função especifica para cada uma delas.

Ele começa lendo a serial, porem só  armazena os dados se o primeiro digito recebido for igual a ' abre chave ' ( { ), dai ele armazena os próximos sete caracteres. Se o sétimo carácter for igual a ' fecha chave ' ( } ), ele fecha a leitura da porta serial. Depois ele mostra os valores armazenados.

Como exemplo de tratamento dessas informações, programei sete leds para acender de acordo com o carácter que esta nas variáveis ' digx '.

ex: {000000}
{001100}
{100001}
{010010}
{101010}
{010101}
{111111}

// Declara variaveis globais
char data [7];
byte byte_received;
byte cont1 = 1;
char dig0,dig1,dig2,dig3,dig4,dig5,dig6,dig7;
int flag;
int cont;
void setup(){
  Serial.begin(9600);
  pinMode(2,OUTPUT);
  pinMode(3,OUTPUT);
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
}

void loop(){
  flag=1;//    Ativa a leitura Serial
  while(Serial.available() > 0 && flag == 1){
    byte_received = Serial.read();
    if(byte_received == '{'){
      cont=0;
    }
    if(cont <=8){
      data[cont] = byte_received;
      cont=cont++;
    }
    // Aqui o programa armazena cada informacao q vem da serial
    // em uma varivel diferente.
    dig0 = data[0];
    dig1 = data[1];
    dig2 = data[2];
    dig3 = data[3];
    dig4 = data[4];
    dig5 = data[5];
    dig6 = data[6];
    dig7 = data[7];
    }
    if(dig7 == '}'){
      flag=0;
    }
    // O programa so ira armazenar os dados se o primeiro caracter
    // recebido for igual a abre chave { ,
    //e a ultima for igual a fecha chave } .
 
    // Aqui ele mostra os dados enviados. A apartir daqui eles
    // podem ser processados de acordo com o programa que vc ira
    // criar.
    if(dig0=='{' && dig7 =='}'){
      Serial.print(dig0);
      Serial.print(dig1);
      Serial.print(dig2);
      Serial.print(dig3);
      Serial.print(dig4);
      Serial.print(dig5);
      Serial.print(dig6);
      Serial.println(dig7);
    }
    if(dig1 == '1'){
      digitalWrite(2,HIGH);
    }
    if(dig1 == '0'){
      digitalWrite(2,LOW);
    }
        if(dig2 == '1'){
      digitalWrite(3,HIGH);
    }
    if(dig2 == '0'){
      digitalWrite(3,LOW);
    }
        if(dig3 == '1'){
      digitalWrite(4,HIGH);
    }
    if(dig3 == '0'){
      digitalWrite(4,LOW);
    }
        if(dig4 == '1'){
      digitalWrite(5,HIGH);
    }
    if(dig4 == '0'){
      digitalWrite(5,LOW);
    }
        if(dig5 == '1'){
      digitalWrite(6,HIGH);
    }
    if(dig5 == '0'){
      digitalWrite(6,LOW);
    }
        if(dig6 == '1'){
      digitalWrite(7,HIGH);
    }
    if(dig6 == '0'){
      digitalWrite(7,LOW);
    }
}

2 Displays de 7 Segmentos com Arduino

Um jeito facil de acender displays de 7 segmentos no arduino e atraves da funcao sevenSegWrite. O exemplo que irei postar foi feito para acender 2 displays.

#include <EEPROM.h>
// Declaracao das variaveis
int ledA = 2;                // Segmento A
int ledB = 3;                // Segmento B
int ledC = 4;                // Segmento C
int ledD = 5;                // Segmento D
int ledE = 6;                // Segmento E
int ledF = 7;                // Segmento F
int ledG = 8;                // Segmento G
int dsp1 = 9;                // Habilita Display 1
int dsp2 = 10;               // Habilita Display 2
int digD = 0;
int digU = 0;

// Declaracao da funcao sevenSegDigits
// Essa funcao serve para displays de ANODO COMUM, para utilizar com CATODO COMUM, substitua
//todos os 0 (ZEROS) por 1(UNS).
byte seven_seg_digits[10][7] ={ { 0,0,0,0,0,0,1 },  // = 0 - E D C B A F G
                                 { 1,1,0,0,1,1,1 },  // = 1
                                 { 0,0,1,0,0,1,0 },  // = 2
                                 { 1,0,0,0,0,1,0 },  // = 3
                                 { 1,1,0,0,1,0,0 },  // = 4
                                 { 1,0,0,1,0,0,0 },  // = 5
                                 { 0,0,0,1,1,0,0 },  // = 6
                                 { 1,1,0,0,0,1,1 },  // = 7
                                 { 0,0,0,0,0,0,0 },  // = 8
                                 { 1,1,0,0,0,0,0 }   // = 9
                                };
void setup(){
  pinMode(ledA, OUTPUT);      // Configura pinos Digital como saída Segmento Display
   pinMode(ledB, OUTPUT);      //
   pinMode(ledC, OUTPUT);      //
   pinMode(ledD, OUTPUT);      //
   pinMode(ledE, OUTPUT);      //
   pinMode(ledF, OUTPUT);      //
   pinMode(ledG, OUTPUT);      //
   pinMode(dsp1, OUTPUT);      //
   pinMode(dsp2, OUTPUT);      //
   pinMode(A0,INPUT);
   digU = EEPROM.read(0);
   digD = EEPROM.read(1);
}
// Declara Void SevenSegWrite
void sevenSegWrite(byte digit){
  byte pin = 2;
  for(byte segCount=0 ; segCount < 7;++segCount){
    digitalWrite(pin,seven_seg_digits[digit][segCount]);
    ++pin;
  }
}
//Ate esse ponto, todo o programa e "padrao", sendo necessarias todas as declaracoes feitas
//com mudancas apenas nos pinos que voce ira utilizar

//No loop e onde acendemos os displays, o programa abaixo le o valor de um botao e incrementa
//o valor de unidade ate q ele seja igual a 9, apos isso ele zera o valor da variavel que
//armazena a unidade(digU) e incrementa a variavel da dezena (digD), se os dois valores  forem
//iguais a 9 (FAZENDO ASSIM 99) ele zera os valores e recomeca a contagem.
// Tambem fiz uso da bibliteca EEPROM para armazenar os valores (digU e digD)mesmo quando
//o circuito for desligado.
void loop(){
  if(digitalRead(A0) == HIGH){
    digU = digU + 1;
    if(digU > 9){
      digU = 0;
      digD = digD + 1;
    }
  }
  if(digD ==9 and digU == 9 ){
    digU =0;
    digD =0;
  }
  EEPROM.write(0,digU);
  EEPROM.write(1,digD);
  for(int i = 0; i<20;i++){
    digitalWrite(dsp1,HIGH);
    digitalWrite(dsp2,LOW);
    sevenSegWrite(digD);
    delay(5);
    digitalWrite(dsp1,LOW);
    digitalWrite(dsp2,HIGH);
    sevenSegWrite(digU);
    delay(5);
  }
}

Em breve irei publicar uma versao que acende um valor desejado vindo da serial.