Fica irritado por ter de ajustar todos os relógios para a hora de verão duas vezes por ano? Se sim, este artigo é para si! Vou mostrar-lhe como construir um relógio digital que se ajusta automaticamente. Além disso, terá sempre um relógio com a hora certa.
Ao sincronizar o relógio via WiFi com um fornecedor de hora na internet, garantimos que o nosso relógio mostra sempre a hora correta, independentemente das mudanças de hora de verão ou se mudarmos de fuso horário. Além disso, vamos aprender a analisar strings JSON e datetime e a mostrar a hora num ecrã LCD.
Vou usar um ESP32-C3 SuperMini para este projeto, mas qualquer ESP32, ESP8266 ou um Arduino com WiFi shield também funcionam.
Vamos começar!
Componentes Necessários
Aqui estão os componentes necessários para o projeto. Em vez da placa de desenvolvimento ESP32-C3 Mini listada abaixo, usei uma placa muito semelhante chamada ESP32-C3 SuperMini do AliExpress. A minha tinha apenas um LED incorporado de uma cor, enquanto a placa abaixo tem um LED RGB. Mas tirando isso, devem ser quase idênticas e ambas devem funcionar.
ESP32-C3 Mini
Cabo USB C
LCD 16×2
Conjunto de Cabos 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.
Hora de Verão
A Hora de Verão (DST) é uma prática de adiantar o relógio uma hora durante os meses de verão para prolongar a luz do dia à noite. Esta alteração serve para poupar energia e aproveitar melhor a luz natural. No entanto, nem todos os países ou regiões adotam a hora de verão, e as datas de início e fim variam.
A maioria dos países muda a hora à 1h ou 2h e adianta uma hora. Mas há casos especiais, como a Ilha Lord Howe, na Austrália, que adianta apenas 30 minutos, Cuba muda à meia-noite e alguns países mudam à 1h UTC em vez de 1h local. Para uma visão completa, veja o artigo da Wikipédia: Daylight saving time by country.
Para garantir que o nosso relógio digital se ajusta automaticamente à hora de verão, precisamos de implementar um mecanismo que tenha em conta as regras de DST do fuso horário específico. No entanto, a variedade de regras entre países torna a implementação destas alterações bastante complexa. Por isso, vamos confiar num fornecedor de hora na internet que trata de tudo por nós.
Ao sincronizar o nosso relógio com um fornecedor de hora na internet, podemos obter a hora atual juntamente com dados adicionais, como o fuso horário e se a hora de verão está ativa. Esta informação é normalmente fornecida num JSON format, que precisamos de analisar para extrair os detalhes relevantes.
Na próxima secção, vamos ver alguns fornecedores de hora na internet, como ligar a eles e qual o formato JSON que usam.
Fornecedor de Hora na Internet
Nesta secção vamos falar rapidamente sobre três fornecedores de hora na internet, como usar as suas APIs e que informação está incluída no JSON que fornecem. Também vou falar um pouco sobre o Network Time Protocol (NTP), que é uma boa alternativa.
WorldTimeAPI
WorldTimeAPI é um serviço web simples, que devolve a hora atual em texto simples ou JSON. Pode usar este site para obter a hora de um determinado fuso horário ou com base no endereço IP do seu computador. Vamos usar esta última opção. É mais fácil e assim o nosso relógio ajusta-se automaticamente não só à hora de verão, mas também quando for mudado de fuso horário.
É muito fácil experimentar o WorldTimeAPI. Basta clicar neste link: http://worldtimeapi.org/api/ip ou introduzi-lo na barra de pesquisa do seu navegador. Note que não precisa de indicar explicitamente o seu endereço IP. O serviço web deteta isso automaticamente com base na origem do pedido. O que vai ver no navegador é uma saída semelhante à seguinte (adicionei alguma formatação para ser mais legível e ocultei o meu 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 saída está em formato JSON. Contém outras informações além da hora atual. Mas estamos especialmente interessados no campo datetime, que nos dá a hora local atual. Neste exemplo é "2023-11-16T12:09:46.409360+11:00".
Sempre que aceder a este link, vai obter a hora atualizada. Só não abuse e não aceda ao link demasiadas vezes, senão pode ser bloqueado!
O WorldTimeAPI é o fornecedor de hora na internet que vamos usar para o nosso relógio. Mas também vou indicar duas alternativas que devolvem informações ligeiramente diferentes, que podem ser mais adequadas para o seu caso.
timezonedb
Timezonedb oferece várias outras APIs que pode usar para obter informação sobre fusos horários. Mas também tem um serviço que devolve a hora atual. No entanto, tem de se registar para obter uma API_KEY que lhe permite usar o serviço. Existe um plano gratuito e, depois de ter a sua API_KEY pode usar o seguinte link para receber a informação da hora em formato JSON:
http://api.timezonedb.com/v2/get-time-zone?key=API_KEY&format=json&by=zone&zone=Australia/Melbourne
Infelizmente, tem de indicar um fuso horário. Precisa do plano premium pago para consultar por endereço 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"
}
No entanto, a vantagem deste serviço é que devolve uma string de hora já formatada, fácil de usar. Veja o campo formatted acima.
ipgeolocation
Como terceira opção, temos ipgeolocation. Também terá de se registar para obter um API_KEY. Mas o plano gratuito para programadores é bastante generoso, com 1.000 pedidos diários e 30.000 mensais, o que é mais do que suficiente. Aqui está o link para obter a hora com base no seu endereço IP: https://api.ipgeolocation.io/timezone?apiKey=API_KEY. Obviamente, terá de colocar o seu próprio API_KEY aí.
A informação devolvida é muito completa e inclui não só a hora, mas também a geolocalização do utilizador. Como pode ver, atualmente vivo em Melbourne, Austrália.
{
"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
}
O ipgeolocation é o meu fornecedor de hora preferido devido ao formato conveniente da informação de data e hora que devolve (veja os campos date_time, date_time_txt, e date_time_wti) e os dados adicionais.
No entanto, para simplificar ao máximo, no nosso exemplo de relógio vou usar o WorldTimeAPI, pois não é necessário registo para usar o serviço.
Network Time Protocol
Finalmente, uma palavra sobre o Network Time Protocol (NTP): “O Network Time Protocol (NTP) é um networking protocol para clock synchronization entre sistemas informáticos através de packet-switched, redes de dados com latency variável.” (fonte: Wikipédia).
Foi especificamente desenhado para sincronizar relógios com precisão, mas é bastante complexo e difícil de usar. Veja o TimeNTP library e o example code.
No entanto, existe também o SNTP (Simple Network Time Protocol), que é uma versão simplificada do NTP. Embora seja menos preciso do que o NTP, o SNTP ainda fornece a hora com uma precisão de 100 milissegundos. É muito mais fácil de usar e, se quiser saber mais, veja o nosso tutorial How to synchronize ESP32 clock with SNTP server
Na próxima secção, mostro-lhe como ligar um ecrã LCD a um ESP32, para podermos mostrar a hora e a data de forma prática.
Ligar os Componentes
Precisamos de um ecrã para mostrar a hora do nosso relógio. Qualquer ecrã serve, mas para simplificar vamos usar um LCD 16×2 ligado via I2C. Para mais informações sobre ecrãs LCD, veja os nossos tutoriais sobre How to use a 16×2 character LCD with Arduino e Character I2C LCD with Arduino Tutorial (8 Examples).
Ligar o ecrã LCD ao ESP32 é muito simples. Primeiro, ligue 5V ao VCC e G ao Ground. Depois, ligue o SDA ao pino 8 (fio amarelo) e o SCL ao pino 9 (fio laranja) no ESP32.
Certifique-se de ligar corretamente o SDA e o SCL. Se usar uma placa diferente, pode querer mudar para os pinos que suportam a interface I2C na sua placa. Procure os pinos marcados com SDA e SCL no pinout. Aqui está o pinout do ESP32-C3 Supermini, que estou a usar neste projeto:
Embora os pinos GPIO8 e GPIO9 sejam supostamente os nativos para a interface I2C, tive de os definir explicitamente no código abaixo para funcionar.
Aqui está uma foto de como fica o nosso Relógio Automático de Hora de Verão na vida real, quando a cablagem está completa e o código está a correr.
Se precisar de mais informações sobre a placa SuperMini que estou a usar aqui, veja o tutorial ESP32-C3 SuperMini Board.
Código para o Relógio
Nesta secção, vamos escrever o código para o nosso Relógio Automático de Hora de Verão. São 5 passos no total.
Primeiro, precisamos de verificar a hora e decidir se queremos sincronizar, por exemplo, uma vez por hora. Se sim, temos de descarregar a informação da hora do fornecedor de hora na internet. Estes dados vêm em formato JSON. Por isso, temos de os analisar e extrair a hora.
Depois de termos a hora, vamos definir o relógio interno do ESP32 e mostrar a hora no LCD. O código seguinte faz tudo isto. Dê uma vista de olhos rápida e explico os detalhes a seguir.
// 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);
}
Agora vamos analisar as partes do código e perceber como tudo funciona.
Constantes e Bibliotecas
Começamos por incluir as bibliotecas necessárias para este projeto, como “WiFi.h“, “HTTPClient.h“, “ArduinoJson.h“, “TimeLib.h” e “LiquidCrystal_I2C.h“. Estas bibliotecas fornecem a funcionalidade necessária para ligação WiFi, fazer pedidos HTTP, analisar JSON, gerir o tempo e controlar o ecrã LCD.
Vai precisar de install as bibliotecas ArduinoJson, TimeLib e LiquidCrystal_I2C. As outras fazem parte da biblioteca padrão do ESP32/Arduino.
#include "WiFi.h" #include "stdarg.h" #include "HTTPClient.h" #include "ArduinoJson.h" #include "TimeLib.h" #include "LiquidCrystal_I2C.h" #include "Wire.h"
De seguida, definimos os pinos (SDA, SCL) para a interface I2C e o SSID e password do WiFi para ligar à rede. Substitua “YOUR_WIFI_SSID” e “YOUR_WIFI_PASSWORD” pelos dados reais da sua rede.
#define SDA 8 #define SCL 9 #define WIFI_SSID "YOUR_WIFI_SSID" #define WIFI_PASSPHRASE "YOUR_WIFI_PASSWORD"
Também definimos o URL da API do fornecedor de hora na internet que vamos usar para sincronizar o relógio. Neste exemplo, usamos “http://worldtimeapi.org/api/ip“, mas pode substituir por outro dos fornecedores que discutimos acima. No entanto, como o formato dos dados é diferente, terá de ajustar o código de análise conforme necessário.
#define URL "http://worldtimeapi.org/api/ip"
Depois, criamos um documento JSON estático com capacidade de 2048 bytes para guardar a resposta do fornecedor de hora. Se a resposta for maior, vai dar erro. Por isso, se escolher outra API que devolva uma resposta maior, aumente este valor.
StaticJsonDocument<2048> doc;
Inicializamos o ecrã LCD usando o LiquidCrystal_I2C library. Os parâmetros passados ao construtor LiquidCrystal_I2C especificam o endereço I2C do ecrã (0x3F) e o número de colunas e linhas (16 e 2, respetivamente). Se usar um ecrã LCD 20×4, tem de alterar isto. Note também que alguns ecrãs têm o endereço I2C 0x27 em vez de 0x3F.
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x3F, 16, 2);
Funções Auxiliares
É sempre boa prática dividir código complexo em partes mais pequenas e fáceis de gerir usando funções. Implementei três funções auxiliares: para mostrar a hora no LCD, para verificar se é preciso sincronizar a hora e para descarregar a hora atual.
lcd_print_time
A função auxiliar lcd_print_time() imprime a hora atual no ecrã LCD. Vai buscar a hora atual usando a função now() da TimeLib library e formata-a numa string usando a função sprintf(). A string formatada é então impressa no LCD usando a função lcd.print(). Escrevemos na coluna 3 e nas linhas 0 e 1 para centrar o 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 outra função auxiliar chamada should_sync_time() que determina se o relógio deve ser sincronizado com o fornecedor de hora na internet.
Verifica se o minuto atual é zero e 3 segundos ou se o ano atual é 1970. Ou seja, sincronizamos a cada hora e fazemos isso 3 segundos depois da hora certa para apanhar a mudança de hora de verão que pode ocorrer à hora cheia. No pior dos casos, o nosso relógio fica 3 segundos atrasado.
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;
}
Pode sincronizar mais vezes, mas não exagere! O fornecedor de hora na internet pode bloqueá-lo se tentar buscar a hora a cada segundo! De dez em dez minutos deve ser suficiente.
Também verificamos se o ano atual é 1970. Este é o ano que o relógio do ESP32 indica quando é ligado (início da Unix time). Ou seja, quando o ESP32 é ligado, a primeira coisa que fazemos é sincronizar a hora, mesmo que não seja à hora cheia. Sem isto, a hora pode estar errada até uma hora!
sync_time
De seguida, definimos a função sync_time(), responsável por sincronizar o relógio com o fornecedor de hora na internet. Começa por criar uma instância da classe HTTPClient e faz um GET request para o URL especificado. Se o pedido for bem-sucedido (código de resposta HTTP > 0), obtém o corpo da resposta como string e analisa-o como JSON usando o ArduinoJson library.
Se a análise do JSON for bem-sucedida, extrai o ano, mês, dia, hora, minuto, segundo e informação do fuso horário do objeto JSON usando a função sscanf(). Por fim, define a hora usando a função setTime() da 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 depuração, pode adicionar a seguinte linha depois de scanf para imprimir a hora analisada:
Serial.printf("sync: %2d:%02d:%02d %4d-%02d-%02d\n", h, m, s, Y, M, D);
Note que adicionei um atraso de 1 segundo no início de sync_time. Isto serve para evitar que sincronizemos várias vezes no mesmo segundo. Vai ver mais à frente que o ecrã é atualizado a cada 100ms na função loop. Ou seja, a condição second(t) == 3 seria verdadeira 10 vezes no loop e sincronizávamos várias vezes.
Há formas melhores de tratar isto. Mas para simplificar, usei apenas um delay. No entanto, isto significa que a hora não é atualizada durante um segundo a cada hora. Sinta-se à vontade para melhorar este ponto.
Função Setup
Na função setup(), inicializamos a comunicação série a 115200 bauds. Também inicializamos a interface I2C usando a função Wire.begin().
Depois, definimos o modo WiFi para station com WiFi.mode() e ligamos à rede WiFi com WiFi.begin(). Esperamos até a ligação estar estabelecida, verificando continuamente o estado do WiFi com WiFi.status().
Por fim, inicializamos o LCD, ligamos a luz de fundo e limpamos o ecrã chamando as funções lcd.init(), lcd.backlight() e lcd.clear(), respetivamente.
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();
}
Note que tive de definir explicitamente os pinos SDA e SCL para a interface I2C usando Wire.begin(8,9). Não consegui pôr o I2C a funcionar no ESP32-C3 Supermini sem isso. Se alguém encontrar uma solução melhor, diga nos comentários.
Função Loop
Na função loop(), verificamos continuamente se o relógio deve ser sincronizado com o fornecedor de hora na internet, chamando a função should_sync_time(). Se for necessário sincronizar, chamamos a função sync_time() para atualizar o relógio. Depois, chamamos a função lcd_print_time() para mostrar a hora atual no LCD. Adicionamos um pequeno atraso de 100 milissegundos com a função delay() para evitar atualizações excessivas.
void loop() {
if (should_sync_time())
sync_time();
lcd_print_time();
delay(100);
}
E está feito! Com este código, temos um relógio digital que se ajusta automaticamente à hora de verão e a diferentes fusos horários, sincronizando via WiFi com um fornecedor de hora na internet. A hora atual é mostrada num ecrã LCD e o relógio é sincronizado periodicamente.
Extensões
Há muitas possíveis extensões para este projeto. Além da hora e data, podíamos mostrar o fuso horário, o offset do fuso e se a hora de verão está ativa ou não. Obviamente, um beep horário ou uma função de alarme também seriam interessantes.
Dependendo do seu país, pode preferir mostrar a hora em formato AM/PM em vez de 24 horas, ou para vários fusos horários. Também seria fácil mostrar o nome do dia da semana e do mês.
Não estamos limitados apenas a fornecedores de hora na internet. Qualquer informação disponível online, como previsões meteorológicas, cotações de bolsa ou notícias, pode ser mostrada além da hora. É só mais um pedido HTTP com dados para analisar.
Finalmente, como nos ligamos à internet em intervalos regulares, podíamos aproveitar para monitorizar a velocidade da internet ou falhas de ligação.
Conclusão
Neste tutorial, aprendemos a construir um relógio digital que se ajusta automaticamente à hora de verão e a diferentes fusos horários. Ao sincronizar o relógio via WiFi com um fornecedor de hora na internet, garantimos que o nosso relógio mostra sempre a hora certa.
Começámos por falar dos componentes necessários para este projeto, que incluem uma placa ESP32 com WiFi e um ecrã LCD. Depois explicámos como ligar estes componentes para criar o relógio.
A seguir, discutimos o conceito de hora de verão e a sua importância para ajustar o relógio às mudanças sazonais. Explorámos como tratar a hora de verão no código para garantir que o relógio se atualiza corretamente.
Para sincronizar o nosso relógio com um fornecedor de hora na internet, usámos técnicas de análise de JSON para extrair a hora da API do fornecedor. Também aprendemos a trabalhar com strings datetime para converter e mostrar a hora no LCD.
Se quiser um ecrã maior, mais bonito e com touch para o seu relógio, veja o tutorial Digital Clock with CrowPanel 3.5″ ESP32 Display. E se quiser mostrar a hora de uma forma mais original, pode usar este código para construir um Relógio de Anel de LEDs, como descrito neste tutorial: LED Ring Clock with WS2812.
Se tiver mais dúvidas ou precisar de ajuda extra, consulte a secção de Perguntas Frequentes ou visite os links fornecidos para mais recursos e informação.
Perguntas Frequentes
Aqui estão algumas perguntas frequentes sobre como construir um relógio digital que se ajusta automaticamente à hora de verão e a diferentes fusos horários:
P: Posso usar qualquer placa com WiFi para este projeto?
R: Sim, pode usar qualquer microcontrolador com WiFi ou que possa ser equipado com um WiFi shield. Algumas opções populares são os módulos ESP8266 e ESP32, que já têm WiFi integrado.
P: Como é que o relógio se ajusta à hora de verão?
R: O relógio ajusta-se à hora de verão ao sincronizar com um fornecedor de hora na internet. Estes fornecedores fornecem informação precisa, incluindo o fuso horário atual e se a hora de verão está ativa. Ao analisar esta informação e ajustar o relógio, garante que o seu relógio mostra sempre a hora certa.
P: Preciso mesmo de um ecrã LCD para este projeto?
R: Embora o LCD não seja obrigatório, é recomendado para este projeto porque permite ver a hora de forma visual. No entanto, se preferir, pode mostrar a hora no monitor série ou noutro dispositivo de saída à sua escolha.
P: Posso personalizar o código para adicionar mais funcionalidades?
R: Claro! O código fornecido é apenas um ponto de partida e pode personalizá-lo para adicionar funcionalidades ou alterar o comportamento conforme as suas necessidades. Por exemplo, pode adicionar suporte para vários fusos horários, mostrar mais informação ou integrar outros sensores ou módulos no projeto.
P: Existem limitações ao usar um fornecedor de hora na internet?
R: Embora usar um fornecedor de hora na internet seja uma forma prática de sincronizar o relógio, depende de ter ligação à internet. Se o relógio não conseguir ligar-se, pode não conseguir atualizar a hora corretamente. Além disso, se o fornecedor tiver problemas ou estiver em baixo, isso pode afetar a precisão do relógio.
Links
Aqui estão alguns links úteis para projetos semelhantes:
- 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
