Programmateur guirlande Noël ESP32 : allumée au coucher du soleil
Programmateur de guirlande de Noël ESP32 : NTP et position donnent le coucher du soleil, un relais allume et éteint à minuit. Tableau des villes, contrôle web.
Le grand avantage d'un ESP32 comme programmateur de guirlande de Noël, c'est qu'il allume les lumières quand le soleil se couche vraiment chez toi, et non à heure fixe. L'ESP32 se connecte au Wi-Fi, récupère l'heure sur Internet par NTP, calcule le lever et le coucher du soleil du jour à partir de la latitude et de la longitude que tu lui donnes, allume la guirlande avec un module relais et l'éteint tout seul à minuit. En plus, une petite page web sur ton téléphone te permet d'allumer et d'éteindre à la main, et le mode choisi est mémorisé même après une coupure de courant.
Dans ce guide, on montre d'abord pourquoi le coucher du soleil se décale chaque jour et à quel point il varie d'une ville à l'autre, puis on explique pas à pas la formule du calcul. Viennent ensuite deux sketches : le premier écrit simplement le lever et le coucher du soleil du jour dans le moniteur série, le second est un programmateur complet avec relais, extinction à minuit et contrôle web. La dernière partie traite de la sécurité en extérieur et des erreurs courantes. Pour revoir les bases du NTP, jette un œil à horloge NTP avec ESP32.

Pourquoi le coucher du soleil plutôt qu'une heure fixe ?
Un programmateur de prise mécanique ou numérique s'allume chaque soir à la même heure, alors que le coucher du soleil bouge pendant toute la saison. À Paris, le soleil se couche à 17:32 le 1er novembre, à 16:57 le 1er décembre et à 17:44 le 31 janvier, soit près de 50 minutes d'écart pendant la période des fêtes. Un réglage fixe à 17:00 allume les lumières en plein jour début novembre et fin janvier ; si tu le passes à 17:20, elles s'allument à la mi-décembre près d'une demi-heure après la tombée de la nuit. Le lieu compte aussi beaucoup : le 21 décembre, le soleil se couche à 15:53 à Berlin et à 17:51 à Madrid, alors que les deux villes partagent le même fuseau horaire. Le tableau donne les couchers de soleil calculés avec la même formule que le code ; ils diffèrent en général d'une ou deux minutes des valeurs officielles.
| Ville | Latitude, longitude | 1er déc. | 10 déc. | 21 déc. | 31 déc. |
|---|---|---|---|---|---|
| Istanbul | 41,01 / 28,98 | 17:37 | 17:36 | 17:38 | 17:44 |
| Ankara | 39,93 / 32,86 | 17:25 | 17:23 | 17:26 | 17:32 |
| Izmir | 38,42 / 27,14 | 17:51 | 17:51 | 17:53 | 17:59 |
| Londres | 51,51 / -0,13 | 15:56 | 15:52 | 15:53 | 15:59 |
| Berlin | 52,52 / 13,41 | 15:57 | 15:53 | 15:53 | 16:00 |
| Munich | 48,14 / 11,58 | 16:23 | 16:20 | 16:22 | 16:28 |
| Vienne | 48,21 / 16,37 | 16:04 | 16:01 | 16:02 | 16:08 |
| Madrid | 40,42 / -3,70 | 17:49 | 17:48 | 17:51 | 17:57 |
| Paris | 48,86 / 2,35 | 16:57 | 16:54 | 16:55 | 17:02 |
| Rome | 41,90 / 12,50 | 16:40 | 16:39 | 16:41 | 16:47 |
| Milan | 45,46 / 9,19 | 16:42 | 16:40 | 16:42 | 16:48 |
| New York | 40,71 / -74,01 | 16:30 | 16:28 | 16:31 | 16:37 |
| Mexico | 19,43 / -99,13 | 17:57 | 17:59 | 18:03 | 18:08 |
Le tableau cache un détail intéressant : même si le 21 décembre est le jour le plus court, le coucher du soleil le plus précoce arrive une dizaine de jours plus tôt, dans la première quinzaine de décembre. La raison est l'équation du temps : l'orbite de la Terre n'est pas un cercle parfait et son axe est incliné, si bien qu'en décembre le soleil atteint son point le plus haut environ 30 secondes plus tard chaque jour. Le coucher du soleil est repoussé d'autant, tandis que le matin le soleil se lève de plus en plus tard jusqu'au début janvier. Un programmateur à heure fixe ne peut jamais suivre cette subtilité ; la formule en tient compte toute seule.
Comment calcule-t-on le coucher du soleil ?
Le code utilise les formules solaires approchées publiées par l'agence américaine d'observation océanique et atmosphérique (NOAA). Le calcul n'a besoin que du jour de l'année, de la latitude et de la longitude ; il ne télécharge aucune donnée supplémentaire. Le résultat est en minutes UTC, que le code convertit en heure locale grâce au réglage de fuseau horaire : il reste donc juste dans les pays à heure d'été. Sous 60° de latitude, la formule est précise à une ou deux minutes ; dans les régions polaires, quand le soleil ne se couche pas ou ne se lève pas de la journée, l'arc cosinus n'est pas défini et le code le vérifie à part.
| Étape | Formule | Explication |
|---|---|---|
| 1. Fraction de l'année | γ = 2π / 365 × (jour − 1) | Convertit le jour de l'année en radians |
| 2. Équation du temps | eqtime = 229,18 × (0,000075 + 0,001868 cos γ − 0,032077 sin γ − 0,014615 cos 2γ − 0,040849 sin 2γ) | Écart entre l'heure solaire et l'heure de la montre, d'environ −14 à +16 min sur l'année |
| 3. Déclinaison solaire | δ = 0,006918 − 0,399912 cos γ + 0,070257 sin γ − ... | Environ −23,44° autour du 21 décembre |
| 4. Angle horaire | ha = arccos(cos 90,833° / (cos φ cos δ) − tan φ tan δ) | 90,833° : réfraction à l'horizon (0,567°) + rayon du soleil (0,267°) |
| 5. Coucher du soleil | 720 − 4 × (longitude − ha) − eqtime | Minutes UTC ; chaque degré de longitude vaut 4 minutes |
Matériel
- Carte de développement ESP32 (30 ou 38 broches, peu importe)
- Module relais 1 canal : avec optocoupleur, contacts 10 A 250 V AC ; ou un relais statique (SSR) silencieux
- Chargeur USB 5 V 1–2 A et câble USB pour l'ESP32
- Guirlande : de préférence une guirlande LED d'extérieur basse tension (5–31 V) avec son propre adaptateur
- Boîte de dérivation IP65, presse-étoupes et borniers
- Quelques fils de liaison
Câblage : ESP32 et module relais
| Module relais | ESP32 | Remarque |
|---|---|---|
| VCC | VIN (5 V) | La bobine du relais demande 5 V ; la broche VIN alimentée par USB suffit |
| GND | GND | Masse commune |
| IN | GPIO 26 | RELAY_PIN dans le code ; la plupart des modules s'activent à LOW |
| COM | Sortie + de l'adaptateur de la guirlande | Entrée de la ligne commutée |
| NO (normalement ouvert) | Entrée + de la guirlande | Le circuit se ferme quand le relais colle |
| NC (normalement fermé) | Libre | Non utilisé |
Étape 1 : afficher le coucher du soleil du jour dans le moniteur série
- Dans l'Arduino IDE, installe le paquet esp32 depuis le gestionnaire de cartes et choisis ESP32 Dev Module comme carte.
- Dans le code ci-dessous, indique le nom et le mot de passe de ton réseau dans WIFI_SSID et WIFI_PASS.
- Modifie LATITUDE et LONGITUDE selon ta ville ; les longitudes ouest et les latitudes sud sont négatives.
- Hors de Turquie, choisis la ligne TZ_INFO dans le tableau des fuseaux horaires plus bas ; pour la France, c'est "CET-1CEST,M3.5.0,M10.5.0/3".
- Téléverse le code, ouvre le moniteur série à 115200 bauds et compare les heures affichées avec le tableau.
1// ESP32: NTP saati + bugünün gün doğumu/batımı (Seri Monitör)
2// ESP32: NTP time + today's sunrise/sunset (Serial Monitor)
3#include <WiFi.h>
4#include <time.h>
5#include <math.h>
6
7const char* WIFI_SSID = "AgAdi"; // Wi-Fi adı / Wi-Fi name
8const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifresi / Wi-Fi password
9const char* TZ_INFO = "<+03>-3"; // Türkiye UTC+3 / Turkey UTC+3
10const double LATITUDE = 41.01; // İstanbul enlemi (kuzey +) / latitude (north +)
11const double LONGITUDE = 28.98; // İstanbul boylamı (doğu +) / longitude (east +)
12
13// NOAA yaklaşık formülü, sonuç UTC dakika / NOAA approximation, result in UTC minutes
14bool sunTimesUtc(int yday, int year, double &riseUtc, double &setUtc) {
15 int daysInYear = ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) ? 366 : 365;
16 double g = 2.0 * PI / daysInYear * yday; // yılın kesri (radyan) / fractional year (rad)
17 double eqTime = 229.18 * (0.000075 + 0.001868 * cos(g) - 0.032077 * sin(g)
18 - 0.014615 * cos(2 * g) - 0.040849 * sin(2 * g)); // zaman denklemi (dk) / equation of time (min)
19 double decl = 0.006918 - 0.399912 * cos(g) + 0.070257 * sin(g) - 0.006758 * cos(2 * g)
20 + 0.000907 * sin(2 * g) - 0.002697 * cos(3 * g) + 0.00148 * sin(3 * g); // eğim (rad) / declination (rad)
21 double lat = LATITUDE * DEG_TO_RAD;
22 double x = cos(90.833 * DEG_TO_RAD) / (cos(lat) * cos(decl)) - tan(lat) * tan(decl);
23 if (x < -1.0 || x > 1.0) return false; // kutup gecesi ya da gündüzü / polar night or day
24 double ha = acos(x) * RAD_TO_DEG; // saat açısı (derece) / hour angle (degrees)
25 riseUtc = 720 - 4 * (LONGITUDE + ha) - eqTime;
26 setUtc = 720 - 4 * (LONGITUDE - ha) - eqTime;
27 return true;
28}
29
30void setup() {
31 Serial.begin(115200);
32 WiFi.begin(WIFI_SSID, WIFI_PASS);
33 while (WiFi.status() != WL_CONNECTED) {
34 delay(500);
35 Serial.print(".");
36 }
37 configTzTime(TZ_INFO, "pool.ntp.org", "time.cloudflare.com");
38 struct tm now;
39 while (!getLocalTime(&now)) {
40 Serial.println("NTP bekleniyor / waiting for NTP");
41 }
42
43 struct tm noon = now; // yerel öğle: günün UTC tarihini bulmak için / local noon to find today's UTC date
44 noon.tm_hour = 12; noon.tm_min = 0; noon.tm_sec = 0; noon.tm_isdst = -1;
45 time_t noonT = mktime(&noon);
46 time_t utcMidnight = noonT - (noonT % 86400);
47
48 double riseUtc, setUtc;
49 if (sunTimesUtc(now.tm_yday, now.tm_year + 1900, riseUtc, setUtc)) {
50 time_t riseT = utcMidnight + (time_t)(riseUtc * 60);
51 time_t setT = utcMidnight + (time_t)(setUtc * 60);
52 struct tm r, s;
53 localtime_r(&riseT, &r);
54 localtime_r(&setT, &s);
55 Serial.printf("Bugun / today: %02d.%02d.%d\n", now.tm_mday, now.tm_mon + 1, now.tm_year + 1900);
56 Serial.printf("Gun dogumu / sunrise: %02d:%02d\n", r.tm_hour, r.tm_min);
57 Serial.printf("Gun batimi / sunset: %02d:%02d\n", s.tm_hour, s.tm_min);
58 }
59}
60
61void loop() {
62}La partie la plus délicate du code est la conversion entre UTC et heure locale. La formule donne le coucher du soleil en minutes depuis le minuit UTC du jour. Le code convertit d'abord le midi local d'aujourd'hui en horodatage avec mktime(), puis soustrait le reste de la division par 86400 pour obtenir le minuit UTC de la même date. On y ajoute les minutes du coucher du soleil et localtime_r() convertit le résultat dans ton fuseau horaire. Partir de midi évite de calculer le mauvais jour pendant les heures de nuit où la date UTC et la date locale diffèrent.
Étape 2 : le code complet avec relais, extinction à minuit et contrôle web
Le second sketch transforme le calcul du coucher du soleil en programmateur. Toutes les 10 secondes, il vérifie l'heure ; si le jour a changé, il recalcule le lever et le coucher du soleil, et en mode automatique il décide si les lumières doivent être allumées. La bibliothèque intégrée WebServer sert une petite page sur le port 80 : en ouvrant l'adresse IP de l'ESP32 dans un navigateur, tu vois l'état des lumières, le lever et le coucher du soleil du jour et les liens AUTO, ON et OFF. Le mode choisi est enregistré en flash avec Preferences : après une coupure de courant, le programmateur reprend dans le même mode.
1// ESP32 Noel ışıkları zamanlayıcısı: gün batımında aç, gece yarısı kapat, web'den elle kontrol
2// ESP32 Christmas lights timer: on at sunset, off at midnight, manual control from the web
3#include <WiFi.h>
4#include <WebServer.h>
5#include <Preferences.h>
6#include <time.h>
7#include <math.h>
8
9const char* WIFI_SSID = "AgAdi"; // Wi-Fi adı / Wi-Fi name
10const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifresi / Wi-Fi password
11const char* TZ_INFO = "<+03>-3"; // Türkiye / Turkey. Berlin, Paris, Roma, Madrid: "CET-1CEST,M3.5.0,M10.5.0/3"
12const double LATITUDE = 41.01; // enlem (kuzey +) / latitude (north +)
13const double LONGITUDE = 28.98; // boylam (doğu +, batı -) / longitude (east +, west -)
14
15const int RELAY_PIN = 26; // röle modülü IN / relay module IN
16const bool RELAY_ACTIVE_LOW = true; // çoğu modül LOW ile çeker / most modules switch on LOW
17const int SUNSET_OFFSET_MIN = 0; // gün batımına göre kayma (dk), -15 = 15 dk önce / shift from sunset (min)
18const int OFF_MINUTE = 24 * 60; // kapanış: 24:00 = gece yarısı, 23:30 için 23*60+30 / off time
19const int MORNING_ON_MINUTE = -1; // sabah açılış, ör. 6*60+30; -1 = kapalı / morning on, e.g. 6:30; -1 = off
20
21enum Mode : uint8_t { MODE_AUTO, MODE_ON, MODE_OFF };
22Mode mode = MODE_AUTO;
23bool lightsOn = false;
24int sunriseMin = -1, sunsetMin = -1; // bugünün yerel dakikası / today's local minute of day
25int lastYday = -1;
26unsigned long lastCheck = 0;
27
28WebServer server(80);
29Preferences prefs;
30
31bool sunTimesUtc(int yday, int year, double &riseUtc, double &setUtc) {
32 int daysInYear = ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) ? 366 : 365;
33 double g = 2.0 * PI / daysInYear * yday;
34 double eqTime = 229.18 * (0.000075 + 0.001868 * cos(g) - 0.032077 * sin(g)
35 - 0.014615 * cos(2 * g) - 0.040849 * sin(2 * g));
36 double decl = 0.006918 - 0.399912 * cos(g) + 0.070257 * sin(g) - 0.006758 * cos(2 * g)
37 + 0.000907 * sin(2 * g) - 0.002697 * cos(3 * g) + 0.00148 * sin(3 * g);
38 double lat = LATITUDE * DEG_TO_RAD;
39 double x = cos(90.833 * DEG_TO_RAD) / (cos(lat) * cos(decl)) - tan(lat) * tan(decl);
40 if (x < -1.0 || x > 1.0) return false;
41 double ha = acos(x) * RAD_TO_DEG;
42 riseUtc = 720 - 4 * (LONGITUDE + ha) - eqTime;
43 setUtc = 720 - 4 * (LONGITUDE - ha) - eqTime;
44 return true;
45}
46
47int toLocalMinute(time_t utcMidnight, double utcMinutes) {
48 time_t t = utcMidnight + (time_t)(utcMinutes * 60);
49 struct tm lt;
50 localtime_r(&t, <);
51 return lt.tm_hour * 60 + lt.tm_min;
52}
53
54void updateSunTimes(struct tm now) { // günde bir kez / once a day
55 now.tm_hour = 12; now.tm_min = 0; now.tm_sec = 0; now.tm_isdst = -1;
56 time_t noonT = mktime(&now);
57 time_t utcMidnight = noonT - (noonT % 86400);
58 double r, s;
59 if (sunTimesUtc(now.tm_yday, now.tm_year + 1900, r, s)) {
60 sunriseMin = toLocalMinute(utcMidnight, r);
61 sunsetMin = toLocalMinute(utcMidnight, s);
62 }
63 lastYday = now.tm_yday;
64 Serial.printf("Gun dogumu %02d:%02d, gun batimi %02d:%02d\n", sunriseMin / 60, sunriseMin % 60, sunsetMin / 60, sunsetMin % 60);
65}
66
67void setRelay(bool on) {
68 lightsOn = on;
69 digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
70}
71
72bool autoWantsOn(int nowMin) {
73 if (sunsetMin < 0) return false;
74 if (nowMin >= sunsetMin + SUNSET_OFFSET_MIN && nowMin < OFF_MINUTE) return true; // akşam / evening
75 if (MORNING_ON_MINUTE >= 0 && nowMin >= MORNING_ON_MINUTE && nowMin < sunriseMin) return true; // sabah / morning
76 return false;
77}
78
79void applyState() {
80 struct tm now;
81 if (!getLocalTime(&now, 10)) { // saat henüz yok / no time yet
82 setRelay(mode == MODE_ON);
83 return;
84 }
85 if (now.tm_yday != lastYday) updateSunTimes(now);
86 int nowMin = now.tm_hour * 60 + now.tm_min;
87 bool on = (mode == MODE_ON) || (mode == MODE_AUTO && autoWantsOn(nowMin));
88 if (on != lightsOn) {
89 setRelay(on);
90 Serial.printf("%02d:%02d isiklar %s\n", now.tm_hour, now.tm_min, on ? "ACIK / on" : "KAPALI / off");
91 }
92}
93
94String hhmm(int m) {
95 if (m < 0) return "--:--";
96 char buf[12];
97 snprintf(buf, sizeof(buf), "%02d:%02d", m / 60, m % 60);
98 return String(buf);
99}
100
101void handleRoot() {
102 String html = F("<!DOCTYPE html><html><head><meta charset='utf-8'>"
103 "<meta name='viewport' content='width=device-width,initial-scale=1'>"
104 "<title>Noel</title></head><body style='font-family:sans-serif;text-align:center'>");
105 html += "<h2>" + String(lightsOn ? "ON" : "OFF") + "</h2>";
106 html += "<p>Sunrise " + hhmm(sunriseMin) + " | Sunset " + hhmm(sunsetMin) + "</p>";
107 html += "<p>Mode: " + String(mode == MODE_AUTO ? "AUTO" : (mode == MODE_ON ? "ON" : "OFF")) + "</p>";
108 html += F("<p><a href='/mode?m=auto'>AUTO</a> | <a href='/mode?m=on'>ON</a> | <a href='/mode?m=off'>OFF</a></p></body></html>");
109 server.send(200, "text/html", html);
110}
111
112void handleMode() {
113 String m = server.arg("m");
114 mode = (m == "on") ? MODE_ON : (m == "off") ? MODE_OFF : MODE_AUTO;
115 prefs.putUChar("mode", mode); // elektrik kesilse de hatırla / remember after a power cut
116 applyState();
117 server.sendHeader("Location", "/");
118 server.send(303);
119}
120
121void setup() {
122 digitalWrite(RELAY_PIN, RELAY_ACTIVE_LOW ? HIGH : LOW); // açılışta kapalı başla / start switched off
123 pinMode(RELAY_PIN, OUTPUT);
124 Serial.begin(115200);
125
126 prefs.begin("noel", false);
127 mode = (Mode)prefs.getUChar("mode", MODE_AUTO);
128
129 WiFi.mode(WIFI_STA);
130 WiFi.begin(WIFI_SSID, WIFI_PASS);
131 unsigned long start = millis();
132 while (WiFi.status() != WL_CONNECTED && millis() - start < 20000) delay(500);
133 Serial.print("IP: ");
134 Serial.println(WiFi.localIP());
135
136 configTzTime(TZ_INFO, "pool.ntp.org", "time.cloudflare.com");
137 server.on("/", handleRoot);
138 server.on("/mode", handleMode);
139 server.begin();
140}
141
142void loop() {
143 server.handleClient();
144 if (millis() - lastCheck > 10000) { // 10 sn'de bir kontrol / check every 10 s
145 lastCheck = millis();
146 applyState();
147 }
148}Réglages
| Réglage | Valeur par défaut | À quoi ça sert ? |
|---|---|---|
| TZ_INFO | "<+03>-3" | Fuseau horaire et règle d'heure d'été (format POSIX) |
| LATITUDE / LONGITUDE | 41.01 / 28.98 | Position ; longitude ouest et latitude sud négatives |
| RELAY_PIN | 26 | Broche reliée à IN du module relais |
| RELAY_ACTIVE_LOW | true | true si le module s'active à LOW, false s'il s'active à HIGH |
| SUNSET_OFFSET_MIN | 0 | Décalage par rapport au coucher du soleil ; −15 allume 15 min plus tôt |
| OFF_MINUTE | 24 * 60 | Heure d'extinction ; pour 23:30, mets 23 * 60 + 30 |
| MORNING_ON_MINUTE | -1 | Allumage du matin ; avec 6 * 60 + 30, les lumières brillent de 06:30 au lever du soleil |
Comment fonctionne le code ?
C'est dans applyState() que la décision est prise. Tant que l'heure n'est pas reçue, les lumières ne s'allument qu'en mode ON ; cela évite qu'elles s'allument au mauvais moment avant que le Wi-Fi soit là. Une fois l'heure valide, la minute de la journée est calculée et deux conditions sont testées : la fenêtre du soir va du coucher du soleil à l'heure d'extinction, la fenêtre facultative du matin de l'heure d'allumage au lever du soleil. Le relais ne commute que lorsque l'état change, et chaque changement s'affiche dans le moniteur série, ce qui facilite le dépannage. setRelay() écrit le bon niveau sur la broche selon RELAY_ACTIVE_LOW. Dans setup(), la broche est mise au niveau éteint avant d'être déclarée en sortie ; cet ordre empêche le relais de coller un instant au démarrage. Si le Wi-Fi tombe, l'ESP32 continue sur son horloge interne et le NTP corrige l'heure dès que la connexion revient.
| Région | TZ_INFO |
|---|---|
| Turquie | <+03>-3 |
| Allemagne, Autriche, Italie, France, Espagne | CET-1CEST,M3.5.0,M10.5.0/3 |
| Royaume-Uni, Irlande, Portugal | GMT0BST,M3.5.0/1,M10.5.0 |
| Côte est des États-Unis (New York) | EST5EDT,M3.2.0,M11.1.0 |
| Mexique (Mexico) | CST6 |
Sécurité en extérieur
- Privilégie la basse tension : avec des guirlandes LED 5–31 V livrées avec leur adaptateur, place le relais sur la sortie basse tension de l'adaptateur et tu ne touches jamais au secteur.
- Boîtier et presse-étoupes : mets l'ESP32 et le relais dans un boîtier IP65, fais passer les câbles par des presse-étoupes et fixe le boîtier entrées de câbles vers le bas pour que l'eau ne s'y infiltre pas.
- Calcul du courant : une guirlande typique de 200 LED consomme 10 à 20 W, soit moins de 0,1 A en 230 V. Tu n'approcheras pas les 10 A du relais, mais sur les modules bon marché la vraie limite est inférieure à l'indication ; garde donc la charge totale sous quelques ampères.
- Condensation : les nuits d'hiver, l'humidité peut condenser dans le boîtier ; ajoute un petit sachet de gel de silice et fixe l'électronique en haut du boîtier plutôt qu'au fond.
- Pas de charges inductives : utilise ce programmateur uniquement pour l'éclairage ; le courant d'appel des moteurs, radiateurs ou compresseurs peut souder les contacts du relais en peu de temps.
Erreurs fréquentes et solutions
| Problème | Cause | Solution |
|---|---|---|
| "En attente du NTP" ne finit jamais dans le moniteur série | Wi-Fi non connecté ou port NTP bloqué | Vérifie le nom du réseau et le mot de passe, rapproche l'ESP32 de la box |
| Coucher du soleil décalé d'une heure pile | TZ_INFO incorrect ou règle d'heure d'été absente | Utilise la bonne chaîne POSIX du tableau |
| Coucher du soleil décalé de plusieurs heures | Signe de la longitude faux ou latitude et longitude inversées | Saisis la longitude ouest en négatif et vérifie l'ordre |
| Le relais ne retombe jamais | Le module 5 V ne se coupe pas complètement avec un HIGH à 3,3 V | Sépare JD-VCC, utilise un module 3,3 V ou un transistor |
| Les lumières clignotent au démarrage | Broche de démarrage ou ordre de pinMode | Choisis une broche sûre comme GPIO 26, digitalWrite d'abord puis pinMode |
| La page web ne s'ouvre pas | L'adresse IP a changé | Fais une réservation DHCP dans la box ou utilise mDNS |
| Les lumières restent allumées après minuit | Mode resté sur ON | Repasse en AUTO depuis la page web |
Idées de projets avec ce programmateur
- Capteur de lumière de secours : si le Wi-Fi reste coupé longtemps, détecte l'obscurité avec une LDR et allume quand même les lumières.
- Domotique : publie l'état du relais en MQTT et pilote-le depuis un tableau de bord Home Assistant.
- Programmation multicanal : avec une carte 4 relais, donne des heures d'extinction différentes aux lumières du balcon, du jardin et de la fenêtre.
- Effet coucher de soleil : utilise un ruban WS2812B au lieu du relais et fais monter les couleurs doucement jusqu'au blanc chaud au coucher du soleil ; le montage du ruban est dans guirlande LED pour sapin.
- Autres projets de saison : pour des idées qui complètent ce programmateur, consulte la liste des projets Arduino de Noël.
Si tu veux apprendre les briques de ce programmateur une par une, regarde dans l'application BlueGrays les projets d'heure réelle par NTP avec ESP32, de serveur web asynchrone ESP32 et d'éclairage intelligent ESP32 ; chacun fournit schéma, liste de câblage et code expliqué pas à pas. Combine ces briques avec le calcul du coucher du soleil de cet article, et tes lumières de Noël s'allumeront toutes seules, pile à l'heure, chaque soir.
Questions fréquentes
Comment allumer automatiquement une guirlande de Noël au coucher du soleil ?
La méthode la plus précise consiste à utiliser une carte Wi-Fi comme l'ESP32 pour obtenir l'heure par NTP et calculer le coucher du soleil du jour à partir de la latitude et de la longitude. À cette heure-là, la carte fait coller un relais qui allume les lumières, puis les éteint à l'heure choisie. Plus simple, un interrupteur crépusculaire à LDR fonctionne aussi, mais les nuages et l'éclairage public peuvent le tromper.
L'ESP32 récupère-t-il l'heure du coucher du soleil sur Internet ?
Non, il ne récupère sur Internet que l'heure, par NTP. Il calcule lui-même le coucher du soleil avec les formules de la NOAA, qui n'ont besoin que du jour de l'année, de la latitude et de la longitude. Aucun service météo ni clé d'API n'est donc nécessaire.
Le programmateur continue-t-il de fonctionner sans Internet ?
Oui. Une fois l'heure obtenue, l'ESP32 continue de compter avec son horloge interne et la dérive reste en général de quelques secondes par jour. Quand la connexion revient, le NTP corrige l'heure. En revanche, si l'ESP32 redémarre, le mode automatique n'allume pas les lumières tant qu'il n'a pas récupéré l'heure.
Un module relais fonctionne-t-il avec les 3,3 V de l'ESP32 ?
La plupart des modules relais 5 V se déclenchent avec un signal de 3,3 V, mais certains modules à optocoupleur actifs à LOW ne retombent pas complètement avec un HIGH à 3,3 V. Dans ce cas, retirer le cavalier JD-VCC et alimenter le module à part, prendre un module à commande 3,3 V ou ajouter un transistor NPN règle le problème.
Quel relais choisir pour des guirlandes de Noël d'extérieur ?
Pour l'éclairage, un module relais mécanique à optocoupleur avec des contacts 10 A 250 V AC suffit ; si le clic te dérange, prends un relais statique (SSR). Dans tous les cas, place la carte dans un boîtier étanche et alimente le côté secteur par une ligne protégée par un différentiel.
Peut-on allumer avant ou après le coucher du soleil ?
Oui. SUNSET_OFFSET_MIN dans le code fixe le décalage en minutes : −15 allume les lumières 15 minutes avant le coucher du soleil, 20 les allume 20 minutes après. Comme le crépuscule dure environ 30 minutes, un décalage positif de 10 à 20 minutes donne souvent le plus bel effet.
Projets à réaliser après cet article
Voir tous les projets
ESP32 : heure réelle depuis Internet via NTP
L'ESP32 se connecte au Wi-Fi et récupère l'heure exacte auprès de serveurs NTP (Network Time Protocol) à la milliseconde près. Avec configTzTime(), le fuseau horaire de la Turquie (TRT, UTC+3) s'applique automatiquement, et dans les pays à heure d'été, le changement (DST) est géré tout seul par une chaîne POSIX TZ. L'heure s'affiche dans le Serial Monitor et sur un LCD I2C en option.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
Avec un ESP32, un capteur de mouvement PIR, un capteur de lumière LDR et un module relais, on transforme ton couloir, tes toilettes ou ton cellier en éclairage intelligent. Si la pièce est déjà claire, la lumière reste éteinte malgré le mouvement : pas de gaspillage d'énergie en journée. La lumière reste allumée 30 secondes et la durée se prolonge automatiquement tant que le mouvement continue.

Veilleuse ESP32 avec LDR
Veilleuse dans laquelle la LED s'allume automatiquement dans l'obscurité et s'éteint à la lumière. La broche D0 (sortie numérique) du module capteur LDR est utilisée - le seuil d'obscurité est réglé avec le petit potentiomètre sur le module, le module lui-même génère la sortie HAUT/BAS. L'ESP32 lit simplement ce signal avec digitalRead(), le code est très simple.

Contrôle d'une bande NeoPixel WS2812B avec l'ESP32
Les LED adressables WS2812B (NeoPixel) sont des LED RGB intelligentes chaînées et pilotées par une seule broche de données. On pilote un ruban WS2812B de 8 LED avec la bibliothèque Adafruit_NeoPixel pour créer un arc-en-ciel fluide. La logique 3,3 V de l'ESP32 convient à la plupart des WS2812B ; en cas d'instabilité, on montre la solution : résistance série de 470Ω et condensateur de 1000µF. L'animation fait glisser la teinte dans l'espace HSV.

Connexion Wi-Fi STA ESP32 (avec écran LCD)
Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

ESP32 mDNS : accès à l'appareil via bluegrays-esp.local (avec écran LCD)
Dans ce projet, en ajoutant un service mDNS (Multicast DNS) à l'ESP32, nous permettons d'accéder à l'appareil via un nom d'hôte lisible, tel que bluegrays-esp.local, plutôt qu'à l'aide d'une adresse IP. Même si l'adresse IP attribuée par le DHCP venait à changer, vous pourrez toujours accéder à l'appareil sous le même nom. En exécutant également un petit serveur web sur l'appareil, nous envoyons des commandes de contrôle des LED depuis un navigateur via l'adresse http://bluegrays-esp.local/.

Ampoule 220V avec bouton poussoir (Push)
Tant que tu appuies sur le bouton, une vraie ampoule de 220 volts reste allumée, et elle s'éteint dès que tu relâches.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

