¿Te molesta tener que ajustar todos los relojes al horario de verano dos veces al año? ¡Si es así, este artículo es para ti! Te mostraré cómo construir un reloj digital que se ajusta automáticamente. Además, tendrás un reloj que siempre es preciso.
Al sincronizar el reloj por WiFi con un proveedor de hora en internet, podemos asegurarnos de que nuestro reloj siempre muestre la hora correcta, sin importar los cambios de horario de verano o si nos movemos entre diferentes zonas horarias. Además, aprenderemos a analizar cadenas JSON y datetime, y a mostrar la hora en una pantalla LCD.
Voy a usar un ESP32-C3 SuperMini para este proyecto, pero cualquier ESP32, ESP8266 o un Arduino con WiFi shield también funcionará.
¡Vamos a empezar!
Componentes necesarios
Aquí tienes las piezas necesarias para el proyecto. En lugar de la placa de desarrollo ESP32-C3 Mini que aparece abajo, utilicé una placa muy similar llamada ESP32-C3 SuperMini de AliExpress. La mía solo tenía un LED incorporado de un solo color, mientras que la placa de abajo tiene un LED RGB. Pero aparte de eso, deberían ser casi idénticas y ambas deberían funcionar.
ESP32-C3 Mini
Cable USB C
LCD 16×2
Set de cables Dupont
Breadboard
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Horario de verano
El horario de verano (DST) es una práctica que consiste en adelantar el reloj una hora durante los meses de verano para aprovechar más la luz natural por las tardes. Este ajuste se hace para ahorrar energía y aprovechar mejor la luz del día. Sin embargo, no todos los países o regiones aplican el horario de verano, y las fechas de inicio y fin varían.
La mayoría de los países cambian la hora a la 1am o 2am y adelantan una hora. Pero hay casos especiales, como la isla Lord Howe en Australia, que adelanta solo 30 minutos, Cuba cambia la hora a medianoche y algunos países lo hacen a la 1am UTC en vez de la hora local. Para ver un resumen completo, consulta el artículo de Wikipedia: Daylight saving time by country.
Para asegurarnos de que nuestro reloj digital se ajuste automáticamente al horario de verano, necesitamos implementar un mecanismo que tenga en cuenta las reglas de DST de la zona horaria específica. Sin embargo, la variedad de reglas entre países hace que sea bastante complejo implementar estos ajustes por nuestra cuenta. En su lugar, confiaremos en un proveedor de hora en internet que se encargue de todo esto por nosotros.
Al sincronizar nuestro reloj con un proveedor de hora en internet, podemos obtener la hora actual junto con datos adicionales, como la zona horaria y si el horario de verano está activo. Esta información normalmente se proporciona en un JSON format, que debemos analizar para extraer los datos relevantes.
En la siguiente sección, veremos algunos proveedores de hora en internet, cómo conectarnos a ellos y cuál es su formato JSON.
Proveedor de hora en internet
En esta sección hablaremos brevemente de tres proveedores de hora en internet, cómo usar sus APIs y qué información contienen en el JSON que devuelven. También te contaré un poco sobre el Network Time Protocol (NTP), que es una buena alternativa.
WorldTimeAPI
WorldTimeAPI es un servicio web sencillo que devuelve la hora actual en texto plano o JSON. Puedes usar esta web para obtener la hora de una zona horaria concreta o según la dirección IP de tu ordenador. Usaremos esta última opción. Es más fácil y así nuestro reloj se ajustará automáticamente no solo al horario de verano, sino también al cambiar de zona horaria.
Probar WorldTimeAPI es muy fácil. Solo haz clic en este enlace: http://worldtimeapi.org/api/ip o escríbelo en la barra de búsqueda de tu navegador. Ten en cuenta que no tienes que indicar tu dirección IP explícitamente. El servicio web la detecta automáticamente según el origen de la consulta. Lo que verás en tu navegador será una salida similar a la siguiente (he añadido algo de formato para que se lea mejor y he ocultado mi IP):
{
"abbreviation": "AEDT",
"client_ip": "122.150.000.000",
"datetime": "2023-11-16T12:09:46.409360+11:00",
"day_of_week": 4,
"day_of_year": 320,
"dst": true,
"dst_from": "2023-09-30T16:00:00+00:00",
"dst_offset": 3600,
"dst_until": "2024-04-06T16:00:00+00:00",
"raw_offset": 36000,
"timezone": "Australia/Melbourne",
"unixtime": 1700096986,
"utc_datetime": "2023-11-16T01:09:46.409360+00:00",
"utc_offset": "+11:00",
"week_number": 46
}
Esta salida está en formato JSON. Contiene más información además de la hora actual. Pero nos interesa especialmente el campo datetime, que nos da la hora local actual. En este ejemplo es "2023-11-16T12:09:46.409360+11:00".
Cada vez que visites este enlace, obtendrás la hora actualizada. ¡Solo asegúrate de no consultarlo demasiado seguido, o podrías ser bloqueado!
WorldTimeAPI es el proveedor de hora en internet que usaremos para nuestro reloj. Pero también te daré dos alternativas que devuelven información ligeramente diferente, que podría ser más adecuada para tu caso.
timezonedb
Timezonedb ofrece varias APIs que puedes usar para obtener información de zonas horarias. Pero también tiene un servicio que devuelve la hora actual. Sin embargo, tienes que registrarte para obtener un API_KEY que te permita usar su servicio. Hay un plan gratuito y, una vez tengas tu API_KEY puedes usar el siguiente enlace para recibir la información de la hora en formato JSON:
http://api.timezonedb.com/v2/get-time-zone?key=API_KEY&format=json&by=zone&zone=Australia/Melbourne
Por desgracia, tienes que indicar una zona horaria. Necesitas el plan premium de pago para consultar por dirección IP.
{
"status": "OK",
"message": "",
"countryCode": "AU",
"countryName": "Australia",
"regionName": "",
"cityName": "",
"zoneName": "Australia\/Melbourne",
"abbreviation": "AEDT",
"gmtOffset": 39600,
"dst": "1",
"zoneStart": 1696089600,
"zoneEnd": 1712419199,
"nextAbbreviation": "AEST",
"timestamp": 1700145739,
"formatted": "2023-11-16 14:42:19"
}
Sin embargo, la ventaja de este servicio es que devuelve una cadena de hora ya formateada y fácil de usar. Mira el campo formatted arriba.
ipgeolocation
Como tercera opción, tenemos ipgeolocation. También tendrás que registrarte para obtener un API_KEY. Pero el plan gratuito para desarrolladores es muy generoso, con 1.000 peticiones diarias y 30.000 mensuales, más que suficiente. Aquí tienes el enlace para obtener la hora según tu dirección IP: https://api.ipgeolocation.io/timezone?apiKey=API_KEY. Obviamente, tendrás que poner tu propio API_KEY ahí.
La información que devuelve es muy completa y no solo incluye la hora, sino también la geolocalización del solicitante. Como puedes ver, actualmente vivo en Melbourne, Australia.
{
"geo": {
"country_code2": "AU",
"country_code3": "AUS",
"country_name": "Australia",
"country_name_official": "Commonwealth of Australia",
"state_prov": "Victoria",
"state_code": "AU-VIC",
"district": "",
"city": "Melbourne",
"zipcode": "3004",
"latitude": "-37.8",
"longitude": "144.9"
},
"timezone": "Australia/Melbourne",
"timezone_offset": 10,
"timezone_offset_with_dst": 11,
"date": "2023-11-16",
"date_time": "2023-11-16 14:57:36",
"date_time_txt": "Thursday, November 16, 2023 14:57:36",
"date_time_wti": "Thu, 16 Nov 2023 14:57:36 +1100",
"date_time_ymd": "2023-11-16T14:57:36+1100",
"date_time_unix": 1700107056.275,
"time_24": "14:57:36",
"time_12": "02:57:36 PM",
"week": 46,
"month": 11,
"year": 2023,
"year_abbr": "23",
"is_dst": true,
"dst_savings": 1
}
ipgeolocation es mi proveedor de hora preferido por la información de fecha y hora tan bien formateada que devuelve (ver los campos date_time, date_time_txt y date_time_wti) y los datos adicionales.
Sin embargo, para mantener las cosas lo más simples posible, en nuestro ejemplo de reloj usaré WorldTimeAPI, ya que no necesitas registrarte para usar su servicio.
Network Time Protocol
Por último, una palabra sobre el Network Time Protocol (NTP): «El Network Time Protocol (NTP) es un networking protocol para clock synchronization entre sistemas informáticos a través de packet-switched, redes de datos de latency variable.» (fuente: Wikipedia).
Está diseñado específicamente para sincronizar relojes con precisión, pero es bastante complejo y difícil de usar. Échale un vistazo al TimeNTP library y al example code.
Sin embargo, también existe SNTP (Simple Network Time Protocol), que es una versión simplificada de NTP. Aunque es menos preciso que NTP, SNTP sigue proporcionando la hora con una precisión de hasta 100 milisegundos. Es mucho más fácil de usar y, si quieres saber más, consulta nuestro How to synchronize ESP32 clock with SNTP server tutorial
En la siguiente sección, te muestro cómo conectar una pantalla LCD a un ESP32, para que podamos mostrar la hora y la fecha de forma clara.
Conexión de los componentes
Necesitamos una pantalla para mostrar la hora de nuestro reloj. Cualquier pantalla serviría, pero para simplificar usaremos una pantalla LCD 16×2 conectada por I2C. Para más información sobre pantallas LCD, consulta nuestros tutoriales sobre How to use a 16×2 character LCD with Arduino y Character I2C LCD with Arduino Tutorial (8 Examples).
Conectar la pantalla LCD al ESP32 es muy sencillo. Primero, conecta 5V a VCC y G a Ground. Luego conecta SDA al pin 8 (cable amarillo) y SCL al pin 9 (cable naranja) del ESP32.
Asegúrate de conectar SDA y SCL correctamente. Si usas otra placa, quizá quieras cambiar a los pines que soportan la interfaz I2C en tu placa. Busca los pines marcados como SDA y SCL en el pinout. Aquí tienes el pinout del ESP32-C3 Supermini que uso en este proyecto:
Aunque los pines GPIO8 y GPIO9 deberían ser los nativos para la interfaz I2C, tuve que configurarlos explícitamente en el código de abajo para que funcionara.
Aquí tienes una foto de cómo queda nuestro Reloj Automático de Horario de Verano en la vida real, cuando el cableado está completo y el código está funcionando.
Por cierto, si necesitas más información sobre la placa SuperMini que uso aquí, échale un vistazo al ESP32-C3 SuperMini Board tutorial.
Código para el reloj
En esta sección, escribiremos el código para nuestro Reloj Automático de Horario de Verano. Hay 5 pasos a seguir.
Primero, tenemos que comprobar la hora y decidir si queremos sincronizar, por ejemplo, una vez cada hora. Si es así, necesitamos descargar la información de la hora del proveedor de hora en internet. Estos datos estarán en formato JSON, así que tendremos que analizarlos y extraer la hora.
Una vez que tengamos la hora, configuraremos el reloj interno del ESP32 y luego mostraremos la hora en la pantalla LCD. El siguiente código hace todo esto. Échale un vistazo rápido y te explico los detalles más abajo.
// makerguides.com: Automatic Daylight Savings Time Clock
#include "WiFi.h"
#include "stdarg.h"
#include "HTTPClient.h"
#include "ArduinoJson.h"
#include "TimeLib.h"
#include "LiquidCrystal_I2C.h"
#include "Wire.h"
#define SDA 8
#define SCL 9
#define WIFI_SSID "YOUR_WIFI_SSID"
#define WIFI_PASSPHRASE "YOUR_WIFI_PASSWORD"
#define URL "http://worldtimeapi.org/api/ip"
StaticJsonDocument<2048> doc;
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x3F, 16, 2);
void lcd_print_time() {
time_t t = now();
char buff[24];
sprintf(buff, "%d:%02d:%02d ", hour(t), minute(t), second(t));
lcd.setCursor(3, 0);
lcd.print(buff);
sprintf(buff, "%02d-%02d-%04d ", day(t), month(t), year(t));
lcd.setCursor(3, 1);
lcd.print(buff);
}
bool should_sync_time() {
time_t t = now();
bool wifi_on = WiFi.status() == WL_CONNECTED;
bool should_sync = (minute(t) == 0 && second(t) == 3) || (year(t) == 1970);
return wifi_on && should_sync;
}
void sync_time() {
delay(1000);
HTTPClient http;
http.begin(URL);
if (http.GET() > 0) {
String json = http.getString();
auto error = deserializeJson(doc, json);
if (!error) {
int Y, M, D, h, m, s, ms, tzh, tzm;
sscanf(doc["datetime"], "%d-%d-%dT%d:%d:%d.%d+%d:%d",
&Y, &M, &D, &h, &m, &s, &ms, &tzh, &tzm);
setTime(h, m, s, D, M, Y);
}
}
http.end();
}
void setup() {
Serial.begin(115200);
Wire.begin(SDA, SCL); // I2C for ESP32-C3 Supermini
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PASSPHRASE);
while (WiFi.status() != WL_CONNECTED)
delay(500);
lcd.init();
lcd.backlight();
lcd.clear();
}
void loop() {
if (should_sync_time())
sync_time();
lcd_print_time();
delay(100);
}
Ahora vamos a ver más de cerca las partes del código y entender cómo funciona todo.
Constantes y librerías
Empezamos incluyendo las librerías necesarias para este proyecto, como «WiFi.h«, «HTTPClient.h«, «ArduinoJson.h«, «TimeLib.h» y «LiquidCrystal_I2C.h«. Estas librerías proporcionan la funcionalidad necesaria para la conectividad WiFi, hacer peticiones HTTP, analizar JSON, gestionar la hora y controlar la pantalla LCD.
Necesitarás install las librerías ArduinoJson, TimeLib y LiquidCrystal_I2C. Las demás forman parte de la librería estándar de ESP32/Arduino.
#include "WiFi.h" #include "stdarg.h" #include "HTTPClient.h" #include "ArduinoJson.h" #include "TimeLib.h" #include "LiquidCrystal_I2C.h" #include "Wire.h"
A continuación, definimos los pines (SDA, SCL) para la interfaz I2C y el SSID y contraseña WiFi para conectarnos a la red. Sustituye «YOUR_WIFI_SSID» y «YOUR_WIFI_PASSWORD» por los datos reales de tu red.
#define SDA 8 #define SCL 9 #define WIFI_SSID "YOUR_WIFI_SSID" #define WIFI_PASSPHRASE "YOUR_WIFI_PASSWORD"
También definimos la URL de la API del proveedor de hora en internet que usaremos para sincronizar el reloj. En este ejemplo usamos «http://worldtimeapi.org/api/ip«, pero puedes cambiarla por cualquiera de los otros proveedores que comentamos antes. Sin embargo, como el formato de los datos es diferente entre proveedores, tendrás que ajustar el código de análisis.
#define URL "http://worldtimeapi.org/api/ip"
Luego creamos un documento JSON estático con una capacidad de 2048 bytes para almacenar la respuesta del proveedor de hora en internet. Si la respuesta es más grande, obtendrás un error. Así que si eliges otra API que devuelva una respuesta mayor, asegúrate de aumentar este número.
StaticJsonDocument<2048> doc;
Inicializamos la pantalla LCD usando el LiquidCrystal_I2C library. Los parámetros que pasamos al constructor de LiquidCrystal_I2C especifican la dirección I2C de la pantalla (0x3F) y el número de columnas y filas (16 y 2, respectivamente). Si usas la típica pantalla LCD 20×4, tendrás que cambiar esto. También ten en cuenta que algunas pantallas tienen la dirección I2C 0x27 en vez de 0x3F.
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x3F, 16, 2);
Funciones auxiliares
Siempre es buena idea dividir el código complejo en partes más manejables usando funciones. He implementado tres funciones auxiliares para mostrar la hora en la pantalla LCD, comprobar si hay que sincronizar la hora y descargar la hora actual.
lcd_print_time
La función auxiliar lcd_print_time() imprime la hora actual en la pantalla LCD. Obtiene la hora actual usando la función now() de la TimeLib library y la formatea en una cadena usando la función sprintf(). La cadena de hora formateada se imprime en la pantalla LCD usando la función lcd.print(). Escribimos en la columna 3 y en las filas 0 y 1 para centrar el texto.
void lcd_print_time() {
time_t t = now();
char buff[24];
sprintf(buff, "%d:%02d:%02d ", hour(t), minute(t), second(t));
lcd.setCursor(3, 0);
lcd.print(buff);
sprintf(buff, "%02d-%02d-%04d ", day(t), month(t), year(t));
lcd.setCursor(3, 1);
lcd.print(buff);
}
should_sync_time
Definimos otra función auxiliar llamada should_sync_time() que determina si el reloj debe sincronizarse con el proveedor de hora en internet.
Comprueba si el minuto actual es cero y 3 segundos, o si el año actual es 1970. Eso significa que sincronizamos cada hora y lo hacemos 3 segundos después de la hora en punto para captar el cambio de horario de verano que puede ocurrir justo a la hora. Así que, en el peor de los casos, nuestro reloj tendrá un desfase de 3 segundos.
bool should_sync_time() {
time_t t = now();
bool wifi_on = WiFi.status() == WL_CONNECTED;
bool should_sync = (minute(t) == 0 && second(t) == 3) || (year(t) == 1970);
return wifi_on && should_sync;
}
Puedes sincronizar más a menudo, ¡pero no te pases! El proveedor de hora en internet te bloqueará si intentas obtener la hora cada segundo. Cada diez minutos, por ejemplo, estaría bien.
También comprobamos si el año actual es 1970. Este es el año que tu reloj ESP32 mostrará al arrancar (inicio de Unix time). Esto significa que, cuando el ESP32 se enciende, lo primero que haremos será sincronizar la hora, aunque no sea en punto. ¡Sin esto, la hora podría estar completamente desfasada hasta una hora!
sync_time
A continuación definimos la función sync_time(), que se encarga de sincronizar el reloj con el proveedor de hora en internet. Empieza creando una instancia de la clase HTTPClient y haciendo una GET request a la URL especificada. Si la petición tiene éxito (código de respuesta HTTP > 0), obtiene el cuerpo de la respuesta como una cadena y la analiza como JSON usando el ArduinoJson library.
Si el análisis JSON tiene éxito, extrae el año, mes, día, hora, minuto, segundo e información de zona horaria del objeto JSON usando la función sscanf(). Finalmente, ajusta la hora usando la función setTime() de la TimeLib library.
void sync_time() {
delay(1000);
HTTPClient http;
http.begin(URL);
if (http.GET() > 0) {
String json = http.getString();
auto error = deserializeJson(doc, json);
if (!error) {
int Y, M, D, h, m, s, ms, tzh, tzm;
sscanf(doc["datetime"], "%d-%d-%dT%d:%d:%d.%d+%d:%d",
&Y, &M, &D, &h, &m, &s, &ms, &tzh, &tzm);
setTime(h, m, s, D, M, Y);
}
}
http.end();
}
Para depurar, puedes añadir la siguiente línea después de scanf para imprimir la hora analizada:
Serial.printf("sync: %2d:%02d:%02d %4d-%02d-%02d\n", h, m, s, Y, M, D);
Ten en cuenta que añadí un retardo de 1 segundo al principio de sync_time. Esto es para evitar que se sincronice varias veces en el mismo segundo. Más adelante verás que la pantalla se actualiza cada 100 ms en la función loop. Eso significa que la condición second(t) == 3 sería verdadera 10 veces en el loop y sincronizaríamos varias veces.
Hay mejores formas de gestionar esto. Pero para mantener el código simple, solo usé un delay. Sin embargo, esto también significa que la hora mostrada no se actualizará durante un segundo cada hora. Si quieres, puedes mejorarlo.
Función Setup
En la función setup(), inicializamos la comunicación serie a 115200 baudios. También inicializamos la interfaz I2C usando la función Wire.begin().
Luego, configuramos el modo WiFi en modo estación usando WiFi.mode() y nos conectamos a la red WiFi usando WiFi.begin(). Esperamos hasta que la conexión se establezca comprobando continuamente el estado de WiFi con WiFi.status().
Por último, inicializamos la pantalla LCD, encendemos la retroiluminación y limpiamos la pantalla llamando a las funciones lcd.init(), lcd.backlight() y lcd.clear(), respectivamente.
void setup() {
Serial.begin(115200);
Wire.begin(SDA, SCL); // I2C for ESP32-C3 Supermini
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PASSPHRASE);
while (WiFi.status() != WL_CONNECTED)
delay(500);
lcd.init();
lcd.backlight();
lcd.clear();
}
Ten en cuenta que tuve que establecer explícitamente los pines SDA y SCL para la interfaz I2C usando Wire.begin(8,9). No conseguí que I2C funcionara en el ESP32-C3 Supermini sin esto. Si alguien encuentra una mejor solución, por favor, que lo deje en los comentarios.
Función Loop
En la función loop(), comprobamos continuamente si el reloj debe sincronizarse con el proveedor de hora en internet llamando a la función should_sync_time(). Si es necesario sincronizar, llamamos a la función sync_time() para actualizar el reloj. Luego, llamamos a la función lcd_print_time() para mostrar la hora actual en la pantalla LCD. Añadimos un pequeño retardo de 100 milisegundos usando la función delay() para evitar actualizaciones excesivas.
void loop() {
if (should_sync_time())
sync_time();
lcd_print_time();
delay(100);
}
¡Eso es todo! Con este código, tenemos un reloj digital que se ajusta automáticamente al horario de verano y a diferentes zonas horarias sincronizándose por WiFi con un proveedor de hora en internet. La hora actual se muestra en una pantalla LCD y el reloj se sincroniza periódicamente.
Extensiones
Hay muchas posibles ampliaciones para este proyecto. Además de la hora y la fecha, podríamos mostrar la zona horaria, el desfase horario y si el horario de verano está activo o no. Obviamente, un pitido cada hora o una función de alarma también serían útiles.
Dependiendo de tu país, quizá prefieras mostrar la hora en formato AM/PM en vez de 24 horas, o para varias zonas horarias. También sería fácil mostrar el nombre del día de la semana y el nombre del mes.
No estamos limitados solo a proveedores de hora en internet. Cualquier información disponible en internet, como previsiones meteorológicas, cotizaciones de bolsa o noticias generales, se podría mostrar además de la hora. Solo es otra petición HTTP con datos que se pueden analizar.
Por último, ya que nos conectamos a internet a intervalos regulares, podríamos aprovechar esto para monitorizar la velocidad de internet o la pérdida de conectividad.
Conclusión
En este tutorial, hemos aprendido a construir un reloj digital que se ajusta automáticamente al horario de verano y a diferentes zonas horarias. Al sincronizar el reloj por WiFi con un proveedor de hora en internet, podemos asegurarnos de que nuestro reloj siempre muestre la hora exacta.
Empezamos hablando de los componentes necesarios para este proyecto, que incluyen una placa ESP32 con WiFi y una pantalla LCD. Luego explicamos cómo conectar estos componentes para crear el reloj.
Después, hablamos del concepto de horario de verano y su importancia para ajustar el reloj según los cambios estacionales. Vimos cómo gestionar el horario de verano en nuestro código para que el reloj se actualice correctamente.
Para sincronizar nuestro reloj con un proveedor de hora en internet, utilizamos técnicas de análisis de JSON para extraer los datos de hora de la API del proveedor. También aprendimos a trabajar con cadenas datetime para convertir y mostrar la hora en la pantalla LCD.
Si quieres una pantalla más grande y con pantalla táctil para tu reloj, échale un vistazo al Digital Clock with CrowPanel 3.5″ ESP32 Display tutorial. Y si quieres mostrar la hora de una forma más original, puedes usar este código para construir un Reloj de Anillo LED como se describe en este tutorial: LED Ring Clock with WS2812.
Si tienes más preguntas o necesitas ayuda adicional, consulta la sección de Preguntas Frecuentes o visita los enlaces proporcionados para más recursos e información.
Preguntas Frecuentes
Aquí tienes algunas preguntas frecuentes sobre cómo construir un reloj digital que se ajusta automáticamente al horario de verano y a diferentes zonas horarias:
P: ¿Puedo usar cualquier placa con WiFi para este proyecto?
R: Sí, puedes usar cualquier placa microcontroladora que tenga WiFi o que se le pueda añadir un WiFi shield. Algunas opciones populares son los módulos ESP8266 y ESP32, que ya tienen WiFi incorporado.
P: ¿Cómo ajusta el reloj el horario de verano?
R: El reloj se ajusta al horario de verano sincronizándose con un proveedor de hora en internet. Estos proveedores ofrecen información precisa, incluyendo la zona horaria actual y si el horario de verano está activo. Analizando esta información y ajustando el reloj en consecuencia, puedes asegurarte de que tu reloj siempre muestre la hora correcta.
P: ¿Necesito una pantalla LCD para este proyecto?
R: Aunque no es obligatorio usar una pantalla LCD, es recomendable para este proyecto porque te permite ver la hora de forma visual. Sin embargo, si lo prefieres, también puedes mostrar la hora en un monitor serie o en cualquier otro dispositivo de salida que elijas.
P: ¿Puedo personalizar el código para añadir más funciones?
R: ¡Por supuesto! El código proporcionado es solo un punto de partida y puedes personalizarlo para añadir más funciones o modificar su comportamiento según tus necesidades. Por ejemplo, podrías añadir soporte para varias zonas horarias, mostrar información adicional o integrar otros sensores o módulos en el proyecto.
P: ¿Hay alguna limitación al usar un proveedor de hora en internet?
R: Aunque usar un proveedor de hora en internet es una forma cómoda de sincronizar tu reloj, depende de tener conexión a internet. Si tu reloj no puede conectarse, puede que no actualice la hora correctamente. Además, si el proveedor de hora tiene problemas o está caído, también puede afectar a la precisión de tu reloj.
Enlaces
Aquí tienes algunos enlaces útiles a proyectos similares:
- NTP ESP32: Use Internet to get date and time with Arduino code
- NTP with Day Light Saving Time for the ESP32
- ESP32 Useful Wi-Fi Library Functions
- ESP32 HTTP GET and HTTP POST
