Como utilizar display de 7 segmentos com 4 dígitos – cátodo comum com Arduino

O display de 7 segmentos com 4 dígitos é um módulo compacto que contém quatro visores individuais de 7 segmentos, ilustrado na Figura 1.

No display de 7 segmentos com 4 dígitos todos os pinos do mesmo segmento são conectados juntos, por exemplo: o segmento A do dígito 1 está conectado ao segmento A dos dígitos 2, 3 e 4, e cada dígito possui seu pino comum isolado, conforme Figura 2. Esta técnica de multiplexação minimiza o número de pinos usados.

Como pode ser observado nas Figura 2 e Figura 3, o display de 7 segmentos com 4 dígitos é composto por 12 pinos, sendo 7 pinos dos 7 segmentos (A, B, C, D, E, F, G), 4 pinos dos 4 dígitos (D1, D2, D3, D4) e 1 pino para o ponto decimal (DP).

Os displays de 7 segmento com 4 dígitos podem ser do tipo cátodo comum ou ânodo comum.

• Cátodo comum: Cada segmento do módulo é multiplexado, compartilhando os mesmos pontos de conexão do cátodo e cada um dos quatro dígitos tem seu próprio ponto de conexão ânodo. conforme ilustrado na Figura 4.

• Ânodo comum: Cada segmento do módulo é multiplexado, compartilhando os mesmos pontos de conexão do ânodo e cada um dos quatro dígitos tem seu próprio ponto de conexão cátodo. Conforme ilustrado na Figura 5.

A proposta deste projeto é usar display de 7 segmentos com 4 dígitos cátodo comum em conjunto com a placa Arduino para exibir números e pontos.

OBSERVAÇÃO: Antes de iniciar o projeto, verifique se o display de 7 segmentos com 4 dígitos é do tipo cátodo comum ou ânodo comum. Para fazer esta identificação, monte o circuito da Figura 6, em que o pino 3 do display será conectado ao 5V e o pino 6 ao GND.

Se o primeiro LED localizado no canto inferior direito do display de 7 segmentos com 4 dígitos for acionado, seu display é do tipo cátodo comum.

Caso o LED não tenha acionado, seu display de 7 segmentos com 4 dígitos é do tipo ânodo comum.

MATERIAIS NECESSÁRIOS

• 1 x Placa UNO SMD R3 Atmega328 compatível com Arduino UNO;
• 1 x Cabo USB;
• 1 x Protoboard;
• 1 x Display de 7 segmentos com 4 dígitos cátodo comum;
• 8 x Resistor de 200 ou 220 Ω;
• Fios de jumper macho-macho.

ESQUEMÁTICO DE LIGAÇÃO DOS COMPONENTES

Inicialmente, certifique-se que a sua placa Arduino esteja desligada. Monte o circuito da Figura 7 utilizando o display de 7 segmentos com 4 dígitos, os resistores e os jumpers.

Siga atentamente a Figura 7 e a Tabela 1 para montar o circuito na protoboard.

Pino display	Descrição	Porta da Placa UNO
1	Segmento E	Digital 7
2	Segmento D	Digital 6
3	Segmento DP	Digital 5
4	Segmento C	Digital 3
5	Segmento G	Digital 2
6	Dígito 1	Digital 4
7	Segmento B	Digital 13
8	Dígito 2	Digital 11
9	Dígito 3	Digital 12
10	Segmento F	Digital 9
11	Segmento A	Digital 8
12	Dígito D4	Digital 10

ELABORANDO O CÓDIGO

Com o circuito montado, vamos a programação do Sketch. Neste projeto, vamos exibir os números de 0 a 9 e pontos no display de 7 segmentos com 4 dígitos cátodo comum. Vamos entender a lógica de programação para o projeto a partir dos seguintes passos:

1. Declarar as variáveis:
Iniciaremos a programação declarando as variáveis correspondentes ao controle dos segmentos do display. Conforme o esquemático elétrico, atribuiremos a porta 8 a variável a; a porta 13 a variável b; a porta 3 a variável c; a porta 6 a variável d; a porta 7 a variável e; a porta 9 a variável f; a porta 2 a variável g e a porta 5 a variável dp.

Em seguida, devemos declarar a variável correspondente aos dígitos do display, em que atribuímos a porta 4 a variável d1, a porta 11 a variável d2, a porta 12 a variável d3 e a porta 10 a variável d4.

2. Criar as funções dos números a serem exibidos no display 7 segmentos:
Na programação deste Sketch precisamos criar funções que serão responsáveis por acionar os segmentos do display para que ele exiba números de 0 a 9 e os pontos.

Desta forma, vamos criar uma função para cada número e uma para os pontos. Cada função conterá a combinação de segmentos que devem ser acionados (colocados em nível alto) para que exiba o dígito desejado. Para formar um dígito é necessário acender os segmentos correspondentes. Na Tabela 2 estão listados os segmentos que devem ser acionados para formação dos números de 0 a 9 e os pontos.

Número	Sequência
0	a, b, c, d, e, f
1	b, c
2	a, b, d, e, g
3	a, b, c, d, g
4	b, c, f, g
5	a, c, d, f, g
6	a, c, d, e, f, g
7	a, b, c
8	a, b, c, d, e, f, g
9	a, b, c, f, g
•	dp

3. Configurar as portas de saída:
Na função setup, configuraremos todos as variáveis como saída, ou seja, as variáveis a, b, c, d, e, f, g, dp, d1, d2, d3 e d4 devem ser configuradas como OUTPUT.

4. Acionar os dígitos dos displays e chamar as funções:
Iniciamos a função loop definindo nível baixo nos pinos correspondentes aos 4 dígitos do display. Nos displays cátodo comum o acionamento dos dígitos é feito em nível lógico baixo (LOW).

Em seguida, chamamos as funções responsáveis pelo acionamento dos segmentos dos displays para formar os números e pontos.

Ao final, o código do projeto proposto ficará da seguinte maneira:

/*
  =  DISPLAY 7 SEGMENTOS 4 DÍGITOS CÁTODO COMUM  =
  ================================================
  == BLOG DA ROBOTICA - www.blogdarobotica.com ===
  ================================================
  Autor: Carol Correia Viana
  E-mail: contato@blogdarobotica.com
  Facebook: facebook.com/blogdarobotica
  Instagram:@blogdarobotica
  YouTube: youtube.com/user/blogdarobotica
  ================================================
  == CASA DA ROBOTICA - www.casadarobotica.com ===
  ================================================
  Facebook: facebook.com/casadaroboticaoficial
  Instagram:@casadarobotica
  ================================================
*/

//Declarando todos os pinos dos segmentos e digito do Display
int a = 8; //Pino 11 do display
int b = 13; //Pino 7 do display
int c = 3; //Pino 4 do display
int d = 6; //Pino 2 do display
int e = 7; //Pino 1 do display
int f = 9; //Pino 10 do display
int g = 2; //Pino 5 do display
int dp = 5; //Pino 3 do display

int d1 = 4; //Pino 6 do display
int d2 = 11; //Pino 8 do display
int d3 = 12; //Pino 9 do display
int d4 = 10; //Pino 12 do display

//Funções de exibição dos números no display de 7 segmentos
void zero() { //Função para escrever o nº zero
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, LOW);
  digitalWrite(dp, LOW);
  delay(1000);
}
void um() { //Função para escrever o nº um
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(dp, LOW);
  delay(1000);
}

void dois() { //Função para escrever o nº dois
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, LOW);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
  delay(1000);
}

void tres() { //Função para escrever o nº três
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
  delay(1000);
}

void quatro() { //Função para escrever o nº quatro
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
  delay(1000);
}

void cinco() { //Função para escrever o nº cinco
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
  delay(1000);
}

void seis() { //Função para escrever o nº seis
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
  delay(1000);
}

void sete() { //Função para escrever o nº sete
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(dp, LOW);
  delay(1000);
}

void oito() { //Função para escrever o nº oito
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
  delay(1000);
}

void nove() { //Função para escrever o nº nove
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
  delay(1000);
}

void pontos() { //Função para escrever ....
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(dp, HIGH);
  delay(1000);
}

void setup() {
  //Configura todos os pinos como saída (OUTPUT)
  pinMode(d1, OUTPUT); //Dígitos
  pinMode(d2, OUTPUT);
  pinMode(d3, OUTPUT);
  pinMode(d4, OUTPUT);

  pinMode(a, OUTPUT); //Segmentos
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
  pinMode(dp, OUTPUT);
}

void loop() {
  //Display cátodo comum - acionamento dos dígitos em nível lógico baixo
  digitalWrite(d1, LOW);
  digitalWrite(d2, LOW);
  digitalWrite(d3, LOW);
  digitalWrite(d4, LOW);

  //Chamando as funções para impressão de cada número
  zero();
  um();
  dois();
  tres();
  quatro();
  cinco();
  seis();
  sete();
  oito();
  nove();
  pontos();
}

Espero ter ajudado,

Obrigada a todos e em caso de dúvidas deixe seu comentário abaixo!

Att. Carol Correia Viana