Guides · 9 min de lecture

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.

Module relais pour un programmateur de guirlande de Noël ESP32
Module relais : l'interrupteur qui coupe et rétablit l'alimentation de la guirlande à partir du signal 3,3 V de l'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.

VilleLatitude, longitude1er déc.10 déc.21 déc.31 déc.
Istanbul41,01 / 28,9817:3717:3617:3817:44
Ankara39,93 / 32,8617:2517:2317:2617:32
Izmir38,42 / 27,1417:5117:5117:5317:59
Londres51,51 / -0,1315:5615:5215:5315:59
Berlin52,52 / 13,4115:5715:5315:5316:00
Munich48,14 / 11,5816:2316:2016:2216:28
Vienne48,21 / 16,3716:0416:0116:0216:08
Madrid40,42 / -3,7017:4917:4817:5117:57
Paris48,86 / 2,3516:5716:5416:5517:02
Rome41,90 / 12,5016:4016:3916:4116:47
Milan45,46 / 9,1916:4216:4016:4216:48
New York40,71 / -74,0116:3016:2816:3116:37
Mexico19,43 / -99,1317:5717:5918:0318: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.

ÉtapeFormuleExplication
1. Fraction de l'annéeγ = 2π / 365 × (jour − 1)Convertit le jour de l'année en radians
2. Équation du tempseqtime = 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 horaireha = arccos(cos 90,833° / (cos φ cos δ) − tan φ tan δ)90,833° : réfraction à l'horizon (0,567°) + rayon du soleil (0,267°)
5. Coucher du soleil720 − 4 × (longitude − ha) − eqtimeMinutes 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 relaisESP32Remarque
VCCVIN (5 V)La bobine du relais demande 5 V ; la broche VIN alimentée par USB suffit
GNDGNDMasse commune
INGPIO 26RELAY_PIN dans le code ; la plupart des modules s'activent à LOW
COMSortie + de l'adaptateur de la guirlandeEntrée de la ligne commutée
NO (normalement ouvert)Entrée + de la guirlandeLe circuit se ferme quand le relais colle
NC (normalement fermé)LibreNon utilisé
Il existe un piège classique avec les modules relais 5 V à optocoupleur qui s'activent à LOW : comme le niveau HIGH de l'ESP32 n'est que de 3,3 V, la LED de l'optocoupleur peut ne pas s'éteindre complètement et le relais ne retombe jamais. Dans ce cas, retire le cavalier JD-VCC, mets 5 V sur JD-VCC et 3,3 V sur VCC, ou utilise un module à commande 3,3 V ou un transistor NPN. Évite aussi de relier IN aux broches de démarrage comme GPIO 0, 2, 12 et 15 : elles changent brièvement d'état au démarrage de l'ESP32 et les lumières clignotent un instant.

Étape 1 : afficher le coucher du soleil du jour dans le moniteur série

  1. Dans l'Arduino IDE, installe le paquet esp32 depuis le gestionnaire de cartes et choisis ESP32 Dev Module comme carte.
  2. Dans le code ci-dessous, indique le nom et le mot de passe de ton réseau dans WIFI_SSID et WIFI_PASS.
  3. Modifie LATITUDE et LONGITUDE selon ta ville ; les longitudes ouest et les latitudes sud sont négatives.
  4. 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".
  5. Téléverse le code, ouvre le moniteur série à 115200 bauds et compare les heures affichées avec le tableau.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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, &lt);
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églageValeur par défautÀ quoi ça sert ?
TZ_INFO"<+03>-3"Fuseau horaire et règle d'heure d'été (format POSIX)
LATITUDE / LONGITUDE41.01 / 28.98Position ; longitude ouest et latitude sud négatives
RELAY_PIN26Broche reliée à IN du module relais
RELAY_ACTIVE_LOWtruetrue si le module s'active à LOW, false s'il s'active à HIGH
SUNSET_OFFSET_MIN0Décalage par rapport au coucher du soleil ; −15 allume 15 min plus tôt
OFF_MINUTE24 * 60Heure d'extinction ; pour 23:30, mets 23 * 60 + 30
MORNING_ON_MINUTE-1Allumage 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.

Si tu ne veux pas lire l'adresse IP dans le moniteur série à chaque fois, attribue à l'ESP32 une IP fixe dans ta box (réservation DHCP) ou accède-y par son nom avec mDNS. Si tu préfères saisir les identifiants Wi-Fi depuis ton téléphone plutôt que de les écrire dans le code, ajoute à ce sketch la méthode de ESP32 WiFiManager.
RégionTZ_INFO
Turquie<+03>-3
Allemagne, Autriche, Italie, France, EspagneCET-1CEST,M3.5.0,M10.5.0/3
Royaume-Uni, Irlande, PortugalGMT0BST,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.
Si tu travailles en 230 V, toutes les connexions doivent être dans un boîtier fermé et isolé, le circuit doit être alimenté par une ligne protégée par un disjoncteur différentiel 30 mA et l'installation doit se faire hors tension. Si tu n'as pas l'habitude des installations électriques, utilise le relais seulement côté basse tension ou confie cette partie à un électricien. Ne laisse pas non plus le module relais accessible : les soudures côté contacts sont sous tension secteur.

Erreurs fréquentes et solutions

ProblèmeCauseSolution
"En attente du NTP" ne finit jamais dans le moniteur sérieWi-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 pileTZ_INFO incorrect ou règle d'heure d'été absenteUtilise la bonne chaîne POSIX du tableau
Coucher du soleil décalé de plusieurs heuresSigne de la longitude faux ou latitude et longitude inverséesSaisis la longitude ouest en négatif et vérifie l'ordre
Le relais ne retombe jamaisLe module 5 V ne se coupe pas complètement avec un HIGH à 3,3 VSépare JD-VCC, utilise un module 3,3 V ou un transistor
Les lumières clignotent au démarrageBroche de démarrage ou ordre de pinModeChoisis une broche sûre comme GPIO 26, digitalWrite d'abord puis pinMode
La page web ne s'ouvre pasL'adresse IP a changéFais une réservation DHCP dans la box ou utilise mDNS
Les lumières restent allumées après minuitMode resté sur ONRepasse 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.

Voir tous les projets
ESP32 : heure réelle depuis Internet via NTP
ES-26Avancé
Premium

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.

4.5(13)
22
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

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).

4.8(16)
26
Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
ES-37Avancé
Premium

É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.

4.3(6)
11
Veilleuse ESP32 avec LDR
ES-10Débutant
Premium

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.

4.6(17)
30
Contrôle d'une bande NeoPixel WS2812B avec l'ESP32
ES-24Intermédiaire
Premium

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.

4.9(19)
30
Connexion Wi-Fi STA ESP32 (avec écran LCD)
ES-25Avancé

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.

4.4(21)
38
ESP32 mDNS : accès à l'appareil via bluegrays-esp.local (avec écran LCD)
ES-29Avancé
Premium

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/.

4.8(14)
23
Ampoule 220V avec bouton poussoir (Push)
AR-19Avancé
Premium

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.

4.4(30)
38