- Componentes necessários
- Display de 4 dígitos e 7 segmentos
- 74HC595 Shift Register IC
- Módulo RTC DS3231
- Diagrama de circuito
- Programando Arduino UNO para Multiplexing Display de Sete Segmentos
Os relógios de parede digitais estão se tornando mais populares hoje em dia e são melhores do que o relógio analógico, pois fornece tempo preciso em horas, minutos e segundos e é fácil de ler os valores. Alguns relógios digitais também possuem muitas facilidades, como exibição de temperatura, umidade, configuração de vários alarmes, etc. A maioria dos relógios digitais usa display de sete segmentos.
Anteriormente, construímos muitos circuitos de relógios digitais usando displays de 7 segmentos ou LCD 16x2. Aqui você pode ver os designs de PCB completos de relógio digital baseado em AVR. Este tutorial é sobre como fazer um relógio digital multiplexando displays de quatro a 7 segmentos usando Arduino UNO e exibindo a hora no formato HH: MM.
Componentes necessários
- Display de 4 dígitos e 7 segmentos
- 74HC595 IC
- Módulo RTC DS3231
- Arduino UNO
- Tábua de pão
- Fios de conexão
Display de 4 dígitos e 7 segmentos
O display de 7 segmentos de 4 dígitos possui quatro displays de sete segmentos unidos ou podemos dizer multiplexados juntos. Eles são usados para exibir valores numéricos e também alguns alfabetos com decimais e dois pontos. O display pode ser usado em ambas as direções. Quatro dígitos são úteis para fazer relógios digitais ou como números de contagem de 0 a 9999. Abaixo está o diagrama interno para exibição de 7 segmentos de 4 dígitos.
Cada segmento possui um LED com controle individual de LED. Existem dois tipos de visores de sete segmentos, como ânodo comum e cátodo comum. A imagem acima mostra o display de ânodo comum de 7 segmentos.
Ânodo Comum
No ânodo comum, todos os terminais positivos (ânodos) de todos os 8 LEDs são conectados juntos, chamados de COM. E todos os terminais negativos são deixados sozinhos ou conectados aos pinos do microcontrolador. Usando o microcontrolador, se a lógica LOW for definida para iluminar o segmento de LED específico e definir a lógica Alta para desligar o LED.
Cátodo Comum
No cátodo comum, todos os terminais negativos (cátodo) de todos os 8 LEDs são conectados juntos, chamados de COM. E todos os terminais positivos são deixados sozinhos ou conectados aos pinos do microcontrolador. Ao usar o microcontrolador, defina a lógica HIGH para iluminar o LED e defina LOW para desligar o LED.
Saiba mais sobre monitores de 7 segmentos aqui e verifique como podem ser conectados a outros microcontroladores:
- Interface de exibição de 7 segmentos com Arduino
- Interface de exibição de 7 segmentos com Raspberry Pi
- Interface de exibição de sete segmentos com ARM7-LPC2148
- Interface de exibição de 7 segmentos com microcontrolador PIC
- Interface de exibição de 7 segmentos com microcontrolador 8051
74HC595 Shift Register IC
O IC 74HC595 também conhecido como 8-Bit Serial IN - Parallel OUT Shift Register. Este IC pode receber entrada de dados em série e pode controlar 8 pinos de saída em paralelo. Isso é útil para reduzir os pinos usados no microcontrolador. Você pode encontrar todos os projetos relacionados ao registrador de deslocamento 74HC595 aqui.
Trabalho de 74HC595 IC:
Este IC usa três pinos como Clock, Data & Latch com o microcontrolador para controlar os 8 pinos de saída do IC. O relógio é usado para fornecer pulsos contínuos do microcontrolador e o pino de dados é usado para enviar os dados, como a saída que precisa ser ligada ou desligada no respectivo relógio.
Pinagem:
|
Número do PIN |
Nome do Pin |
Descrição |
|
1,2,3,4,5,6,7 |
Pinos de saída (Q1 a Q7) |
O 74HC595 tem 8 pinos de saída, dos quais 7 são esses pinos. Eles podem ser controlados em série |
|
8 |
Terra |
Conectado ao solo do microcontrolador |
|
9 |
(Q7) Saída serial |
Este pino é usado para conectar mais de um 74HC595 em cascata |
|
10 |
(MR) Reinicialização mestre |
Redefine todas as saídas como baixas. Deve ser mantido alto para operação normal |
|
11 |
(SH_CP) Relógio |
Este é o pino do relógio para o qual o sinal do relógio deve ser fornecido pelo MCU / MPU |
|
12 |
(ST_CP) Trava |
O pino de trava é usado para atualizar os dados para os pinos de saída. É ativo alto |
|
13 |
(OE) Habilitar Saída |
A habilitação de saída é usada para desligar as saídas. Deve ser mantido baixo para operação normal |
|
14 |
(DS) Dados seriais |
Este é o pino para o qual os dados são enviados, com base no qual as 8 saídas são controladas |
|
15 |
(Q0) Saída |
O primeiro pino de saída. |
|
16 |
Vcc |
Este pino alimenta o IC, normalmente + 5V é usado. |
Módulo RTC DS3231
DS3231 é um módulo RTC. RTC significa Real Time Clock. Este módulo é usado para lembrar a hora e a data mesmo quando o circuito não está energizado. Ele tem uma bateria de backup CR2032 para operar o módulo na ausência de alimentação externa. Este módulo também inclui um sensor de temperatura. O módulo pode ser usado em projetos embarcados, como fazer relógio digital com indicador de temperatura, etc. Aqui estão alguns projetos úteis para usá-lo:
- Alimentador automático de animais de estimação usando Arduino
- Interface do Módulo RTC (DS3231) com Microcontrolador PIC: Relógio Digital
- Interface do módulo RTC (DS3231) com MSP430: Relógio Digital
- ESP32 Real Time Clock using DS3231 Module
- Relógio de parede digital em PCB usando microcontrolador AVR Atmega16 e DS3231 RTC
Pinagem do DS3231:
|
Nome do Pin |
Usar |
|
VCC |
Conectado ao positivo da fonte de alimentação |
|
GND |
Conectado ao solo |
|
SDA |
Pino de dados serial (I2C) |
|
SCL |
Pino de relógio serial (I2C) |
|
SQW |
Pino de saída de onda quadrada |
|
32K |
Saída do oscilador de 32K |
Características e especificações:
- RTC conta segundos, minutos, horas e ano
- Sensor digital de temperatura com precisão de ± 3ºC
- Registre-se para corte de envelhecimento
- Interface I2C 400Khz
- Baixo consumo de energia
- Bateria reserva CR2032 com vida de dois a três anos
- Tensão operacional: 2,3 a 5,5 V
Diagrama de circuito
Conexão de circuito entre DS3231 RTC e Arduino UNO:
|
DS3231 |
Arduino UNO |
|
VCC |
5V |
|
GND |
GND |
|
SDA |
A4 |
|
SCL |
A4 |
Conexões de circuito entre 74HC595 IC e Arduino Uno:
|
74HC595 IC |
Arduino UNO |
|
11-SH_CP (SRCLK) |
6 |
|
12-ST_CP (RCLK) |
5 |
|
14-DS (dados) |
4 |
|
13-OE (trava) |
GND |
|
8-GND |
GND |
|
10-MR (SRCLR) |
+ 5V |
|
16-VCC |
+ 5V |
Conexões de circuito entre IC 74HC595 e Sete Segmento de 4 dígitos e Arduino UNO:
|
4-DigitSevenSegment |
IC 74HC595 |
Arduino UNO |
|
UMA |
Q0 |
- |
|
B |
T1 |
- |
|
C |
2º trimestre |
- |
|
D |
3º T |
- |
|
E |
Q4 |
- |
|
F |
Q5 |
- |
|
G |
Q6 |
- |
|
D1 |
- |
10 |
|
D2 |
- |
11 |
|
D3 |
- |
12 |
|
D4 |
- |
9 |
Programando Arduino UNO para Multiplexing Display de Sete Segmentos
O código completo e o vídeo de trabalho estão anexados no final deste tutorial. Na seção de programação, será explicado como o tempo (hora e minuto) é retirado do módulo RTC no formato 24h e depois convertido para o respectivo formato para exibi-los no display de 7 segmentos de 4 dígitos.
Para fazer a interface do módulo DS3231 RTC com o Arduino UNO, o barramento I2C do Arduino UNO é usado. Uma biblioteca chamada
Neste conceito, hora e minuto são retirados primeiro do RTC e são combinados como 0930 (21:30) e, em seguida, os dígitos individuais são separados como mil, cem, dezenas, unidade e os dígitos individuais convertidos em formato binário como 0 em 63 (0111111). Este código binário é enviado para um registrador de deslocamento e, em seguida, do registrador de deslocamento para o segmento de sete, exibindo com sucesso o Dígito 0 no display de sete segmentos. Desta forma, os quatro dígitos são multiplexados e a hora e o minuto são exibidos.
Inicialmente, a biblioteca necessária é incluída, como a biblioteca DS3231 e a biblioteca Wire (biblioteca I2C).
#incluir
Os pinos são definidos para o controle de sete segmentos. Esses controles desempenharão um papel importante na multiplexação da tela.
#define latchPin 5 #define clockPin 6 #define dataPin 4 #define ponto 2
As variáveis são declaradas para armazenar o resultado convertido ou bruto obtido do RTC.
int h; // Variável declarada por hora int m; // Variável declarada por minuto int milhares; centenas de int; int dezenas; unidade interna; bool h24; bool PM;
Em seguida, o objeto para a classe DS3231 é declarado como RTC para simplificar o uso em outras linhas.
DS3231 RTC;
Como o módulo RTC faz interface com o Arduino usando comunicação I2C. Portanto, wire.begin () é usado para iniciar a comunicação I2C no endereço padrão do RTC, pois não há outros módulos I2C.
Wire.begin ();
O modo de pino é definido, se o GPIO se comportará como saída ou entrada.
pinMode (9, OUTPUT); pinMode (10, OUTPUT); pinMode (11, OUTPUT); pinMode (12, OUTPUT); pinMode (latchPin, OUTPUT); pinMode (clockPin, OUTPUT); pinMode (dataPin, OUTPUT); pinMode (ponto, OUTPUT);
O loop é executado infinitamente e leva o tempo em horas e minutos do módulo RTC DS3231. 'h24' indica a variável de formato de 24 horas.
int h = RTC.getHour (h24, PM); int m = RTC.getMinute ();
Em seguida, a hora e o minuto são combinados como um número (exemplo, se a hora for 10 e min for 60, o número será 10 * 100 = 1000 + 60 = 1060).
número int = h * 100 + m;
Os dígitos individuais do número são obtidos (exemplo 1060-1 é mil, 0 é hundered, 1 é o décimo e 0 é o último dígito). Para separar os dígitos, o operador módulo é usado. Por exemplo, em 1060 para obter 1, então 1060/1000 = 1,06% 10 = 1). Portanto, dígitos separados são armazenados em variáveis separadas.
milhares int = número / 1000% 10; centenas int = número / 100% 10; dezenas int = número / 10% 10; unidade interna = número% 10;
Depois disso, uma instrução switch case para cada dígito individual é definida para convertê-los no respectivo formato (formato binário) e enviá-los via registrador de deslocamento para exibição em 7 segmentos. Por exemplo (para 1 dígito é alterado para 06 (0000 0110)). Para que seja enviado via shift e 1 dígito seja exibido em 7 segmentos (0 para LOW, 1 para HIGH).
switch (t) { caso 0: unidade = 63; pausa; caso 1: unidade = 06; pausa; caso 2: unidade = 91; pausa; caso 3: unidade = 79; pausa; caso 4: unidade = 102; pausa; caso 5: unidade = 109; pausa; caso 6: unidade = 125; caso 7: unidade = 07; pausa; caso 8: unidade = 127; pausa; caso 9: unidade = 103; pausa; }
Em seguida, o dígito individual em formato binário é enviado através da função 'shiftout' com MSB primeiro e o pino do respectivo dígito é tornado HIGH e o pino de trava é tornado HIGH.
digitalWrite (9, LOW); digitalWrite (latchPin, LOW); shiftOut (dataPin, clockPin, MSBFIRST, milhares); digitalWrite (latchPin, HIGH); digitalWrite (9, ALTO); atraso (5);
Isso termina o código completo. A maior parte da explicação da função é fornecida na seção de comentários do código, ao lado da linha de código. A frequência do relógio decidirá a visualização do tempo e da qualidade da multiplexação, ou seja, se o relógio baixo for usado, a oscilação pode ser vista como se a velocidade do relógio fosse alta, então não haverá tal oscilação e um tempo estável poderá ser visto.
Observe que para acessar o módulo RTC, a tensão do barramento I2C deve ser mantida. Para dar alguma sugestão ou caso tenha alguma dúvida, por favor, comente abaixo.