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

 30 de junho de 2022  Carol Correia Viana  0 comentários 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.

Figura 1 – Display de 7 segmentos com 4 dígitos.

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.

Figura 2 – Multiplexação dos pinos do display de 7 segmentos com 4 dígitos.

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).

Figura 3 – Pinos do display de 7 segmentos com 4 dígitos.

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.

Figura 4 – Display de 7 segmentos para cátodo

 Â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.

Figura 5 – Display de 7 segmentos Ânodo

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.
 Figura 6 –
Teste do display de sete segmentos com 4 dígitos – 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.

Figura 7 – Circuito para Projeto exibir números e pontos no display de 7 segmentos com 4 dígitos – cátodo
comum.
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
Tabela 1 –
Pinos para Projeto exibir números e pontos no display de 7 segmentos com 4 dígitos –
cátodo comum.
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
Tabela 2 – Número e sequência de segmentos.
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();
}