Interface ESP32 com 74HC595 e display de 7 segmentos de 4 dígitos

Tempo de leitura: 11 minutes

Este guia se concentra no display de 4 dígitos e 7 segmentos e sua interface com o ESP32 usando o registrador de deslocamento 74HC595. Usando o registrador de deslocamento 74HC595 para acionar displays de 7 segmentos com nossas placas ESP, podemos salvar pinos GPIO do ESP32. Primeiro, mostraremos algumas descrições de displays de 7 segmentos e 74HC595 IC e, em seguida, forneceremos um código para programar suas placas ESP32 na IDE do Arduino. Usando o código, você poderá exibir números de 0 a 9999 em seu display de sete segmentos de 4 dígitos facilmente.

Antes de ir para o nosso display HS420361K-32 de 4 dígitos e 7 segmentos, vamos apresentar brevemente os displays de 7 segmentos.

7 Introdução à Exibição do Segmento

Um dispositivo de 7 segmentos consiste em 7 diodos emissores de luz. Esses diodos emissores de luz são organizados e embalados dentro de um único display com um padrão específico em mente. Se este padrão for controlado de uma forma específica ligando e desligando os LEDs, um dispositivo de sete segmentos exibirá um número único. Há também um oitavo LED extra em um display de sete segmentos que é usado para exibir pontos. Esse ponto às vezes é usado como ponto decimal quando queremos exibir um valor fracionário.

A figura abaixo mostra um display de 7 segmentos e sua pinagem. A sequência de oito LEDs do lado esquerdo mostra a conexão interna e uma imagem do lado direito mostra como esses LEDs estão dispostos para formar um display de sete segmentos. Pin3 e 8 são pinos comuns. Esses pinos são usados para fornecer 5 volts ou terra em monitores do tipo ânodo comum e cátodo comum, respectivamente.

Tipos de Exibições de Sete Segmentos

Existem dois tipos de displays de sete segmentos, como ânodo comum e cátodo comum.

Exibição de ânodo comum

No display de anodo comum, todos os terminais de anodos de oito diodos emissores de luz são comuns e se conectam com uma fonte de alimentação de 5 volts. Em condições normais, aplicamos a lógica alta do nosso microcontrolador a cada segmento. Portanto, cada segmento permanece desligado ou não brilha. Da mesma forma, quando queremos acender um LED específico de um dispositivo de sete segmentos, fornecemos sinal lógico baixo. Como o LED acende apenas quando houver um sinal lógico alto no lado do ânodo e um sinal lógico baixo no lado do cátodo, como é o caso do display do tipo ânodo comum.

Exibição de cátodo comum

Na exibição de segmento de cátodo comum, todos os cátodos de oito diodos emissores de luz são comuns e se conectam ao solo. Para desligar qualquer segmento de 7 segmentos, aplicamos a lógica baixa do nosso microcontrolador a este segmento. Da mesma forma, quando queremos ligar um LED específico de um dispositivo de sete segmentos, fornecemos sinal lógico alto do pino de saída digital do microcontrolador. Como o LED acende apenas quando houver um sinal lógico alto no lado do ânodo e um sinal lógico baixo no lado do cátodo, como é o caso do display do tipo cátodo comum.

HS420561K-32 Exibição de 4 dígitos e 7 segmentos

Um display de 4 dígitos e 7 segmentos que usaremos neste guia é mostrado abaixo:

Ele vem com 12 pinos, 6 de cada lado. A figura abaixo mostra sua configuração de pinos.

A tabela abaixo mostra o número do pino associado a cada segmento.

Número do Pino Segmento
1 E
2 D
3 decimal
4 C
5 G
6 D4
7 B
8 D3
9 D2
10 F
11 A
12 D1

Este é um display de cátodo comum. Cada pino de segmento por exemplo A, B, C, D, E, F, G e decimal é responsável por controlar os mesmos segmentos para todos os dígitos. Os pinos de dígito são separados D1, D2, D3 e D4 e são conectados ao seu respectivo digit1-digit4 respectivamente. Como é comum a configuração do cátodo, enviar um sinal LOW para o pino do dígito o liga. Portanto, para controlar cada dígito, teremos que primeiro ligar/desligar o pino de dígito D1-D4 de cada um dos dígitos. Isso será feito fornecendo um sinal ALTO ao pino do dígito. Em seguida, teremos que ativar os segmentos individuais para exibir um número.

74HC595 Registro de Turno

O 74HC595 é um IC registrador de deslocamento de entrada serial e saída paralela.

Podemos usar registradores de deslocamento como 74HC595 para salvar os pinos dos microcontroladores. Com o uso de um registrador de deslocamento IC 74HC595, podemos reduzir o número de pinos para no máximo quatro para controlar o dispositivo de sete segmentos de 4 dígitos.

O registrador de deslocamento controla várias saídas simultaneamente. Utilizando o protocolo serial in parallel out, ele obtém dados serialmente da placa ESP32 e os transmite através dos pinos paralelos.

Pino Out

A figura abaixo mostra o pino fora do IC.

É composto por 16 pinos. Os oito pinos (Q0-Q7) são os pinos de saída do registrador de deslocamento. Esses pinos são conectados a qualquer periférico onde queremos exibir os dados do registro de armazenamento em nosso caso o display de 4 dígitos e 7 segmentos.

Funcionalidade dos pinos

Esta tabela lista o funcionamento de cada pino.

Numero do Pino Nome do Pino Descrição
1-7, 9, 15 Q0-Q7 a ~Q7 Registro de saída de 8 bits e ~Q7 usado para cascata
14 DS Este é o pino de entrada de dados seriais, onde os dados de entrada são fornecidos.
13 ~OE O pino de habilitação de saída está ativo baixo. Quando este pino está baixo, os dados no registro de armazenamento aparecem na saída. Ao aplicar sinais altos, as saídas são desligadas forçando-as para o estado de alta impedância. No entanto, a saída serial não é afetada. Para operações normais, é mantido baixo.
10 ~MR É uma entrada assíncrona de reset mestre ativo baixo que é usada para resetar apenas o registrador de deslocamento. A trava de 8 bits não é afetada por esta entrada. A aplicação de um sinal baixo no pino 10 redefinirá apenas a parte do registrador de deslocamento.
11 SH_CP Este é o pino de entrada do clock de um registrador de deslocamento 74hc595. Um dado é deslocado do pino de entrada serial para o registrador de deslocamento de 8 bits em cada transição positiva do sinal de clock aplicado neste pino.
12 ST_CP Este é o pino de trava. É pino de entrada de clock alto ativo de um registro de armazenamento. Uma transição positiva de um sinal neste pino é usada para atualizar os dados para os pinos de saída.
8 GND Este é o pino terra e está conectado ao terra do circuito.
16 VCC Uma fonte de alimentação positiva é fornecida neste pino.

Interface ESP32 com 74HC595 e display de 4 dígitos de 7 segmentos

Os seguintes componentes são necessários:

  • Placa de desenvolvimento ESP32
  • 74HC595 IC
  • Display de 4 dígitos de 7 segmentos
  • Quatro resistores de 220 ohms
  • Fios de conexão
  • Protoboard

Para conectar corretamente todos os dispositivos, siga as conexões com muito cuidado. Siga o esquema esquemático abaixo:

ESP32 com display 74HC595 e HS420361K-32 de 4 dígitos e 7 segmentos
ESP32 com display 74HC595 e HS420361K-32 de 4 dígitos e 7 segmentos

Registro de Turno com ESP32

Corretamente, explicaremos como conectado entre o registrador de deslocamento e a placa ESP32. Comece conectando o pino 16 e o pino 10 do 74HC595 com o pino de 3,3 V do ESP32. Em seguida, conecte o pino 8 e o pino 13 do IC com uma placa ES32. Então vamos conectar os 3 pinos, pin11, pin12 e pin14 com GPIO18, GPIO5 e GPIO23 respectivamente. Estes são os pinos de relógio, trava e dados.

74HC595 ESP32
pino 16 (VCC) e pino 10 (~MR) 3.3V
pino 8 (GND) e pino 13 (~OE) GND
pino 11 (SH_CP) GPIO18
pino 12 (ST_CP) GPIO5
pino 14 (DS) GPIO23

Shift Register com display de 4 dígitos e 7 segmentos

A seguir, explicaremos as conexões entre o registrador de deslocamento e o display de 4 dígitos e 7 segmentos. Siga as conexões mostradas na tabela abaixo para conectar os pinos de saída de dados paralelos do registrador de deslocamento Q0-Q7 com os segmentos do display.

74HC595 Display de 4 dígitos de 7 segmentos
Q0 (pino 15) A
Q5 (pino 5) F
Q1 (pino 1) B
Q4 (pino 4) E
Q3 (pino 3) D
Q7 (pino 7) decimal
Q2 (pino 2) C
Q6 (pino 6) G

Display de 4 dígitos de 7 segmentos com ESP32

Por fim, explicaremos as conexões entre o ESP32 e o display de 4 dígitos e 7 segmentos. Use quatro pinos de saída digital apropriados do ESP32 para conectar com cada um dos pinos de dígito D1-D4 através de resistores limitadores de corrente de 220 ohms cada. Usamos os pinos especificados na tabela abaixo.

Display de 4 dígitos e 7 segmentos ESP32
D1 GPIO22
D2 GPIO21
D3 GPIO19
D4 GPIO4

Configurando o Arduino IDE

Vamos programar nossa placa ESP32 usando o Arduino IDE. Antes de prosseguirmos, você deve certificar-se de ter a versão mais recente do Arduino IDE instalada em seu sistema. Além disso, você também deve instalar um complemento ESP32 no Arduino IDE. Caso seu IDE não tenha o plugin instalado, você pode acessar o link abaixo:

Instalando a biblioteca ESP32 no Arduino IDE e fazendo upload do código

Para programar nossa placa ESP32 com o registrador de deslocamento e o display de 4 dígitos e 7 segmentos, precisaremos da biblioteca Timer de JChristensen no link a seguir.

Seu arquivo zip será baixado para o seu computador imediatamente. Após a conclusão do download, extraia o arquivo .zip para a pasta da biblioteca do Arduino. Certifique-se de renomear o arquivo extraído como ‘Timer’. Você também pode ir para Sketch > Include Library > Add .zip Library dentro do IDE para adicionar a biblioteca também.

Após a instalação da biblioteca, reinicie seu IDE.

 

Sketch do Arduino: Números de exibição de 7 segmentos de 4 dígitos ESP32

Abra seu Arduino IDE e vá em File > New para abrir um novo arquivo. Copie o código abaixo nesse arquivo.

Este sketch permitirá que o usuário digite qualquer número de 0 a 9999, que será exibido no display de 4 dígitos e 7 segmentos.

#include "Timer.h" 
Timer timer; 

long number = 0; 
int num1 = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
int timer_event = 0;

int D1 = 22;
int D2 = 21;
int D3 = 19;
int D4 = 4;

int latchPin = 5;
int clockPin = 18;
int dataPin = 23;

int count = 0;
int numbers[4] ;
int cathodePins[] = {22, 21, 19, 4};

byte table[10] {B11111100, B01100000, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110};

void setup() {
  Serial.begin(115200); 
  pinMode(D4, OUTPUT);
  pinMode(D3, OUTPUT);
  pinMode(D2, OUTPUT);
  pinMode(D1, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  digitalWrite(D4, HIGH);
  digitalWrite(D3, HIGH);
  digitalWrite(D2, HIGH);
  digitalWrite(D1, HIGH);
  Serial.println("Enter a number between 0 and 9999");
}

void loop() {
  timer.update(); 
  if (Serial.available()) { 
    timer.stop(timer_event); 
    screenOff(); 
    String s = Serial.readString(); 
    number = (long)s.toInt(); 
    if (number > 9999) { 
      Serial.println("Enter a number between 0 and 9999");
      } else {
      separate(number);
      timer_event = timer.every(1, Display); 
    }
  }
}

void separate(long num) { 
  num1 = num / 1000;
  numbers[0] = num1;
  int num1_remove = num - (num1 * 1000);
  num2 = num1_remove / 100;
  numbers[1] = num2;
  int num2_remove = num1_remove - (num2 * 100);
  num3 = num2_remove / 10;
  numbers[2] = num3;
  num4 = num2_remove - (num3 * 10);
  numbers[3] = num4;
}

void Display() {
  screenOff(); 
  digitalWrite(latchPin, LOW); 
  shiftOut(dataPin, clockPin,LSBFIRST, table[numbers[count]]); 
  digitalWrite(cathodePins[count], LOW); 
  digitalWrite(latchPin, HIGH); 
  count++; 
  if (count == 4) { 
    count = 0;
  }
}

void screenOff() { 
  digitalWrite(D4, HIGH);
  digitalWrite(D3, HIGH);
  digitalWrite(D2, HIGH);
  digitalWrite(D1, HIGH);
}

Como o Código Funciona?

Começaremos incluindo a biblioteca Timer.h que instalamos anteriormente. Em seguida, criaremos um objeto dessa biblioteca chamado ‘timer’.

#include "Timer.h" 
Timer timer;

Em seguida, definiremos os pinos GPIO que conectamos com cada pino D1-D4 da tela.

int D1 = 22;
int D2 = 21;
int D3 = 19;
int D4 = 4;

Além disso, também definiremos o pino de trava, o pino de clock e o pino de dados que conectamos com a placa ESP32.

int latchPin = 5;
int clockPin = 18;
int dataPin = 23;

Em seguida, criaremos um array inteiro que possuirá os pinos GPIO que conectamos com D1, D2, D3 e D4 do display de 4 dígitos e 7 segmentos, respectivamente.

int cathodePins[] = {22, 21, 19, 4};

O seguinte define os sinais lógicos que precisamos fornecer aos segmentos de LED para exibir um número de dígito específico em um display de sete segmentos.

byte table[10] {B11111100, B01100000, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110};

setup()

Dentro da função setup(), abriremos uma conexão serial a uma taxa de transmissão de 115200.

Serial.begin(115200);

Usando a função pinMode() vamos configurar os pinos D1-D4 assim como o clock, latch e pino de dados como pinos de saída.

pinMode(D4, OUTPUT);
pinMode(D3, OUTPUT);
pinMode(D2, OUTPUT);
pinMode(D1, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);

Em seguida, usando a função digitalWrite(), definiremos todos os pinos de dígitos para HIGH. Isso desligará a tela.

digitalWrite(D4, HIGH);
digitalWrite(D3, HIGH);
digitalWrite(D2, HIGH);
digitalWrite(D1, HIGH);

loop()

Dentro da função loop(), iniciaremos o cronômetro e adquiriremos se algum dado estiver disponível serialmente. Ele é primeiro salvo como uma string e depois convertido em um inteiro. Em seguida, configuraremos uma condição de que, se o número inserido for um número inválido, o que significa que é maior que 9999, o monitor serial exibirá “Digite um número entre 0 e 9999”. Caso contrário, a função separada() definida pelo usuário será chamada. Esta função irá separar o número em 4 dígitos. Além disso, também chamaremos a função screenOff() definida pelo usuário no loop(). Isso garantirá que a tela esteja desligada inicialmente.

Depois de separar o número faremos a multiplexação usando a função every(). Esta função é fornecida pela classe timer. Ele chama a função definida pelo usuário Display() após cada 1 ms.

void loop() {
  timer.update(); 
  if (Serial.available()) { 
    timer.stop(timer_event); 
    screenOff(); 
    String s = Serial.readString(); 
    number = (long)s.toInt(); 
    if (number > 9999) { 
      Serial.println("Enter a number between 0 and 9999");
      } else {
      separate(number);
      timer_event = timer.every(1, Display); 
    }
  }
}

separate()

A função separate() irá separar o número em 4 dígitos.

void separate(long num) { 
  num1 = num / 1000;
  numbers[0] = num1;
  int num1_remove = num - (num1 * 1000);
  num2 = num1_remove / 100;
  numbers[1] = num2;
  int num2_remove = num1_remove - (num2 * 100);
  num3 = num2_remove / 10;
  numbers[2] = num3;
  num4 = num2_remove - (num3 * 10);
  numbers[3] = num4;
}

Display()

A função Display() primeiro desativa a exibição chamando a função screenOff(). Em seguida, usando digitalWrite(), ele define o pino de trava como LOW. Em seguida, a função shiftOut() é chamada. Esta função desloca os dados em série, bem como a entrada do relógio simultaneamente, usando o operador bit a bit.

void Display() {
  screenOff(); 
  digitalWrite(latchPin, LOW); 
  shiftOut(dataPin, clockPin,LSBFIRST, table[numbers[count]]); 
  digitalWrite(cathodePins[count], LOW); 
  digitalWrite(latchPin, HIGH); 
  count++; 
  if (count == 4) { 
    count = 0;
  }
}

screenOff()

A função screenOff() garante que a tela esteja desligada definindo todos os pinos de dígitos D1-D4 como altos.

void screenOff() { 
  digitalWrite(D4, HIGH);
  digitalWrite(D3, HIGH);
  digitalWrite(D2, HIGH);
  digitalWrite(D1, HIGH);
}

 

Demonstração

Escolha a placa e a porta COM corretas antes de enviar seu código para a placa ESP32. Vá para Ferramentas > Placa e selecione Módulo de desenvolvimento ESP32.

Em seguida, vá para Ferramentas > Porta e selecione a porta apropriada através da qual sua placa está conectada.

Agora clique no botão de upload para carregar o código para o ESP32.

Agora abra seu monitor serial e defina a taxa de transmissão para 115200. Depois disso, pressione o botão de habilitar no ESP32:

Em seguida, digite um número entre 0-9999. Digitamos ‘1234.’ Em seguida, pressione enter.

Ao Rodar o teste, foi feito no Esp32 (genérico) e a porta foi COM5, mais a explicação de acima foi no Frazininho Wifi (Nacional) (ESP32), pois o genérico do teste, foi emprestado.

Imediatamente o display de 4 dígitos e 7 segmentos exibirá o número.

Visits: 25 Visits: 1191251