Como fazer um relógio digital usando o módulo RTC e Arduino Uno
O que é módulo RTC
Este é o módulo de relógio em tempo real que salva os dados de tempo e data e também os exibe na tela de exibição conectada. Este módulo mantém a hora e a data atualizadas e possui um oscilador de cristal que gera um sinal em uma frequência constante. Além disso, o módulo RTC possui pinos dedicados do sensor de temperatura no lado de trás e há um alfinete especial que lê a saída do sensor.
O módulo também vem com uma bateria de íons de lítio de 3V que mantém o módulo funcionando por algum tempo se o suprimento principal estiver desconectado.
Existem 7 pinos do módulo no total, mas no lado oposto, ele tem os mesmos 5 pinos para que você possa soldar os cabeçalhos em qualquer um dos dois lados se houver bateria colocada na parte de trás do módulo e você não quero usar o pino sq do módulo RTC. A tabela abaixo mostra os pinos do módulo RTC:
| Pinos | Descrição |
|---|---|
| 1- (sq) | PIN para gerar a onda quadrada |
| 2- (DS) | PIN que lê a saída do sensor de temperatura (ds18b20) se instalado no RTC |
| 2- (SCL) | Pino do relógio para o Arduino |
| 4- (SDA) | Pin de dados para o Arduino |
| 5- (VCC) | PIN para fornecer a tensão ao módulo |
| 6- (GND) | Pin para aterrar o módulo |
| 7- (morcego) | PIN para conectar a bateria externa como backup |
Fazendo um relógio digital usando RTC com Arduino Uno
Para projetar o relógio em tempo real, você exigirá os seguintes componentes:
- Arduino Uno
- Fios de jumper
- Módulo de relógio em tempo real (DS 1307)
- LCD
- Potenciômetro
- Pão de pão
O esquema do circuito para o relógio digital usando o módulo RTC é dado abaixo . Aqui no esquema, usamos o chip integrado DS (1307), que é quase semelhante ao módulo DS3231.
Conjunto de hardware do relógio digital usando RTC
Também implementamos o circuito de relógio digital no hardware de tal maneira que primeiro colocamos todos os componentes na placa de ensaio. Em seguida, usamos os fios de conexão para a interface dos componentes com o Arduino. Publicamos uma imagem do conjunto de hardware do circuito em que os fios azuis são os pinos de dados do LCD conectados a Arduino. O fio amarelo está conectado com um potenciômetro para ajuste de contraste. Além disso, os fios cinza são o relógio e os pinos de dados do módulo RTC conectados com Arduino.
Instalando a biblioteca do RTC
Para interface o módulo RTC com Arduino First, temos que baixar a biblioteca do módulo RTC. Primeiro, você deve abrir o gerente da biblioteca do Arduino IDE e depois disso, escreva a palavra -chave rtclib Na barra de pesquisa do gerente da biblioteca. Em seguida, você tem que encontrar o Rtclib por adfruit e depois clique no ícone de instalação no azul para instalar a biblioteca.
Quando clicamos no botão "Instalar", uma nova caixa de diálogo aparece para confirmação, então temos que clicar no ícone "instalar all".
Código Arduino para relógio digital usando RTC
O código para a criação de um relógio em tempo real usando Arduino é:
#include "rtclib.H "// Biblioteca de Definição para o módulo RTC
#include // Definindo Biblioteca para o LCD
Liquidcrystal lcd (12, 11, 5, 4, 3, 2); // atribuindo pinos Arduino para o LCD
Rtc_ds3231 rtc; // declarando o módulo RTC
void updatertc () // função para atualizar o RTC pela primeira vez
LCD.setCursor (0, 0); // definindo o local para os dados a serem exibidos
LCD.print ("atualização ..."); // exibindo os dados
// Peça ao usuário para inserir uma nova data e hora
const char txt [6] [15] = "ano", "mês", "dia",
"hora", "minutos", "segundos";
String str = ""; // criando uma string
long rtc_array [6]; // Definindo uma variável para armazenar os dados de entrada
enquanto (serial.disponível())
Serial.ler(); // lendo a entrada serial
para (int i = 0; i < 6; i++) // loop for taking 6 inputs form the user
Serial.print ("atual"); // exibindo os dados na série
Serial.imprimir (txt [i]);
Serial.imprimir(": ");
enquanto (!Serial.disponível())
// verificando se houver entrada do usuário
str = serial.readString (); // lendo a sequência de entrada
Rtc_array [i] = str.toint (); // convertendo a entrada do usuário em número e salvando -o em uma matriz
Serial.println (rtc_array [i]); // imprimindo a entrada do usuário na série
// Atualizando o RTC pela entrada do usuário
rtc.Ajust (DATETIME (RTC_ARRAY [0], RTC_ARRAY [1], RTC_ARRAY [2], RTC_ARRAY [3], RTC_ARRAY [4], RTC_ARRAY [5]));
Serial.println ("hora e data são atualizadas");
void DisplayUpDate () // Função para atualizar a exibição do LCD
// criando e matriz para converter o dígito em palavras que começam de 0 a 6
Const Char Dayinwords [7] [4] = "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat";
// convertendo meses de dígitos em palavras a partir de 1 a 12
Const Char MonthinInwords [13] [4] = "", "Jan", "Febb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec";
// lendo hora e data e salvando -os em variáveis
DateTime RTCTime = RTC.agora();
int sec = rtctime.segundo (); // segundos
int mins = rtctime.minuto (); // minutos
int hrs = rtctime.dozehour (); // horas
int dia = rtctime.diaftheweek (); // dia na palavra
int dd = rtctime.dia (); // dia em número
int mth = rtctime.mês (); // mês
int yr = rtctime.ano (); // ano
LCD.setCursor (0, 0);/ *Definindo o local para exibir a data e o dia da semana em palavras */
// exibindo a data em formato dd-mm-yyyy e dias de semana
if (dd < 10) lcd.print("0");
LCD.impressão (dd);
LCD.imprimir("-");
LCD.print (MonthInwords [MTH]);
LCD.imprimir("-");
LCD.impressão (ano);
LCD.imprimir(" ");
LCD.impressão (DayInwords [dia]);
LCD.setCursor (0, 1);/ *Definindo o local para exibir o tempo */
// exibindo o tempo no LCD
if (hrs < 10) lcd.print("0");
LCD.impressão (hrs);
LCD.imprimir(':');
If (Mins < 10) lcd.print("0");
LCD.impressão (mins);
LCD.imprimir(':');
If (Sec < 10) lcd.print("0");
LCD.impressão (seg);
if (rtctime.ISPM ()) LCD.print ("pm"); // exibindo AM/PM
else LCD.print ("am");
configuração void ()
Serial.começar (9600); // inicializando a comunicação serial
LCD.começar (16,2); // inicializando o LCD
rtc.começar(); // inicializando o módulo RTC
Void Loop ()
DisplayUpDate (); // chamando a função para atualizar o LCD
se (serial.disponível ()) // verificando se houver alguma entrada do usuário
Char Entrada = serial.leia (); // lendo a entrada do usuário
if (input == 'r') updatingrtc (); // se r é a entrada dada chamada a função de atualização para RTC
O código Arduino para fazer um relógio é compilado de tal maneira que primeiro definimos a biblioteca para o módulo RTC. Depois disso, definimos a biblioteca para o LCD e atribuímos os pinos do Arduino ao LCD e declaramos que, para usar as funções do RTC, usaremos a palavra -chave RTC.
Criamos duas funções, uma para atualizar o módulo RTC quando conectado pela primeira vez e a outra função para atualizar o LCD.
No UpdatingRTC Função Primeiro, declaramos um personagem para a data e hora da semana e criamos uma string vazia na qual toda a entrada do usuário será armazenada. Como existem 6 entradas necessárias do usuário para atualizar a hora e a data, usamos um loop para obter a entrada do usuário usando o monitor serial do Arduino IDE.
Em seguida, usamos o rtc.ajustar() função para salvar a data e hora atuais no módulo RTC.
Chegando ao DisplayUpdate () Função No início, convertemos o número de entrada para os dias da semana e o mês do ano em entrada de caracteres e depois definimos o formato para a data que é dd-mm-yyyy.
Em seguida, exibimos a data e a hora no LCD usando o LCD.imprimir() função.
Na função de configuração, depois de inicializar a comunicação serial, os módulos RTC e LCD são inicializados usando a função de início.
Da mesma forma, chegando à função de loop, o primeiro DisplayUpdate () Função é chamada que exibe a data e hora salvas atuais no módulo RTC. Para atualizar a data e hora que usamos e se condicionar quando o O caractere r é inserido como uma entrada serial Em seguida, ligue para a função UpdatingRTC e atualize a data e a hora do módulo.
Lembre-se de que o módulo RTC economiza a hora e a data, dada a primeira vez e continua atualizando essa data e hora, mesmo que o suprimento seja desligado porque possui uma bateria embutida que mantém o módulo funcionando. Portanto, a entrada e hora de entrada é dada apenas pela primeira vez e mantém o registro do tempo até que seja alterado manualmente.
Implementação de hardware para relógio digital usando RTC com Arduino UNO
Para atualizar a hora e a data, precisamos inserir o personagem "R" no monitor serial pressionando Ctrl+Enter e o código Arduino exigirá os dados para a data e hora atuais. Publicamos a imagem abaixo para que você possa ser uma imagem clara das entradas necessárias:
Depois de inserir todos os dados, o programa informará que o módulo RTC é atualizado. Ao atualizar a hora e a data, o LCD exibirá que o RTC está sendo atualizado:
Depois de atualizar a data e a hora, ele será exibido no LCD:
Conclusão
O Arduino UNO Board é uma forma avançada de um microcontrolador que facilitou a interface dos dispositivos com microcontroladores. Usando Arduino Uno, podemos construir diferentes variedades de projetos. Neste artigo, projetamos um relógio em tempo real usando o módulo RTC e o procedimento é explicado brevemente com a ajuda do Código e Simulação Arduino.