Eletrônica digital – Display 7 segmentos com 74HC595 7



Em um post remoto vimos como sequenciar o acendimento de 8 LEDs com o driver 74HC595, através de um código bastante simples e prático que escrevi para acendimento sequencial. Dessa vez vamos por em prática esse controlador para exibir números em um display de 7 segmentos, de forma a utilizar apenas os pinos 8,9 e 10 do Arduino. Posteriormente veremos um exemplo para PIC e como multiplexar.

Na imagem acima (a referência da imagem está nesse post ), está bem clara a conexão. Vamos relembrar que o acendimento do primeiro LED se dá pelo segundo pino da direita, os demais sequencialmente a partir do pino 1 da esquerda até o pino 7, completando assim os 8 LEDs possíveis por controlador.

No pino 8 da esquerda e no pino 4 da direita estão os aterramentos. No pino 1 e 7 da direita liga-se os +5v. No 3, 5 e 6 da direita ligam-se os pinos 8,9 e 10, sendo SER, RCLK e SRCKL respectivamente:

 

O código que escrevi como exemplo foi esse:

 //Define os pinos de saida
int SER = 8;
int RCLK = 9;
int SRCLK = 10;
//array dos pinos, iniciando em LOW
int regis[] = {0,0,0,0,0,0,0,0};
//contador para fazer acender os LEDs em sequencia
int counter = 0;

//função para efetivar a modificação após mudança dos pinos
void changeValues(int val){
clear();
if (val <8){
regis[val] = 1;
}
digitalWrite(RCLK, LOW);
for(int i=7; i >= 0; i--){
digitalWrite(SRCLK, LOW);
int PIN = regis[i];
digitalWrite(SER, PIN);
digitalWrite(SRCLK, HIGH);
}
digitalWrite(RCLK, HIGH);
}

//Baixa todos os pinos do 74HC595
void clear(){
for(int i=7; i >= 0; i--){
regis[i] = LOW;
}
}


void setup(){
//configurando pinos como saida
pinMode(SER,OUTPUT);
pinMode(RCLK,OUTPUT);
pinMode(SRCLK,OUTPUT);
//Parametro 9 indica que deve zerar os pinos do 74HC595
changeValues(9);
}

void loop(){
changeValues(counter);
counter += 1;
//Apos aplicar a mudança, faz um delay
delay(100);
if (counter >7){counter =0;}
}

Para esse código o resultado é este:

Para controlarmos um display de 7 segmentos é bastante simples, baseando-se no código de exemplo acima. Repare que a variável regis (que é um array de inteiros) é a matriz de LEDs, onde cada posição do array representa um LED, portanto, basta acender o conjunto correspondente ao número a ser formado. Mas ainda como prova de conceito, vamos acender o LED anterior ou posterior ao posicional da variável val. Para isso na função changeValues adicione a seguinte linha abaixo de regis[val] = 1:


par = val < 7 ? val+1 : val-1; 

E na primeira linha adicione:


int par;

Troque o delay para 1000ms para que seja perceptível o acendimento em pares. Abaixo, o resultado dessa mudança:

Agora vamos ao próximo passo...

Display de 7 segmentos
Existem 2 tipos de display de 7 seguimentos; o de Anodo comum e o de Catodo comum. Nesse exemplo estou utilizando um display de Catodo comum. A imagem abaixo deixa claro sua conexão:

Se chama "catodo comum" porque o positivo entra em cada um dos segmentos e o aterramento é comum a todos eles, sendo o aterramento o pino central de ambos os lados do display.

O que precisamos fazer aqui é basicamente ordenar a sequencia de ligação dos LEDs de forma a corresponder à sequência do esquemático do display. Posteriormente, criaremos os arrays de inteiros cada qual correspondendo ao número que deve aparecer no display. Só um alerta: J A M A I S ligue o LED desse display sem resistor, porque vai queimar na hora, não é como um LED comum que suporta um tempo de carga direta.
Os resistores utilizados serão os mesmos dos LEDs exemplificados nos videos acima, o que o deixará um bocado luminoso.

No display que estamos utilizando tem um ponto no canto inferior direito. O primeiro pino da base, logo abaixo do ponto lhe é correspondente.

Pinos 2, 4 e 5 da base correspondem a C,D e E respectivamente. Os pinos 1, 2, 4 e 5 correspondem a G,F,A,B respectivamente. A má notícia é que só tenho um display catodo comum e adivinha? Queimei o segmento A acendendo o teste do lado errado do resistor, ou seja, minha recomendação acima: NÃO ligue +5v diretamente aos pinos do display senão já era.

Matrizes para números
A primeira coisa a fazer é sempre limprar os registros, de forma a apagar todos os seguimentos. Para isso, utilizei a função clear() do código de exemplo anterior. Mas a meneira mais limpa é utilizar o pino do 74HC595 que tem justamente essa funcionalidade. Vamos criar a matriz do número 1. Para tal é necessário acender o segmento B e C, ou pino 5 do lado superior e pino 5 do lado inferior. Como ligamos o driver na sequencia correta, basta ativar o pino 2 e 3 do driver:


int um[1,1,0,0,0,0,0,0];

Para o número 2, os segmentos A,B,G,E e D devem ser ligados. Considerando que queimei o segmento A, a exibição aqui já parecerá falha, mas a matriz deve ficar assim:


int dois[1,0,1,1,0,1,0,0];

E assim por diante. O código completo fica assim:


int um[]     = {0,1,1,0,0,0,0,0};
int dois[]   = {1,1,0,1,1,0,1,0};
int tres[]   = {1,1,1,1,0,0,1,0};
int quatro[] = {0,1,1,0,0,1,1,0};
int cinco[]  = {1,0,1,1,0,1,1,0};
int seis[]   = {1,0,1,1,1,1,1,0};
int sete[]   = {1,1,1,0,0,0,0,0};
int oito[]   = {1,1,1,1,1,1,1,0};
int nove[]   = {1,1,1,1,0,1,1,0};
int zero[]   = {1,1,1,1,1,1,0,0};

//array dos numeros
int *number[] = {zero,um,dois,tres,quatro,cinco,seis,sete,oito,nove};

//Define os pinos de saida
int SER   = 8;
int RCLK  = 9;
int SRCLK = 10;

int counter = 0;

void changeValues(int *val[]){
    for (int j=0;j<10;j++){
        for(int i=7; i >  -1; i--){
            //SRCLK deslocamento
            digitalWrite(SRCLK, LOW);
            //HIGH logo apos deslocar, setar o clock
            digitalWrite(RCLK, HIGH);
            int PIN = val[j][i];
            //pino a deslocar
            digitalWrite(SER, PIN);
            //HIGH para ativar
            digitalWrite(SRCLK, HIGH);
        }
        digitalWrite(RCLK, LOW);
        delay(1000);
    }
}

void setup(){
  //configurando pinos como saida
  pinMode(SER,OUTPUT);
  pinMode(RCLK,OUTPUT);
  pinMode(SRCLK,OUTPUT);
}

void loop(){
  changeValues(number);
  counter += 1;
  if (counter >7){counter =0;}
}

E a exibição dos números fica assim:

Para o próximo post vamos entender o que é multiplexação, vamos ver como multiplexar interligando 2 displays de 7 seguimentos e controle do brilho do display com utilização de PWM. Já no post seguinte, veremos como criar um display maior de baixo custo.

Até a próxima diversão!


7 thoughts on “Eletrônica digital – Display 7 segmentos com 74HC595

  1. Pingback: Eletrônica Digital – Display de 7 segmentos com 74HC595 « Djames Suhanko – Linux e Programação

  2. Pingback: Display 7 segmentos com 74HC595 e Arduino | Linux Ajuda

  3. Pingback: Construindo um Pinball – Parte I ← Do Bit Ao Byte

  4. Pingback: Construindo um Pinball – Parte IV – Matriz de LED 8×8 ← Do Bit Ao Byte

  5. Reply matheus out 17, 2013 1:55

    Boa Noite, já foi postado o tutorial explicando como fazer multiplexao??
    E construir os 7 segmentos mais barato???

    Obrigado
    m

  6. Reply Edmarcos nov 6, 2013 20:32

    Muito bom o seu tutorial, mas me tira uma dúvida, como eu faria pra acender os leds individualmente, ou seja envio um comando e acende led 1, depois outro comando acende led 2 e assim por diante ?

Leave a Reply