Est-ce que ça vous agace de devoir régler toutes vos horloges à l’heure d’été deux fois par an ? Si oui, cet article est fait pour vous ! Je vais vous montrer comment construire une horloge numérique qui se règle automatiquement. En plus, vous aurez une horloge toujours précise.
En synchronisant l’horloge via WiFi avec un fournisseur de temps sur Internet, on peut s’assurer que notre horloge affiche toujours l’heure exacte, peu importe les changements d’heure d’été ou les déplacements dans différents fuseaux horaires. Nous apprendrons aussi à analyser des chaînes JSON et datetime, et à afficher l’heure sur un écran LCD.
J’utiliserai un ESP32-C3 SuperMini pour ce projet, mais n’importe quel ESP32, ESP8266 ou un Arduino avec un shield WiFi fonctionnera aussi.
C’est parti !
Composants nécessaires
Voici les composants nécessaires pour le projet. À la place de la carte de développement ESP32-C3 Mini listée ci-dessous, j’ai utilisé une carte très similaire appelée ESP32-C3 SuperMini d’AliExpress. La mienne avait seulement une LED intégrée monochrome, alors que la carte ci-dessous a une LED RGB. Mais à part ça, elles devraient être presque identiques et toutes deux fonctionneront.
ESP32-C3 Mini
Câble USB C
LCD 16×2
Jeu de fils 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.
Heure d’été
L’heure d’été (DST) consiste à avancer l’horloge d’une heure pendant les mois d’été pour prolonger la lumière du jour en soirée. Cette adaptation vise à économiser de l’énergie et à mieux profiter de la lumière naturelle. Cependant, tous les pays ou régions n’appliquent pas l’heure d’été, et les dates de début et de fin varient.
La plupart des pays changent d’heure à 1h ou 2h du matin et avancent d’une heure. Mais il existe des cas particuliers, comme l’île Lord Howe en Australie qui avance de 30 minutes, Cuba qui change à minuit, et certains pays qui changent à 1h UTC au lieu de 1h locale. Pour un aperçu complet, consultez l’article Wikipédia : Daylight saving time by country.
Pour que notre horloge numérique s’ajuste automatiquement à l’heure d’été, il faut mettre en place un mécanisme qui prend en compte les règles DST du fuseau horaire choisi. Cependant, la diversité des règles selon les pays rend la gestion de l’heure d’été assez complexe à implémenter soi-même. À la place, nous allons nous appuyer sur un fournisseur de temps en ligne qui gère tout cela pour nous.
En synchronisant notre horloge avec un fournisseur de temps sur Internet, on peut récupérer l’heure actuelle ainsi que des données supplémentaires, comme le fuseau horaire et si l’heure d’été est active. Ces informations sont généralement fournies dans un JSON format, qu’il faudra analyser pour extraire les détails utiles.
Dans la prochaine section, nous allons voir quelques fournisseurs de temps sur Internet, comment s’y connecter et à quoi ressemble leur format JSON.
Fournisseur de temps sur Internet
Dans cette section, nous allons rapidement présenter trois fournisseurs de temps sur Internet, comment utiliser leurs APIs et quelles informations sont contenues dans leur sortie JSON. Je vous parlerai aussi un peu du Network Time Protocol (NTP), qui est une bonne alternative.
WorldTimeAPI
WorldTimeAPI est un service web simple qui retourne l’heure actuelle en texte brut ou en JSON. Vous pouvez utiliser ce site pour obtenir l’heure d’un fuseau horaire donné ou selon l’adresse IP de votre ordinateur. Nous allons utiliser cette dernière option. C’est plus simple et notre horloge s’ajustera alors automatiquement non seulement à l’heure d’été mais aussi lors d’un changement de fuseau horaire.
Il est très facile de tester WorldTimeAPI. Cliquez simplement sur ce lien : http://worldtimeapi.org/api/ip ou entrez-le dans la barre de recherche de votre navigateur. Notez que vous n’avez pas besoin d’indiquer explicitement votre adresse IP. Le service web la détecte automatiquement selon l’origine de la requête. Ce que vous verrez dans votre navigateur sera une sortie similaire à celle-ci (j’ai ajouté un peu de mise en forme pour la lisibilité et masqué mon 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
}
Cette sortie est au format JSON. Elle contient d’autres informations en plus de l’heure actuelle. Mais ce qui nous intéresse particulièrement, c’est le champ datetime, qui nous donne l’heure locale actuelle. Dans cet exemple, il est "2023-11-16T12:09:46.409360+11:00".
À chaque fois que vous allez sur ce lien, vous obtenez l’heure mise à jour. Attention à ne pas rafraîchir ce lien trop souvent, sinon vous risquez d’être bloqué !
WorldTimeAPI est le fournisseur de temps sur Internet que nous allons utiliser pour notre horloge. Mais je vais aussi vous donner deux alternatives qui retournent des informations légèrement différentes, ce qui pourrait mieux convenir à votre cas d’usage.
timezonedb
Timezonedb propose plusieurs autres APIs pour obtenir des informations sur les fuseaux horaires. Mais il a aussi un service qui retourne l’heure actuelle. Cependant, il faut s’inscrire pour obtenir une API_KEY qui vous permet d’utiliser leur service. Il existe un plan gratuit et une fois que vous avez votre API_KEY, vous pouvez utiliser le lien suivant pour recevoir l’heure au format JSON :
http://api.timezonedb.com/v2/get-time-zone?key=API_KEY&format=json&by=zone&zone=Australia/Melbourne
Malheureusement, il faut fournir un fuseau horaire. Il faut un plan premium payant pour faire une requête par adresse 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"
}
L’avantage de ce service, c’est qu’il retourne une chaîne d’heure déjà bien formatée et facile à utiliser. Voir le champ formatted ci-dessus.
ipgeolocation
Comme troisième option, nous avons ipgeolocation. Il faut aussi s’inscrire pour obtenir une API_KEY. Mais le plan développeur gratuit est très généreux avec 1 000 requêtes par jour et 30 000 par mois, ce qui est largement suffisant. Voici le lien pour obtenir l’heure selon votre adresse IP : https://api.ipgeolocation.io/timezone?apiKey=API_KEY. Évidemment, il faudra mettre votre propre API_KEY à la place.
Les informations retournées sont très complètes et contiennent non seulement l’heure mais aussi la géolocalisation du demandeur. Comme vous pouvez le voir, je vis actuellement à Melbourne, Australie.
{
"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 est mon fournisseur de temps préféré grâce au format pratique des informations de date et d’heure qu’il retourne (voir les champs date_time, date_time_txt, et date_time_wti) ainsi que les données supplémentaires.
Cependant, pour simplifier au maximum, pour notre exemple d’horloge, j’utiliserai WorldTimeAPI, car il n’est pas nécessaire de s’inscrire pour utiliser leur service.
Network Time Protocol
Enfin, un mot sur le Network Time Protocol (NTP) : « Le Network Time Protocol (NTP) est un networking protocol pour la clock synchronization entre systèmes informatiques via packet-switched, réseaux de données à latency variable. » (source : Wikipédia).
Il est spécialement conçu pour synchroniser les horloges avec précision, mais il est assez complexe et difficile à utiliser. Consultez le TimeNTP library et le example code.
Cependant, il existe aussi le SNTP (Simple Network Time Protocol), qui est une version simplifiée de NTP. Bien que beaucoup moins précis que NTP, SNTP fournit tout de même l’heure à 100 millisecondes près. Il est bien plus simple à utiliser et si vous voulez en savoir plus, consultez notre tutoriel How to synchronize ESP32 clock with SNTP server
Dans la prochaine section, je vous montre comment connecter un écran LCD à un ESP32, pour pouvoir afficher joliment l’heure et la date.
Connexion des composants
Il nous faut un écran pour afficher l’heure de notre horloge. N’importe quel écran ferait l’affaire, mais pour la simplicité, nous allons utiliser un écran LCD 16×2 connecté en I2C. Pour plus d’informations sur les écrans LCD, consultez nos tutoriels sur How to use a 16×2 character LCD with Arduino et Character I2C LCD with Arduino Tutorial (8 Examples).
Connecter l’écran LCD à l’ESP32 est très simple. D’abord, reliez le 5V à VCC et G à la masse. Ensuite, connectez SDA à la broche 8 (fil jaune) et SCL à la broche 9 (fil orange) sur l’ESP32.
Assurez-vous de bien connecter SDA et SCL. Si vous utilisez une autre carte, vous voudrez peut-être changer pour les broches qui supportent l’interface I2C sur votre carte. Cherchez simplement les broches marquées SDA et SCL sur le schéma de broches. Voici le schéma de broches de l’ESP32-C3 Supermini que j’utilise dans ce projet :
Bien que les broches GPIO8 et GPIO9 soient censées être les broches natives pour l’interface I2C, j’ai dû les définir explicitement dans le code ci-dessous pour que cela fonctionne.
Voici une photo de notre horloge automatique pour l’heure d’été une fois le câblage terminé et le code en fonctionnement.
Au fait, si vous avez besoin de plus d’informations sur la carte SuperMini que j’utilise ici, consultez le tutoriel ESP32-C3 SuperMini Board.
Code pour l’horloge
Dans cette section, nous allons écrire le code de notre horloge automatique pour l’heure d’été. Il y a 5 étapes à suivre.
D’abord, il faut vérifier l’heure et décider si on veut synchroniser, par exemple, une fois par heure. Si oui, il faut télécharger les informations de temps depuis le fournisseur de temps sur Internet. Ces données seront au format JSON. Il faudra donc les analyser et extraire l’heure.
Une fois l’heure récupérée, on règle l’horloge interne de l’ESP32 puis on affiche l’heure sur le LCD. Le code suivant fait tout cela. Jetez-y un œil rapidement et j’expliquerai les détails dans le texte ci-dessous.
// 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);
}
Voyons maintenant de plus près les différentes parties du code et comprenons comment tout cela fonctionne.
Constantes et bibliothèques
On commence par inclure les bibliothèques nécessaires à ce projet, comme « WiFi.h« , « HTTPClient.h« , « ArduinoJson.h« , « TimeLib.h » et « LiquidCrystal_I2C.h« . Ces bibliothèques fournissent les fonctionnalités requises pour la connexion WiFi, les requêtes HTTP, l’analyse JSON, la gestion du temps et le contrôle de l’écran LCD.
Vous devrez install les bibliothèques ArduinoJson, TimeLib et LiquidCrystal_I2C. Les autres font partie de la bibliothèque standard ESP32/Arduino.
#include "WiFi.h" #include "stdarg.h" #include "HTTPClient.h" #include "ArduinoJson.h" #include "TimeLib.h" #include "LiquidCrystal_I2C.h" #include "Wire.h"
Ensuite, on définit les broches (SDA, SCL) pour l’interface I2C ainsi que le SSID WiFi et le mot de passe pour se connecter au réseau. Remplacez « YOUR_WIFI_SSID » et « YOUR_WIFI_PASSWORD » par vos identifiants réseau réels.
#define SDA 8 #define SCL 9 #define WIFI_SSID "YOUR_WIFI_SSID" #define WIFI_PASSPHRASE "YOUR_WIFI_PASSWORD"
On définit aussi l’URL de l’API du fournisseur de temps sur Internet que nous utiliserons pour synchroniser l’horloge. Dans cet exemple, on utilise « http://worldtimeapi.org/api/ip« , mais vous pouvez la remplacer par l’un des autres fournisseurs de temps mentionnés plus haut. Cependant, comme le format des données diffère selon les fournisseurs, il faudra adapter le code d’analyse en conséquence.
#define URL "http://worldtimeapi.org/api/ip"
On crée ensuite un document JSON statique d’une capacité de 2048 octets pour stocker la réponse du fournisseur de temps. Si la réponse est plus grande, vous aurez une erreur. Donc si vous choisissez une autre API qui retourne une réponse plus volumineuse, pensez à augmenter ce nombre.
StaticJsonDocument<2048> doc;
On initialise l’écran LCD avec le LiquidCrystal_I2C library. Les paramètres passés au constructeur LiquidCrystal_I2C spécifient l’adresse I2C de l’écran (0x3F) et le nombre de colonnes et de lignes (16 et 2, respectivement). Si vous utilisez un écran LCD 20×4 courant, il faudra changer cela. Notez aussi que certains écrans ont l’adresse I2C 0x27 au lieu de 0x3F.
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x3F, 16, 2);
Fonctions utilitaires
Il est toujours bon de découper un code complexe en parties plus petites et gérables avec des fonctions. J’ai implémenté trois fonctions utilitaires pour afficher l’heure sur l’écran LCD, vérifier si une synchronisation est nécessaire, et télécharger l’heure actuelle.
lcd_print_time
La fonction utilitaire lcd_print_time() affiche l’heure actuelle sur l’écran LCD. Elle récupère l’heure actuelle avec la fonction now() de la TimeLib library et la formate en chaîne avec la fonction sprintf(). La chaîne d’heure formatée est ensuite affichée sur l’écran LCD avec la fonction lcd.print(). On écrit à la colonne 3 et aux lignes 0 et 1 pour centrer joliment le texte.
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
On définit une autre fonction utilitaire appelée should_sync_time() qui détermine si l’horloge doit être synchronisée avec le fournisseur de temps sur Internet.
Elle vérifie si la minute actuelle est zéro et 3 secondes, ou si l’année courante est 1970. Cela veut dire qu’on synchronise chaque heure, et on le fait 3 secondes après l’heure pile pour capter le changement d’heure d’été qui peut survenir à l’heure pile. Donc, au pire, notre horloge a 3 secondes de décalage.
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;
}
Vous pouvez synchroniser plus souvent mais n’en abusez pas ! Le fournisseur de temps sur Internet peut vous bloquer si vous essayez de récupérer l’heure chaque seconde ! Toutes les dix minutes environ, ce serait probablement suffisant.
On vérifie aussi si l’année courante est 1970. C’est l’année que votre horloge ESP32 affichera au démarrage (début de Unix time). Cela signifie qu’au démarrage de l’ESP32, la première chose à faire est de synchroniser l’heure, même si ce n’est pas à l’heure pile. Sinon, l’heure pourrait être complètement fausse pendant près d’une heure !
sync_time
Ensuite, on définit la fonction sync_time() qui s’occupe de synchroniser l’horloge avec le fournisseur de temps sur Internet. Elle commence par créer une instance de la classe HTTPClient et effectue une GET request vers l’URL spécifiée. Si la requête réussit (code de réponse HTTP > 0), elle récupère le corps de la réponse sous forme de chaîne et l’analyse en JSON avec le ArduinoJson library.
Si l’analyse JSON réussit, elle extrait l’année, le mois, le jour, l’heure, la minute, la seconde et les informations de fuseau horaire de l’objet JSON avec la fonction sscanf(). Enfin, elle règle l’heure avec la fonction 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();
}
Pour le débogage, vous pouvez ajouter la ligne suivante après scanf pour afficher l’heure analysée :
Serial.printf("sync: %2d:%02d:%02d %4d-%02d-%02d\n", h, m, s, Y, M, D);
Notez que j’ai ajouté un délai d’une seconde au début de sync_time. C’est pour éviter de synchroniser plusieurs fois dans la même seconde. Vous verrez plus tard que l’affichage de l’heure est mis à jour toutes les 100 ms dans la fonction loop. Cela veut dire que la condition second(t) == 3 serait vraie 10 fois dans la boucle et on synchroniserait plusieurs fois.
Il existe de meilleures façons de gérer cela. Mais pour garder le code simple, j’ai juste utilisé un délai. Cela signifie aussi que l’heure affichée ne sera pas mise à jour pendant une seconde chaque heure. N’hésitez pas à améliorer ce point.
Fonction Setup
Dans la fonction setup(), on initialise la communication série à un débit de 115200 bauds. On initialise aussi l’interface I2C avec la fonction Wire.begin().
Ensuite, on passe le WiFi en mode station avec WiFi.mode() et on se connecte au réseau WiFi avec WiFi.begin(). On attend que la connexion soit établie en vérifiant en continu le statut WiFi avec WiFi.status().
Enfin, on initialise l’écran LCD, on allume le rétroéclairage et on efface l’affichage en appelant les fonctions lcd.init(), lcd.backlight() et lcd.clear() respectivement.
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();
}
Notez que j’ai explicitement défini les broches SDA et SCL pour l’interface I2C avec Wire.begin(8,9). Je n’ai pas réussi à faire fonctionner l’I2C sur l’ESP32-C3 Supermini sans cela. Si quelqu’un trouve une meilleure solution, dites-le-moi en commentaire.
Fonction Loop
Dans la fonction loop(), on vérifie en continu si l’horloge doit être synchronisée avec le fournisseur de temps sur Internet en appelant la fonction should_sync_time(). Si une synchronisation est nécessaire, on appelle la fonction sync_time() pour mettre à jour l’horloge. Ensuite, on appelle la fonction lcd_print_time() pour afficher l’heure actuelle sur l’écran LCD. On ajoute un petit délai de 100 millisecondes avec la fonction delay() pour éviter les mises à jour excessives.
void loop() {
if (should_sync_time())
sync_time();
lcd_print_time();
delay(100);
}
Voilà ! Avec ce code, on a une horloge numérique qui s’ajuste automatiquement à l’heure d’été et aux différents fuseaux horaires en se synchronisant via WiFi avec un fournisseur de temps sur Internet. L’heure actuelle est affichée sur un écran LCD et l’horloge se synchronise périodiquement.
Extensions
Il y a plein de possibilités d’extensions pour ce projet. En plus de l’heure et de la date, on pourrait afficher le fuseau horaire, l’écart de fuseau et si l’heure d’été est active ou non. Évidemment, un bip horaire ou une fonction alarme serait aussi sympa.
Selon votre pays, vous préférerez peut-être afficher l’heure au format AM/PM plutôt qu’en 24h, ou pour plusieurs fuseaux horaires. Afficher le nom du jour de la semaine ou du mois serait aussi facile à ajouter.
On n’est pas limité aux fournisseurs de temps sur Internet. Toute information disponible en ligne, comme la météo, les cours de la bourse ou les actualités, pourrait être affichée en plus de l’heure. Il suffit d’une autre requête HTTP avec des données à analyser.
Enfin, puisque l’on se connecte à Internet à intervalles réguliers, on pourrait en profiter pour surveiller la vitesse de connexion ou la perte de connectivité.
Conclusion
Dans ce tutoriel, nous avons appris à construire une horloge numérique qui s’ajuste automatiquement à l’heure d’été et aux différents fuseaux horaires. En synchronisant l’horloge via WiFi avec un fournisseur de temps sur Internet, on s’assure qu’elle affiche toujours l’heure exacte.
Nous avons commencé par discuter des composants nécessaires pour ce projet, qui incluent une carte ESP32 avec WiFi et un écran LCD. Nous avons ensuite expliqué comment connecter ces éléments pour créer l’horloge.
Ensuite, nous avons abordé le concept de l’heure d’été et son importance pour ajuster l’horloge lors des changements saisonniers. Nous avons vu comment gérer l’heure d’été dans notre code pour que l’horloge se mette à jour correctement.
Pour synchroniser notre horloge avec un fournisseur de temps sur Internet, nous avons utilisé des techniques d’analyse JSON pour extraire l’heure depuis l’API du fournisseur. Nous avons aussi appris à manipuler les chaînes datetime pour convertir et afficher l’heure sur l’écran LCD.
Si vous voulez un écran plus grand, plus joli et tactile pour votre horloge, jetez un œil au tutoriel Digital Clock with CrowPanel 3.5″ ESP32 Display. Et si vous voulez afficher l’heure de façon plus originale, vous pouvez utiliser ce code pour construire une horloge à anneau LED comme décrit dans ce tutoriel : LED Ring Clock with WS2812.
Si vous avez d’autres questions ou besoin d’aide supplémentaire, consultez la section Foire Aux Questions ou visitez les liens fournis pour plus de ressources et d’informations.
Foire Aux Questions
Voici quelques questions fréquemment posées sur la construction d’une horloge numérique qui s’ajuste automatiquement à l’heure d’été et aux différents fuseaux horaires :
Q : Puis-je utiliser n’importe quelle carte avec WiFi pour ce projet ?
R : Oui, vous pouvez utiliser n’importe quelle carte microcontrôleur qui a le WiFi ou peut être équipée d’un shield WiFi. Parmi les options populaires, on trouve les modules ESP8266 et ESP32, qui ont le WiFi intégré.
Q : Comment l’horloge s’ajuste-t-elle à l’heure d’été ?
R : L’horloge s’ajuste à l’heure d’été en se synchronisant avec un fournisseur de temps sur Internet. Ces fournisseurs donnent une heure précise, incluant le fuseau horaire actuel et si l’heure d’été est active. En analysant ces informations et en ajustant l’horloge en conséquence, vous pouvez être sûr que votre horloge affiche toujours la bonne heure.
Q : Ai-je besoin d’un écran LCD pour ce projet ?
R : Un écran LCD n’est pas obligatoire, mais il est recommandé pour ce projet car il permet de voir l’heure facilement. Cependant, si vous préférez, vous pouvez aussi afficher l’heure sur un moniteur série ou tout autre dispositif de sortie de votre choix.
Q : Puis-je personnaliser le code pour ajouter d’autres fonctionnalités ?
R : Bien sûr ! Le code fourni est un point de départ, et vous pouvez le personnaliser pour ajouter des fonctionnalités ou modifier son comportement selon vos besoins. Par exemple, vous pouvez ajouter la gestion de plusieurs fuseaux horaires, afficher des informations supplémentaires, ou intégrer d’autres capteurs ou modules au projet.
Q : Y a-t-il des limitations à utiliser un fournisseur de temps sur Internet ?
R : Utiliser un fournisseur de temps sur Internet est pratique pour synchroniser votre horloge, mais cela dépend d’une connexion Internet. Si votre horloge ne peut pas se connecter, elle risque de ne pas mettre l’heure à jour correctement. De plus, si le fournisseur rencontre des problèmes ou des interruptions, cela peut aussi affecter la précision de votre horloge.
Liens
Voici quelques liens utiles vers des projets similaires :
- 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
