#9 Utilizando display de 7 segmentos com 4 dígitos no Arduino

Neste post você irá aprender utilizar um display de 7 segmentos com 4 dígitos no Arduino. O vídeo abaixo mostra como o display vai funcionar no final do experimento.

A imagem abaixo lista os componentes necessários para a realização deste experimento.

A imagem abaixo mostra como o display deve ser ligado na protoboard. É importante que os componentes sejam ligados no Arduino quando ele estiver desligado para não correr o risco de danificar a placa.

O display utilizado foi o 0,56" igual ao modelo mostrado abaixo

Após ligado o display conforme a imagem de prototipação é preciso programar. Ligue o Arduino no computador, abra a interface de desenvolvimento (IDE) e cole o código abaixo. As "//" no código significam comentário, ou seja, o que for escrito após as "//" na mesma linha a IDE do Arduino não considera como código. Após colocar o código, pressione

no menu superior e teste veja o semáforo funcionar.

int um=0;
int t=0;
int dois=0;
int tres=0;
int quatro=0;
int currentMillis = 0;
 
int bt = 0;
//Ponto
int dp = 5;

//Declaração dos Segmentos
int a = 2;
int b = 4;
int c = 10;
int d = 9;
int e = 8;
int f = 3;
int g = 6;

//Declaração dos digitos
int d1 = 11;
int d2 = 7;
int d3 = 12;
int d4 = 1;

//Ordem do pino
byte pinoOrdem[7] = {a, b, c, d, e, f, g};
byte digitoOrdem[4] = {d1, d2, d3, d4};
byte digitos[4][4] = {{0, 0, 0, 1},
                      {0, 0, 1, 0},
                      {0, 1, 0, 0},
                      {1, 0, 0, 0}};

byte sete_segmentos[10][7] = {{0,0,0,0,0,0,1}, // 0
                              {1,0,0,1,1,1,1}, // 1
                              {0,0,1,0,0,1,0}, // 2
                              {0,0,0,0,1,1,0}, // 3                              
                              {1,0,0,1,1,0,0}, // 4
                              {0,1,0,0,1,0,0}, // 5
                              {0,1,0,0,0,0,0}, // 6
                              {0,0,0,1,1,1,1}, // 7
                              {0,0,0,0,0,0,0}, // 8
                              {0,0,0,1,1,0,0}};// 9
                              
void ligaPino(byte digito, byte numero){
    int p = 0;
    byte seg;

    pDigit(digito);
    wDot(1);

    if(numero == 200){
        for(seg = 0; seg < 7; seg++){
            digitalWrite(pinoOrdem[p], 0);
            p++;
        }
          return;
    }    
    for(seg = 0; seg < 7; seg++){
        digitalWrite(pinoOrdem[p], sete_segmentos[numero][seg]);
        ++p;
    }
}    

//ATIVA ALGUM DIGITO DO COMPONENTE
void pDigit(int x){
    digitalWrite(d1, LOW);
    digitalWrite(d2, LOW);
    digitalWrite(d3, LOW);
    digitalWrite(d4, LOW);
    
    switch(x){ //HIGH no pino para acionar o acendimento do segmento
        case 1:
            digitalWrite(d1, HIGH);
            break;
        case 2:
            digitalWrite(d2, HIGH);
            break;
        case 3:
            digitalWrite(d3, HIGH);
            break;
        case 4:
            digitalWrite(d4, HIGH);
            break;
    }

}
void wDot(byte d){
    digitalWrite(dp, d);
}

void setup(){
  int i;
  for(i = 1; i <= 12;i++){
    pinMode(i, OUTPUT);
  }
  pinMode(A5, INPUT);
}

void loop(){
        bt = digitalRead(A5);
        if(bt == HIGH){
          um = 0;
          dois = 0;
          tres = 0;
          quatro = 0;
        }
    if(currentMillis >= 10000){
        currentMillis = 0;
        dois++;
        if(dois >= 6){
            dois = 0;
            tres++;
            if(tres >=10){
                tres = 0;
                quatro++;
                if(quatro >= 6){
                    um = 0;
                    dois = 0;
                    tres = 0;
                    quatro = 0;
                }
            } 
        }
    }
    um = (currentMillis) /1000;
    ligaPino(4, um);
    delay(5);
    
    ligaPino(3, dois);
    delay(5);
    
    ligaPino(2, tres);
    delay(5);
    
    ligaPino(1, quatro);
    delay(5);

    currentMillis = currentMillis + 20; // + 20 para compensar os 4 delays acima

}

A imagem abaixo mostra o que cada pino no display representa segundo o código.