Relógio da Internet com o ExPPOP 10 e LCD Display usando o cliente NTP e o código Arduino
A configuração de um relógio NTP ESP32 é relativamente direta, pois o ESP32 possui suporte interno para o NTP e há muitas bibliotecas disponíveis para ajudar na tela LCD. Uma vez configurado, o relógio NTP ESP32 pode ser usado para acompanhar o tempo com alta precisão, mesmo quando desconectado da Internet.
Agora vamos projetar um relógio baseado em NTP usando ESP32.
Componentes necessários
Para projetar um relógio baseado na Internet do NTP usando o ESP32 a seguir, são necessários componentes:
- Placa ESP32
- 16x2 I2C LCD Display
- Conectando fios
- Pão de pão
Introdução ao NTP (Network Time Protocol)
O Network Time Protocol (NTP) é um protocolo de rede para sincronização do relógio entre os sistemas de computador. É usado para garantir que os relógios em diferentes dispositivos estejam sincronizados entre si, mesmo que estejam em diferentes partes do mundo.
O NTP funciona usando uma hierarquia de servidores de tempo, com cada servidor sincronizando seu relógio com uma fonte de tempo mais precisa. Isso permite que os dispositivos sincronizem seus relógios com um alto nível de precisão, normalmente dentro de alguns milissegundos.
NTP é um protocolo importante para muitas aplicações, incluindo redes de computadores, transações financeiras e pesquisa científica. Também é usado para sincronizar o tempo exibido em relógios digitais e outros dispositivos.
Como funciona o NTP?
O Protocolo de Time de Rede (NTP) funciona enviando e recebendo registro de data e hora entre servidores e clientes, usando uma combinação do horário atual e o tempo necessário para que a mensagem seja enviada e recebida.
O servidor NTP mantém um relógio de referência de alta precisão e usa esse relógio para ajustar os relógios em outros dispositivos. O cliente NTP envia uma solicitação para o servidor e o servidor responde com a hora atual e outros dados, como o tempo de ida e volta da solicitação e a hora atual do servidor. O cliente usa essas informações para ajustar seu próprio relógio e manter um tempo preciso.
O cliente NTP ajusta seu relógio local com o servidor NTP online usando o atraso do link e o deslocamento local definido dentro do código Arduino.
Relógio da Internet com tela Esp32 e LCD usando o cliente NTP
Projetar um relógio baseado em servidor NTP em tempo real usando o ESP32 tem muitos benefícios. Como não depende do módulo RTC interno, podemos obter o tempo exato usando o servidor NTP. Para projetar este relógio primeiro, temos que instalar algumas bibliotecas necessárias no Arduino IDE.
Instalando as bibliotecas necessárias
Para fazer o Relógio da Internet do ESP32 usando o servidor NTP e exibir o tempo na tela LCD, precisamos instalar as seguintes bibliotecas:
- Baixe a biblioteca NTPClient
- Download da biblioteca do tempo
- Baixe a biblioteca I2C LCD
Clique no link para baixar a biblioteca NTPClient.
Para baixar a biblioteca de tempo, abra o link e clique Baixar zip.
Depois de baixar as duas bibliotecas, abra o IDE e vá para: Esboço> Incluir Biblioteca> Adicionar .Biblioteca Zip.
Instale as duas bibliotecas uma por uma. Agora, para exibir o tempo na tela LCD, abra o gerente da biblioteca e instale o LiquidCrystal I2C biblioteca por Frank.
Depois de instalar as bibliotecas necessárias agora, podemos integrar o ESP32 com uma tela LCD.
Ligando o LCD para o ESP32
É possível conectar uma tela LCD com um ESP32 através de seus pinos i2c. SDA O pino está no D21 e SCL/SCK está em D22. Conecte o ESP32 com o LCD, como mostrado na imagem abaixo:
A seguir estão as conexões:
| I2C LCD | Esp32 |
|---|---|
| VCC | Vin |
| Gnd | Gnd |
| SDA | D21 |
| SCL | D22 |
Obtendo o endereço I2C LCD
Depois de conectar o I2C LCD com ESP32, é importante verificar o endereço I2C. Caso se estiver usando mais de um dispositivo no mesmo barramento i2c, o ESP32 não poderá se comunicar com ambos.
Sempre use dispositivos com diferentes endereços I2C. Para obter o endereço I2C, usaremos o Arame biblioteca. Para um código Arduino mais detalhado, leia o artigo Obtenha o endereço I2C no ESP32 usando o Arduino IDE.
Aqui o LCD que estamos usando tem um endereço I2C 0x27.
Código para ESP32 Relógio da Internet
Abra o código IDE e upload para conectar -se a um servidor NTP. Depois que o ESP32 estiver conectado ao servidor NTP usando a conexão WiFi definida dentro do código, o Arduino serial Monitor, e o I2C LCD exibirá tempo real.
#incluir
#incluir
#incluir
#incluir
#incluir
int lcd_columns = 16; /*Defina o tamanho do LCD*/
int lcd_rows = 2;
LiquidCrystal_i2c lcd (0x27, lcd_columns, lcd_rows); /*0x27 Endereço I2C para LCD*/
const char *ssid = "ssid"; /*Substitua por sua rede SSID*/
const char *senha = "senha"; /*Substitua por senha de rede*/
Wifiudp ntpudp;
NTPClient Timeclient (NTPUDP, "Time.nist.Gov ", 18000, 60000);
char time [] = "Hora: 00: 00: 00";
Char date [] = "Data: 00/00/2000";
byte last_second, segundo_, minuto_, hour_, dia_, mês_;
int ano_;
Void Setup ()
Serial.começar (115200);
LCD.iniciar(); /*Inicialize a tela LCD*/
LCD.luz de fundo (); /*Na luz de fundo do LCD*/
LCD.setCursor (0, 0); /*Definir cursor*/
LCD.print ("time"); /*Tempo de impressão no LCD*/
LCD.setCursor (0, 1); /*Definir cursor LCD*/
LCD.data de impressão); /*Data de impressão*/
Wi-fi.BEGIN (SSID, senha); /*Comece o wifi*/
Serial.impressão ("conectando.");
enquanto (wifi.status() != Wl_connected)
atraso (500);
Serial.imprimir(".");
Serial.println ("conectado");
TIMECLIENT.começar();
atraso (1000);
LCD.claro(); /*Clear LCD Display*/
Void Loop ()
TIMECLIENT.atualizar();
não assinado long unix_epoch = timeclient.getEpochtime (); // Obtenha o horário da Epoch UNIX no servidor NTP
segundo_ = segundo (unix_epoch);
if (last_second != segundo_)
minuto_ = minuto (unix_epoch);
hora_ = hora (unix_epoch);
dia_ = dia (unix_epoch);
mês_ = mês (unix_epoch);
ano_ = ano (unix_epoch);
Tempo [12] = segundo_ % 10 + 48;
Tempo [11] = segundo_ / 10 + 48;
Tempo [9] = minuto_ % 10 + 48;
Tempo [8] = minuto_ / 10 + 48;
Tempo [6] = hora_ % 10 + 48;
Tempo [5] = hora_ / 10 + 48;
Data [5] = dia_ / 10 + 48;
Data [6] = dia_ % 10 + 48;
Data [8] = mês_ / 10 + 48;
Data [9] = mês_ % 10 + 48;
Data [13] = (ano_ / 10) % 10 + 48;
Data [14] = ano_ % 10 % 10 + 48;
Serial.println (tempo); /*Imprime o tempo no monitor serial*/
Serial.println (data); /*Data de impressão no monitor serial*/
LCD.setCursor (0, 0); /*Definir cursor LCD*/
LCD.impressão (hora); /*Exibir tempo no LCD*/
LCD.setCursor (0, 1); /*Definir cursor LCD*/
LCD.data de impressão); /*Data de exibição no LCD*/
last_second = segundo_;
Atraso (200);
Usando o código acima, podemos obter o tempo NTP do servidor. Para obter o tempo correto no LCD, você precisa fazer alterações de acordo com o seu fuso horário.
NTPClient Timeclient (NTPUDP, "Ásia.piscina.ntp.org ", 18000, 60000);
Atualmente, o país onde estou morando está 5 horas antes do tempo universal coordenado (hora da UTC). Então, eu tenho que converter 5 horas em segundos.
+5 horas = 5x60x60 = 18.000 segundos
Mude neste fuso horário de acordo com sua localização. Você pode usar o Google para verificar o GMT deslocamento para o seu país.
Altere adicionalmente o SSID de rede e a senha definida dentro do código.
O código iniciado ligando para as bibliotecas instaladas. I2C LCD, ESP32 WiFi, NTPClient e Time Library.
NtpClient.h A biblioteca conectará o ESP32 ao servidor NTP e Wifiudp.h enviará e receberá mensagens UDP.
Para se comunicar com o protocolo UDP do servidor de tempo NTP é usado. Para obter tempo do NTP Internet Server, o endereço do servidor NTP, o deslocamento do NTP e o intervalo NTP precisam ser definidos.
NTPClient Timeclient (NTPUDP, "Ásia.piscina.ntp.org ", 18000, 60000);
O NTP Server envia informações de tempo para ESP32. O tempo recebido está em Unix Timestamp (UNIX Epoch) Formato. A biblioteca do tempo converterá o tempo da época do Unix em minutos, horas e formato diurno.
Próximo endereço I2C (0x27) do LCD é definido. Além disso, o tamanho do LCD 16 × 2 também é configurado.
Em laço função TIMECLIENT.atualizar() A função terá tempo do servidor NTP e o armazenará dentro da variável de tempo.
Saída
No monitor serial, você verá a saída abaixo:
No LCD, exibe um relógio com data e hora atualizadas podem ser vistas.
Conclusão
Esp32 é uma placa IoT baseada em microcontrolador compacta. Este artigo abrange todas as etapas necessárias para projetar um relógio baseado em servidor NTP em tempo real. A saída é exibida na tela LCD usando o código Arduino. Ao definir o servidor NTP correto, qualquer um pode projetar um relógio com base em seu fuso horário usando o código ESP32 e Arduino.