Reloj de Internet con visualización de Esptop 10 y LCD usando el cliente NTP y el código Arduino
Configurar un reloj NTP ESP32 es relativamente sencillo, ya que el ESP32 tiene soporte incorporado para NTP y hay muchas bibliotecas disponibles para ayudar con la pantalla LCD. Una vez configurado, el reloj NTP ESP32 se puede usar para realizar un seguimiento del tiempo con alta precisión, incluso cuando se desconecta de Internet.
Ahora diseñaremos un reloj basado en NTP usando ESP32.
Se requieren componentes
Para diseñar un reloj basado en Internet NTP utilizando los siguientes componentes ESP32:
- Junta ESP32
- Pantalla LCD de 16x2 I2C
- Conectando cables
- Tablero de circuitos
Introducción a NTP (Protocolo de tiempo de red)
El Protocolo de tiempo de red (NTP) es un protocolo de red para la sincronización del reloj entre los sistemas informáticos. Se usa para garantizar que los relojes en diferentes dispositivos estén sincronizados entre sí, incluso si están en diferentes partes del mundo.
NTP funciona utilizando una jerarquía de servidores de tiempo, con cada servidor sincronizando su reloj con una fuente de tiempo más precisa. Esto permite que los dispositivos sincronizaran sus relojes con un alto nivel de precisión, generalmente en unos pocos milisegundos.
NTP es un protocolo importante para muchas aplicaciones, incluidas las redes informáticas, las transacciones financieras e investigación científica. También se usa para sincronizar el tiempo que se muestra en relojes digitales y otros dispositivos.
¿Cómo funciona NTP??
El Protocolo de tiempo de red (NTP) funciona enviando y recibiendo marcas de tiempo entre servidores y clientes, utilizando una combinación de la hora actual y el tiempo tardado para que se envíe y reciba el mensaje.
El servidor NTP mantiene un reloj de referencia de alta precisión y usa este reloj para ajustar los relojes en otros dispositivos. El cliente NTP envía una solicitud al servidor, y el servidor responde con la hora actual y otros datos, como el tiempo de ida y vuelta de la solicitud y la hora actual del servidor. El cliente luego usa esta información para ajustar su propio reloj y mantener un tiempo preciso.
El cliente NTP ajusta su reloj local con el servidor NTP en línea utilizando el retraso del enlace y el desplazamiento local definido dentro del código Arduino.
Reloj de Internet con pantalla ESP32 y LCD usando el cliente NTP
El diseño de un reloj basado en el servidor NTP en tiempo real con ESP32 tiene muchos beneficios. Ya que no depende del módulo RTC interno para que podamos obtener el tiempo exacto con el servidor NTP. Para diseñar este reloj primero tenemos que instalar algunas bibliotecas necesarias en Arduino IDE.
Instalación de las bibliotecas requeridas
Para hacer el reloj de Internet ESP32 usando el servidor NTP y mostrar la hora en la pantalla LCD, necesitamos instalar las siguientes bibliotecas:
- Descargar la biblioteca NTPClient
- Descargar la biblioteca de tiempo
- Descargar I2C LCD Library
Haga clic en el enlace para descargar la biblioteca NTPClient.
Para descargar la biblioteca de tiempo, abra el enlace y haga clic Descargar zip.
Después de descargar ambas bibliotecas abiertas IDE e ir a: Boceto> incluir biblioteca> agregar .Biblioteca.
Instalar ambas bibliotecas una por una. Ahora para mostrar el tiempo en la pantalla LCD, abra el Administrador de la biblioteca e instale el LiquidCrystal I2C biblioteca Franco.
Después de instalar las bibliotecas requeridas ahora, podemos integrar ESP32 con una pantalla LCD.
Cableado el LCD al ESP32
Es posible conectar una pantalla LCD con un ESP32 a través de sus pines I2C. SDA El pin está en D21 y SCL/SCK esta en d22. Conecte ESP32 con LCD como se muestra en la imagen a continuación:
Las siguientes son las conexiones:
| I2C LCD | ESP32 |
|---|---|
| VCC | Empuje |
| Gnd | Gnd |
| SDA | D21 |
| SCL | D22 |
Obtener la dirección LCD I2C
Después de conectar el I2C LCD con ESP32, es importante verificar la dirección I2C. En caso de que si uno usa más de un dispositivo en el mismo bus I2C, ESP32 no podrá comunicarse con ambos.
Use siempre dispositivos con diferentes direcciones I2C. Para obtener la dirección I2C, usaremos el Cable biblioteca. Para obtener un código Arduino más detallado, lea el artículo, Obtenga la dirección I2C en ESP32 usando Arduino IDE.
Aquí la pantalla LCD que estamos usando tiene una dirección I2C 0x27.
Código para el reloj de Internet ESP32
Abra el código IDE y cargue para conectarse a un servidor NTP. Una vez que ESP32 está conectado al servidor NTP utilizando la conexión WiFi definida dentro del código, Arduino Serial Monitor e I2C LCD mostrará tiempo real.
#incluir
#incluir
#incluir
#incluir
#incluir
int lcd_columns = 16; /*Defina el tamaño de LCD*/
int lcd_rows = 2;
LiquidCrystal_i2c LCD (0x27, LCD_COLUMNS, LCD_ROWS); /*0x27 I2C Dirección para LCD*/
const char *ssid = "ssid"; /*Reemplace con su red SSID*/
const char *contraseña = "contraseña"; /*Reemplazar con contraseña de red*/
Wifiudp ntpudp;
NTPClient TimeClient (NTPUDP, "Tiempo.nist.Gobierno ", 18000, 60000);
Char Time [] = "Tiempo: 00: 00: 00";
Fecha de char [] = "Fecha: 00/00/2000";
BYTE LIST_SECOND, Second_, Minute_, Hour_, Day_, Month_;
int año_;
setup () void
De serie.comenzar (115200);
lcd.en eso(); /*Inicializar la pantalla LCD*/
lcd.iluminar desde el fondo(); /*En la luz de fondo LCD*/
lcd.setCursor (0, 0); /*Establecer cursor*/
lcd.imprimir ("tiempo"); /*Tiempo de impresión en LCD*/
lcd.setCursor (0, 1); /*Establecer el cursor LCD*/
lcd.fecha de impresion); /*Fecha de impresion*/
Wifi.begin (SSID, contraseña); /*comienza wifi*/
De serie.Imprimir ("Conectando.");
Mientras (wifi.estado() != Wl_connected)
retraso (500);
De serie.imprimir(".");
De serie.println ("conectado");
Tim -oflient.comenzar();
retraso (1000);
lcd.claro(); /*Clear LCD Display*/
bucle void ()
Tim -oflient.actualizar();
Unsigned Long unix_epoch = timEclient.getepochtime (); // Obtener tiempo de una época de Unix desde el servidor NTP
segundo_ = segundo (unix_epoch);
if (last_second != Second_)
minuto_ = minuto (unix_epoch);
hora_ = hora (unix_epoch);
Day_ = Day (unix_epoch);
mes_ = mes (unix_epoch);
año_ = año (unix_epoch);
Tiempo [12] = Second_ % 10 + 48;
Tiempo [11] = Second_ / 10 + 48;
Tiempo [9] = minuto_ % 10 + 48;
Tiempo [8] = minuto_ / 10 + 48;
Tiempo [6] = hora_ % 10 + 48;
Tiempo [5] = hora_ / 10 + 48;
Fecha [5] = day_ / 10 + 48;
Fecha [6] = day_ % 10 + 48;
Fecha [8] = mes_ / 10 + 48;
Fecha [9] = mes_ % 10 + 48;
Fecha [13] = (año_ / 10) % 10 + 48;
Fecha [14] = año_ % 10 % 10 + 48;
De serie.println (tiempo); /*Imprime tiempo en el monitor de serie*/
De serie.println (fecha); /*Fecha de impresión en el monitor de serie*/
lcd.setCursor (0, 0); /*Establecer el cursor LCD*/
lcd.imprimir (tiempo); /*Mostrar tiempo en LCD*/
lcd.setCursor (0, 1); /*Establecer el cursor LCD*/
lcd.fecha de impresion); /*Fecha de visualización en LCD*/
Last_Second = Second_;
retraso (200);
Usando el código anterior, podemos obtener el tiempo NTP desde el servidor. Para obtener el tiempo correcto en LCD, debe hacer cambios de acuerdo con su zona horaria.
NTPClient TimeClient (NTPUDP ", Asia.piscina.NTP.org ", 18000, 60000);
Actualmente, el país donde vivo está 5 horas antes del tiempo universal coordinado (tiempo de UTC). Entonces, tengo que convertir de 5 horas a segundos.
+5 horas = 5x60x60 = 18,000 segundos
Cambie esta zona horaria de acuerdo con su ubicación. Puedes usar Google para verificar el GMT Compensación para su país.
Además, cambie el SSID y la contraseña de la red definidos dentro del código.
Código iniciado llamando a las bibliotecas instaladas. I2C LCD, ESP32 WiFi, NTPClient y Time Library.
Ntpclient.H La biblioteca conectará ESP32 con el servidor NTP y Wifiudp.H Enviará y recibirá mensajes UDP.
Para comunicarse con el protocolo UDP de NTP Time Server se utiliza. Para obtener el tiempo del servidor de Internet NTP, las variables de la dirección del servidor NTP, la compensación NTP y el intervalo NTP deben definirse.
NTPClient TimeClient (NTPUDP ", Asia.piscina.NTP.org ", 18000, 60000);
NTP Server envía información de tiempo a ESP32. El tiempo recibido es en Desastre Formato de marca de tiempo (Epoch UNIX). La biblioteca de tiempo convertirá el tiempo de la época de unix a minutos, horas y formato diario.
Siguiente dirección I2C (0x27) de la pantalla LCD se define. Además, el tamaño de la LCD 16 × 2 también está configurado.
En bucle función Tim -oflient.actualizar() La función obtendrá el tiempo del servidor NTP y lo almacenará dentro de la variable de tiempo.
Producción
En el monitor en serie, verá la siguiente salida:
En la pantalla LCD, visualice un reloj con fecha y hora actualizadas.
Conclusión
ESP32 es un tablero IoT basado en microcontrolador compacto. Este artículo cubre todos los pasos necesarios para diseñar un reloj basado en el servidor NTP en tiempo real. La salida se muestra en la pantalla LCD utilizando el código Arduino. Al establecer el servidor NTP correcto, cualquiera puede diseñar un reloj basado en su zona horaria utilizando el código ESP32 y Arduino.