ESP32-timer voor kerstverlichting: automatisch aan bij zonsondergang
ESP32-timer voor kerstverlichting: NTP-tijd en je locatie geven de zonsondergang, een relais schakelt de lampjes aan en om middernacht uit. Stedentabel, webbediening en veiligheid.
Het grootste voordeel van een ESP32 als timer voor kerstverlichting is dat hij de lampjes aanzet wanneer de zon echt ondergaat op de plek waar je woont, en niet op een vaste tijd. De ESP32 maakt verbinding met wifi, haalt de tijd via NTP van internet, berekent aan de hand van de breedte- en lengtegraad die je invoert de zonsopkomst en zonsondergang van die dag, zet de lichtsnoer aan met een relaismodule en schakelt hem om middernacht zelf weer uit. Bovendien kun je de lampjes met een kleine webpagina op je telefoon handmatig schakelen, en de modus die je kiest blijft bewaard, ook na een stroomstoring.
In deze gids laten we eerst zien waarom de zonsondergang elke dag verschuift en hoeveel die van stad tot stad verschilt, en leggen we daarna stap voor stap de formule achter de berekening uit. Daarna volgen twee sketches: de eerste print gewoon de zonsopkomst en zonsondergang van vandaag naar de Serial Monitor, de tweede is een complete timer met relais, uitschakeling om middernacht en webbediening. Het laatste deel behandelt veiligheid buitenshuis en veelgemaakte fouten. Wil je de basis van NTP opfrissen, kijk dan bij ESP32 NTP-klok.

Waarom zonsondergang in plaats van een vaste tijd?
Een mechanische of digitale stekkertimer schakelt elke avond op dezelfde tijd in, maar de zonsondergang schuift gedurende het seizoen steeds op. In Londen gaat de zon op 1 november onder om 16:35, op 1 december om 15:56 en op 31 januari om 16:45, een verschil van ongeveer 50 minuten tijdens de kerstperiode. Bij een vaste instelling van 16:15 gaan de lampjes begin november en eind januari aan terwijl het nog licht is; zet je hem op 16:30, dan gaan ze half december meer dan een half uur na het donker aan. Ook de locatie speelt een grote rol: op 21 december gaat de zon in Berlijn onder om 15:53 en in Madrid om 17:51, hoewel beide steden in dezelfde tijdzone liggen. De tabel hieronder toont zonsondergangstijden die zijn berekend met dezelfde formule als in de code; ze wijken meestal een of twee minuten af van gepubliceerde waarden.
| Stad | Breedtegraad, lengtegraad | 1 dec | 10 dec | 21 dec | 31 dec |
|---|---|---|---|---|---|
| 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 |
| Londen | 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 |
| München | 48.14 / 11.58 | 16:23 | 16:20 | 16:22 | 16:28 |
| Wenen | 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 |
| Milaan | 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-Stad | 19.43 / -99.13 | 17:57 | 17:59 | 18:03 | 18:08 |
In de tabel zit een interessant detail: hoewel 21 december de kortste dag is, valt de vroegste zonsondergang ongeveer tien dagen eerder, in de eerste helft van december. De reden is de tijdvergelijking: de baan van de aarde is geen perfecte cirkel en haar as staat scheef, waardoor het moment waarop de zon het hoogste punt aan de hemel bereikt in december elke dag ongeveer 30 seconden later valt. De zonsondergang schuift daarmee mee naar later, terwijl de zon 's ochtends tot begin januari steeds later opkomt. Een timer met een vaste tijd kan dit nooit vangen; de formule houdt er automatisch rekening mee.
Hoe wordt de zonsondergang berekend?
De code gebruikt de benaderde zonneformules van de Amerikaanse National Oceanic and Atmospheric Administration (NOAA). Voor de berekening zijn alleen de dag van het jaar, de breedtegraad en de lengtegraad nodig; er wordt geen extra data van internet gehaald. Het resultaat is in UTC-minuten, die de code met je tijdzone-instelling omzet naar lokale tijd, zodat het ook goed werkt in landen met zomertijd. Onder 60° breedtegraad is de formule op een of twee minuten nauwkeurig; in poolgebieden, waar de zon de hele dag niet ondergaat of opkomt, is de arccos niet gedefinieerd en controleert de code dat apart.
| Stap | Formule | Uitleg |
|---|---|---|
| 1. Fractioneel jaar | γ = 2π / 365 × (dag − 1) | Zet de dag van het jaar om in radialen |
| 2. Tijdvergelijking | eqtime = 229.18 × (0.000075 + 0.001868 cos γ − 0.032077 sin γ − 0.014615 cos 2γ − 0.040849 sin 2γ) | Verschil tussen zonnetijd en kloktijd, over het jaar ongeveer −14 tot +16 min |
| 3. Zonsdeclinatie | δ = 0.006918 − 0.399912 cos γ + 0.070257 sin γ − ... | Rond 21 december ongeveer −23,44° |
| 4. Uurhoek | ha = arccos(cos 90.833° / (cos φ cos δ) − tan φ tan δ) | 90,833°: breking aan de horizon (0,567°) + de straal van de zon (0,267°) |
| 5. Zonsondergang | 720 − 4 × (lengtegraad − ha) − eqtime | UTC-minuten; elke graad lengtegraad is 4 minuten |
Onderdelenlijst
- ESP32-developmentboard (30 of 38 pins, beide werken)
- 1-kanaals relaismodule: optocoupler-geïsoleerd, contacten voor 10 A 250 V AC; of een geruisloos halfgeleiderrelais (SSR)
- 5 V 1–2 A USB-adapter en een USB-kabel voor de ESP32
- Lichtsnoer: bij voorkeur een buitenledsnoer op laagspanning (5–31 V) met eigen adapter
- IP65-aansluitdoos, kabelwartels en klemmenblokken
- Een paar jumperdraden
Bedrading: ESP32 en relaismodule
| Relaismodule | ESP32 | Opmerking |
|---|---|---|
| VCC | VIN (5 V) | De relaisspoel heeft 5 V nodig; de VIN-pin via USB is voldoende |
| GND | GND | Gemeenschappelijke massa |
| IN | GPIO 26 | RELAY_PIN in de code; de meeste modules schakelen bij LOW |
| COM | Lampenadapter + uitgang | Ingang van de geschakelde lijn |
| NO (normaal open) | Lichtsnoer + ingang | De schakeling sluit wanneer het relais aantrekt |
| NC (normaal gesloten) | Ongebruikt | Niet gebruikt |
Stap 1: zie de zonsondergang van vandaag in de Serial Monitor
- Installeer in de Arduino IDE het pakket esp32 via de Boards Manager en kies ESP32 Dev Module als board.
- Vul in de onderstaande code je netwerknaam en wachtwoord in bij WIFI_SSID en WIFI_PASS.
- Pas LATITUDE en LONGITUDE aan voor jouw stad; westelijke lengtegraden en zuidelijke breedtegraden zijn negatief.
- Kies buiten Turkije de regel TZ_INFO uit de tijdzonetabel hieronder.
- Upload de code, open de Serial Monitor op 115200 baud en vergelijk de geprinte tijden met de tabel.
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}Het lastigste deel van de code is de omrekening tussen UTC en lokale tijd. De formule geeft de zonsondergang als minuten na de UTC-middernacht van die dag. De code zet eerst de lokale middag van vandaag met mktime() om in een tijdstempel en trekt daar de rest van de deling door 86400 van af om de UTC-middernacht van dezelfde datum te vinden. De minuten van de zonsondergang worden bij die waarde opgeteld en localtime_r() zet het resultaat om naar jouw tijdzone. Door vanaf de middag te beginnen voorkom je dat er 's nachts de verkeerde dag wordt berekend, wanneer de UTC-datum en de lokale datum verschillen.
Stap 2: de volledige code met relais, uitschakeling om middernacht en webbediening
De tweede sketch maakt van de berekening van de zonsondergang een timer. Elke 10 seconden controleert hij de tijd; als de dag is veranderd berekent hij de zonsopkomst en zonsondergang opnieuw, en in automatische modus bepaalt hij of de lampjes aan moeten. De ingebouwde bibliotheek WebServer serveert een kleine pagina op poort 80: open het IP-adres van de ESP32 in een browser en je ziet de status van de lampjes, de zonsopkomst en zonsondergang van vandaag en de links AUTO, ON en OFF. De gekozen modus wordt met Preferences in het flashgeheugen opgeslagen, zodat de timer na een stroomstoring in dezelfde modus verdergaat.
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}Instellingen
| Instelling | Standaard | Wat het doet |
|---|---|---|
| TZ_INFO | "<+03>-3" | Tijdzone en zomertijdregel (POSIX-formaat) |
| LATITUDE / LONGITUDE | 41.01 / 28.98 | Locatie; westelijke lengtegraad en zuidelijke breedtegraad zijn negatief |
| RELAY_PIN | 26 | Pin die is aangesloten op de IN van de relaismodule |
| RELAY_ACTIVE_LOW | true | true als de module bij LOW schakelt, false bij HIGH |
| SUNSET_OFFSET_MIN | 0 | Verschuiving ten opzichte van de zonsondergang; −15 schakelt 15 min eerder in |
| OFF_MINUTE | 24 * 60 | Uitschakeltijd; gebruik voor 23:30 23 * 60 + 30 |
| MORNING_ON_MINUTE | -1 | Inschakeling 's ochtends; met 6 * 60 + 30 branden de lampjes van 06:30 tot zonsopkomst |
Hoe werkt de code?
In applyState() wordt de beslissing genomen. Als de tijd nog niet is ontvangen, gaan de lampjes alleen aan in ON-modus; zo voorkom je dat ze op het verkeerde moment aangaan voordat de wifi er is. Zodra de tijd geldig is, wordt de minuut van de dag berekend en worden twee voorwaarden gecontroleerd: het avondvenster loopt van zonsondergang tot de uitschakeltijd en het optionele ochtendvenster van de inschakeltijd tot zonsopkomst. Het relais wordt alleen geschakeld als de toestand verandert, en elke wijziging wordt naar de Serial Monitor geprint, wat het oplossen van problemen makkelijker maakt. setRelay() schrijft het juiste niveau naar de pin op basis van RELAY_ACTIVE_LOW. In setup() wordt de pin op het uitniveau gezet voordat hij als uitgang wordt ingesteld; door die volgorde klikt het relais bij het opstarten niet even aan. Als de wifi wegvalt, blijft de ESP32 op zijn interne klok doorlopen en corrigeert NTP de tijd weer zodra de verbinding terug is.
| Regio | TZ_INFO |
|---|---|
| Turkije | <+03>-3 |
| Duitsland, Oostenrijk, Italië, Frankrijk, Spanje | CET-1CEST,M3.5.0,M10.5.0/3 |
| Verenigd Koninkrijk, Ierland, Portugal | GMT0BST,M3.5.0/1,M10.5.0 |
| Oostkust VS (New York) | EST5EDT,M3.2.0,M11.1.0 |
| Mexico (Mexico-Stad) | CST6 |
Veiligheid buitenshuis
- Kies laagspanning: bij ledsnoeren van 5–31 V met eigen adapter sluit je het relais aan op de laagspanningsuitgang van de adapter, zodat je nooit met netspanning in aanraking komt.
- Doos en wartels: plaats de ESP32 en het relais in een IP65-doos, voer de kabels door wartels en monteer de doos met de kabelinvoeren naar beneden, zodat er geen water naar binnen kan lopen.
- Stroomcontrole: een gewoon snoer met 200 leds trekt 10–20 W, minder dan 0,1 A bij 230 V. Je komt dus niet in de buurt van de 10 A van het relais, maar bij goedkope modules ligt de echte limiet lager dan opgedrukt, dus houd de totale belasting onder een paar ampère.
- Condensatie: op winternachten kan vocht in de doos condenseren; voeg een klein zakje silicagel toe en monteer de elektronica bovenin de doos in plaats van op de bodem.
- Geen inductieve belastingen: gebruik deze timer alleen voor verlichting; de inschakelstroom van motoren, kachels of compressoren kan de relaiscontacten in korte tijd aan elkaar laten lassen.
Veelvoorkomende problemen en oplossingen
| Probleem | Oorzaak | Oplossing |
|---|---|---|
| "Waiting for NTP" houdt in de Serial Monitor nooit op | Wifi niet verbonden of de NTP-poort is geblokkeerd | Controleer de netwerknaam en het wachtwoord, zet de ESP32 dichter bij de router |
| Zonsondergang loopt precies een uur af | Verkeerde TZ_INFO of ontbrekende zomertijdregel | Gebruik de juiste POSIX-string uit de tabel |
| Zonsondergang loopt uren af | Verkeerd teken bij de lengtegraad, of breedte- en lengtegraad omgewisseld | Voer westelijke lengtegraad negatief in en controleer de volgorde |
| Relais valt nooit af | 5 V-module schakelt niet helemaal uit bij een HIGH van 3,3 V | Scheid JD-VCC, gebruik een module van 3,3 V of een transistor |
| Lampjes flitsen kort bij het opstarten | Boot-strappingpin of volgorde van pinMode | Gebruik een veilige pin zoals GPIO 26 en roep digitalWrite aan vóór pinMode |
| Webpagina opent niet | Het IP-adres is veranderd | Stel een DHCP-reservering in op de router of gebruik mDNS |
| Lampjes branden na middernacht nog steeds | Modus staat nog op ON | Schakel op de webpagina over naar AUTO |
Projectideeën met deze timer
- Back-up met lichtsensor: als de wifi lang wegblijft, detecteer je het donker met een LDR en zet je de lampjes toch aan.
- Integratie met je slimme huis: publiceer de relaistoestand via MQTT en bedien hem vanaf een Home Assistant-dashboard.
- Planning met meerdere kanalen: geef met een 4-kanaals relaisboard de balkon-, tuin- en raamverlichting verschillende uitschakeltijden.
- Zonsonderganseffect: gebruik een WS2812B-strip in plaats van een relais en laat de kleuren bij zonsondergang langzaam overvloeien naar warmwit; de opzet van de strip vind je in Leds voor de kerstboom.
- Meer seizoensprojecten: voor ideeën die deze timer aanvullen, zie de lijst met Arduino-kerstprojecten.
Wil je de bouwstenen van deze timer een voor een leren, bekijk dan in de BlueGrays-app de projecten ESP32 NTP-realtimeklok, ESP32 asynchrone webserver en ESP32 slimme verlichting; elk met een schakelschema, een bedradingslijst en stap voor stap uitgelegde code. Combineer die onderdelen met de berekening van de zonsondergang uit dit bericht en je kerstverlichting gaat elke avond precies op tijd vanzelf aan.
Veelgestelde vragen
Hoe laat ik kerstverlichting automatisch aangaan bij zonsondergang?
De nauwkeurigste methode is een wifiboard zoals de ESP32 de tijd via NTP te laten ophalen en de zonsondergang van die dag te berekenen uit de breedte- en lengtegraad. Op dat moment trekt het board een relais aan om de lampjes in te schakelen, en het zet ze uit op de tijd die je kiest. Een eenvoudiger oplossing is het donker detecteren met een LDR, maar wolken en straatverlichting kunnen die om de tuin leiden.
Haalt de ESP32 de tijd van de zonsondergang van internet?
Nee, hij haalt alleen de kloktijd via NTP van internet. De zonsondergang berekent hij zelf met de NOAA-formules, waarvoor alleen de dag van het jaar, de breedtegraad en de lengtegraad nodig zijn. Een weerdienst of API-sleutel is dus niet nodig.
Blijft de timer werken als het internet uitvalt?
Ja. Zodra de ESP32 de tijd heeft, telt hij door op zijn interne klok en blijft de afwijking meestal binnen een paar seconden per dag. Zodra de verbinding terug is, corrigeert NTP de tijd weer. Maar als de ESP32 opnieuw opstart, zet de automatische modus de lampjes pas aan als hij de tijd heeft.
Werkt een relaismodule met de 3,3 V van de ESP32?
De meeste relaismodules van 5 V schakelen met een signaal van 3,3 V, maar sommige optocoupler-modules die bij LOW schakelen vallen bij een HIGH van 3,3 V niet helemaal af. Het probleem is dan op te lossen door de JD-VCC-jumper te verwijderen en de module apart te voeden, een module met 3,3 V-trigger te kopen of een NPN-transistor toe te voegen.
Welk relais moet ik gebruiken voor kerstverlichting buiten?
Voor verlichting is een mechanische relaismodule met optocoupler-isolatie en contacten voor 10 A 250 V AC voldoende; wil je het klikgeluid niet, gebruik dan een halfgeleiderrelais (SSR). Welke je ook kiest, plaats het board in een waterdichte doos en voed de netzijde vanuit een groep met aardlekbeveiliging.
Kunnen de lampjes voor of na zonsondergang aangaan?
Ja. Met SUNSET_OFFSET_MIN in de code stel je de verschuiving in minuten in: −15 zet de lampjes 15 minuten voor zonsondergang aan en 20 zet ze 20 minuten erna aan. Omdat de schemering ongeveer 30 minuten duurt, geeft een positieve offset van 10–20 minuten vaak het mooiste resultaat.
Projecten om hierna te bouwen
Alle projecten bekijken
Echte tijd van internet met ESP32 en NTP
De ESP32 verbindt met Wi-Fi en haalt met milliseconde-precisie de echte tijd op bij NTP-servers (Network Time Protocol). configTzTime() past de Turkse tijdzone (TRT, UTC+3) automatisch toe, en in landen met zomertijd wordt de overgang naar zomertijd (DST) geregeld met een POSIX TZ-string. De tijd wordt zowel naar de Serial Monitor als naar een optioneel I2C-lcd gestuurd.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

ESP32 slimme verlichting (PIR + LDR + relais + OLED)
Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

ESP32-nachtlampje met LDR
Nachtlampje waarvan de LED in het donker automatisch aangaat en bij licht uit. Je gebruikt de D0-pin (digitale uitgang) van de LDR-sensormodule: de donkerdrempel stel je in met de kleine potmeter op de module en de module zelf geeft het HIGH/LOW-signaal. De ESP32 leest dit signaal alleen met digitalRead(); de code is heel eenvoudig.

ESP32 WS2812B NeoPixel-strip aansturen
WS2812B-leds (NeoPixel) zijn adresseerbare slimme RGB-leds die je kunt doorlussen en via één datapin kunt aansturen. In dit project sturen we een WS2812B-strip met 8 leds aan met de Adafruit_NeoPixel-bibliotheek en maken we een vloeiende regenbooganimatie. De 3,3V-logica van de ESP32 werkt met de meeste WS2812B-batches; wordt het instabiel, dan laten we de oplossing zien met een serieweerstand van 470Ω en een condensator van 1000µF. De animatie schuift de tint op in de HSV-kleurruimte.

ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)
In dit project voegen we een mDNS-service (Multicast DNS) toe aan de ESP32, zodat je het apparaat bereikt met een leesbare hostnaam zoals bluegrays-esp.local in plaats van een IP-adres. Ook als het IP-adres dat DHCP uitdeelt verandert, reageert het apparaat altijd op dezelfde naam. Met een kleine webserver op het board bedien je de LED vanuit je browser op http://bluegrays-esp.local/.

230V-lamp laten branden met een drukknop
Zolang je de knop vasthoudt, brandt een echte lamp op netspanning, en zodra je loslaat gaat hij uit.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

