ESP32 NTP-tijd: internetklok met tijdzone, OLED en RTC-backup
Zo krijg je NTP-tijd op de ESP32: configTzTime en tijdzones, getLocalTime, strftime, een OLED-klok, DS3231-backup, een dagelijkse taak en ntptime op de Pico W.
Tijd ophalen met ESP32 NTP betekent dat je het board verbindt met tijdservers op internet en de datum en tijd tot op enkele tientallen milliseconden nauwkeurig kent, zonder klokmodule. Zodra de ESP32 op wifi zit, haalt één aanroep van configTzTime() de tijd op, past je tijdzone toe en telt het board daarna zelf verder. Bureauklokken, tijdgestuurd water geven, tijdstempels voor datalogging, een wekker of lampen die op een vast tijdstip aangaan hebben geen aparte RTC-module meer nodig.
In deze gids lopen we stap voor stap door hoe NTP werkt, het instellen van de juiste tijdzone, het schrijven van de datum in elk formaat met getLocalTime en strftime, het tonen van de tijd op een OLED-display, het bijhouden van de tijd met een DS3231-module als de wifi wegvalt of de stroom uitvalt, en het uitvoeren van een taak op een vast tijdstip per dag. In het laatste deel doen we hetzelfde op de Raspberry Pi Pico W met de ntptime-module van MicroPython.

Wat is NTP en hoe krijgt de ESP32 de tijd?
NTP (Network Time Protocol) is een protocol, in gebruik sinds de jaren tachtig, om de klokken van computers en apparaten via internet te synchroniseren. Servers zijn gerangschikt in lagen die strata heten: stratum 1-servers zijn rechtstreeks verbonden met een atoomklok of gps, stratum 2-servers halen hun tijd daarvan, enzovoort. De ESP32 vraagt de tijd op met een klein pakket op UDP-poort 123; de server antwoordt met een tijdstempel met de seconden sinds 1900 plus een fractie van een seconde. De ESP32 houdt rekening met de heen-en-terugreistijd van het pakket en stelt zijn eigen klok in. Op een thuisverbinding ligt de nauwkeurigheid zo meestal tussen 10 en 50 milliseconden, ruim genoeg voor een klokproject.
De lwIP-netwerkstack in de ESP32 gebruikt SNTP, een vereenvoudigde versie van NTP. Zodra de tijd is ontvangen, bewaart de ESP32 hem als systeemtijd en telt hij verder met een timer die van zijn kristal is afgeleid; hij gaat dus niet elke seconde naar internet. Op de achtergrond vraagt hij met regelmatige tussenpozen opnieuw bij de server (standaard elke 3 uur in de Arduino ESP32-core) en corrigeert hij kleine afwijkingen. De systeemtijd wordt bijgehouden in UTC; de lokale tijd die je ziet wordt daaruit berekend met de tijdzoneregel.
| Begrip | Waarde / uitleg |
|---|---|
| Protocol en poort | SNTP, UDP 123 |
| Tijdstempel | Seconden sinds 1900 (de ESP32 zet dit om naar Unix-tijd, die op 1970 is gebaseerd) |
| Typische nauwkeurigheid | 10–50 ms op een thuisverbinding |
| Hersynchronisatie | Standaard 3 uur in Arduino ESP32, te wijzigen met sntp_set_sync_interval() (minimaal 15 s) |
| Maximaal aantal servers | 3 (de servernamen die je aan configTzTime meegeeft) |
| Internetverkeer | Verzoek en antwoord zijn elk een NTP-pakket van 48 byte; hooguit een paar kilobyte per dag |
| Wat je nodig hebt | ESP32, een 2,4 GHz-wifinetwerk en een internetverbinding |
configTime en configTzTime: de tijdzone instellen
Er zijn twee manieren om NTP te starten in de Arduino ESP32-core. configTime(gmtOffset_sec, daylightOffset_sec, server1, server2, server3) neemt de UTC-offset en de zomertijdoffset in seconden. Voor Turkije schrijf je bijvoorbeeld configTime(10800, 0, "pool.ntp.org"), want 3 uur is 10.800 seconden en Turkije zit sinds 2016 het hele jaar op UTC+3, zonder zomertijd. Deze methode is simpel, maar kent de zomertijddata van jouw regio niet; op plekken met zomertijd, zoals Europa of de VS, schakelt de klok op de verkeerde dag om. Gebruik daar dus configTzTime.
De betere manier is configTzTime(TZ, server1, server2, server3). Deze functie neemt een tijdzonestring in POSIX-formaat die ook de zomertijdregels bevat, en de ESP32 regelt de omschakeling elk jaar zelf. Voor Turkije is de string "<+03>-3": de +03 tussen punthaken is de afkorting die op het scherm verschijnt, en -3 betekent dat je 3 uur van de lokale tijd aftrekt om UTC te krijgen. De tabel hieronder toont de strings voor veelgebruikte regio's.
| Regio | TZ-string (configTzTime) | Equivalent in configTime |
|---|---|---|
| Turkije (het hele jaar UTC+3) | <+03>-3 | configTime(10800, 0, ...) |
| Duitsland, Frankrijk, Italië, Spanje | CET-1CEST,M3.5.0,M10.5.0/3 | Niet geschikt, gebruik configTzTime |
| VK, Portugal | GMT0BST,M3.5.0/1,M10.5.0 | Niet geschikt, gebruik configTzTime |
| US Eastern (New York) | EST5EDT,M3.2.0,M11.1.0 | Niet geschikt, gebruik configTzTime |
| Azerbeidzjan, Georgië (UTC+4) | <+04>-4 | configTime(14400, 0, ...) |
| UTC (voor tijdstempels) | UTC0 | configTime(0, 0, ...) |
Wat je nodig hebt en bedrading
Om de tijd in de Serial Monitor te zien heb je alleen een ESP32 en een wifinetwerk nodig. Verderop in de gids gebruiken we een SSD1306 OLED-display van 0,96 inch om de tijd te tonen, een DS3231 RTC-module om de tijd bij stroomuitval te bewaren en een relaismodule voor het voorbeeld van de geplande taak. De OLED en de DS3231 delen dezelfde I2C-bus, dus beide sluit je aan op dezelfde twee pins. De pinout van de ESP32 zoek je op met de tool Pinout.
| Pin van het onderdeel | ESP32 | Raspberry Pi Pico W | Opmerking |
|---|---|---|---|
| OLED / DS3231 VCC | 3V3 | 3V3 (OUT) | Beide werken op 3,3 V |
| OLED / DS3231 GND | GND | GND | Gemeenschappelijke massa |
| OLED / DS3231 SDA | GPIO 21 | GP4 | I2C-datalijn |
| OLED / DS3231 SCL | GPIO 22 | GP5 | I2C-klokllijn |
| IN van de relaismodule | GPIO 26 | GP15 | Voorbeeld van de geplande taak |
| VCC van de relaismodule | 5V (VIN) | VBUS | De meeste relaisspoelen hebben 5 V nodig |
Stap voor stap: je eerste ESP32 NTP-sketch
- Zorg dat het ESP32-boardpakket in de Arduino IDE is geïnstalleerd en kies onder Tools ESP32 Dev Module. Weet je niet hoe, lees dan het bericht Wat is de ESP32.
- Je hebt geen extra bibliotheek nodig: WiFi.h en time.h zitten in de ESP32-core.
- Vervang de waarden WIFI_SSID en WIFI_PASS door die van je eigen netwerk en TZ_INFO door je tijdzone uit de tabel hierboven.
- Upload de sketch en open de Serial Monitor op 115200 baud.
- Je ziet eerst wifi-puntjes en na een paar seconden de datum en tijd, die elke seconde worden bijgewerkt.
1#include <WiFi.h>
2#include <time.h>
3
4const char* WIFI_SSID = "AgAdi"; // Wi-Fi adı / Wi-Fi name
5const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifresi / Wi-Fi password
6const char* TZ_INFO = "<+03>-3"; // Türkiye: UTC+3, yaz saati yok / Turkey: UTC+3, no DST
7
8void setup() {
9 Serial.begin(115200);
10 WiFi.begin(WIFI_SSID, WIFI_PASS);
11 Serial.print("Wi-Fi");
12 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
13 delay(500);
14 Serial.print(".");
15 }
16 Serial.println(" OK");
17
18 // NTP sunucuları + saat dilimi / NTP servers + time zone
19 configTzTime(TZ_INFO, "pool.ntp.org", "time.cloudflare.com");
20
21 struct tm t;
22 while (!getLocalTime(&t)) { // ilk eşitlemeyi bekle (5 sn deneme) / wait for the first sync (5 s per try)
23 Serial.println("NTP bekleniyor / waiting for NTP");
24 }
25 Serial.println("Saat alindi / time received");
26}
27
28void loop() {
29 struct tm t;
30 if (getLocalTime(&t)) {
31 Serial.println(&t, "%d.%m.%Y %H:%M:%S"); // ör. 16.11.2026 14:05:09 / e.g. 16.11.2026 14:05:09
32 }
33 delay(1000);
34}
35| Regel | Wat doet het? |
|---|---|
| configTzTime(TZ_INFO, ...) | Start de SNTP-client en stelt de servers en tijdzone in; keert meteen terug, de tijd komt op de achtergrond binnen |
| getLocalTime(&t) | Vult een struct tm met de lokale tijd; is er nog geen tijd, dan wacht de functie maximaal 5 seconden en geeft false terug |
| Serial.println(&t, "...") | De Print-klasse van de ESP32 kan een struct tm rechtstreeks printen met een strftime-formaat |
| time(nullptr) | Geeft de seconden sinds 1970 terug (Unix-tijd, UTC) |
Hier zit een belangrijk detail: getLocalTime() bepaalt of de tijd "geldig" is door naar het jaar te kijken. Bij het opstarten van de ESP32 is de systeemtijd 1 januari 1970 en de functie geeft false terug totdat het jaar later is dan 2016. Code die data logt of taken uitvoert voordat NTP binnen is, maakt dus niet per ongeluk regels met de datum 1970, zolang je de returnwaarde controleert. De tweede parameter is de timeout in milliseconden; wil je niet blokkeren in loop(), schrijf dan getLocalTime(&t, 0), zodat de functie het maar één keer probeert.
struct tm: de onderdelen van de tijd
getLocalTime() schrijft de tijd in een struct tm, opgesplitst in onderdelen. Met deze velden vergelijk je uren, dagen of maanden bij het bouwen van geplande taken. Twee velden zorgen vaak voor verwarring bij beginners: de maand telt vanaf 0 en het jaar telt vanaf 1900.
| Veld | Bereik | Voorbeeld (maandag 16 november 2026, 14:05:09) |
|---|---|---|
| tm_sec | 0–59 (60 bij een schrikkelseconde) | 9 |
| tm_min | 0–59 | 5 |
| tm_hour | 0–23 | 14 |
| tm_mday | 1–31 | 16 |
| tm_mon | 0–11 (0 = januari) | 10 |
| tm_year | Jaren sinds 1900 | 126 (1900 + 126 = 2026) |
| tm_wday | 0–6 (0 = zondag) | 1 |
| tm_yday | 0–365 (dag van het jaar, vanaf 0) | 319 |
Datum en tijd opmaken met strftime
strftime() schrijft de tijd uit een struct tm volgens een patroon naar een tekenarray. De procentcodes in het patroon worden vervangen door de bijbehorende waarde en alle andere tekens blijven staan. Maak de array zo groot als de langste uitvoer plus één (voor het afsluitende nulteken): "14:05:09" is 8 tekens, dus de array moet minstens 9 byte zijn. De meest gebruikte codes:
| Code | Betekenis | Voorbeelduitvoer |
|---|---|---|
| %H / %M / %S | Uur (00–23) / minuut / seconde | 14 / 05 / 09 |
| %I en %p | 12-uursklok en AM/PM | 02 PM |
| %d / %m / %Y | Dag / maand (01–12) / jaar met vier cijfers | 16 / 11 / 2026 |
| %y | Jaar met twee cijfers | 26 |
| %A / %a | Naam van de weekdag, lang / kort (Engels) | Monday / Mon |
| %B / %b | Naam van de maand, lang / kort (Engels) | November / Nov |
| %j | Dag van het jaar (001–366) | 320 |
| %F / %T | Afkortingen voor %Y-%m-%d / %H:%M:%S | 2026-11-16 / 14:05:09 |
| %Z | Afkorting van de tijdzone | +03 |
De C-bibliotheek op de ESP32 kent alleen Engelse dag- en maandnamen; %A print altijd "Monday". Voor datums in een andere taal bewaar je de dag- en maandnamen in je eigen arrays en gebruik je tm_wday en tm_mon als array-index. Het voorbeeld hieronder doet dat met Turkse namen; vervang ze gewoon door die van jouw taal. Omdat de Serial Monitor UTF-8 ondersteunt, worden letters met accenten daar goed weergegeven. De sketch geeft zowel een leesbare datum als het sorteerbare ISO-formaat (2026-11-16 14:05:09) voor logging.
1#include <WiFi.h>
2#include <time.h>
3
4const char* WIFI_SSID = "AgAdi";
5const char* WIFI_PASS = "Sifre123";
6const char* TZ_INFO = "<+03>-3";
7
8// tm_wday: 0 = Pazar ... 6 = Cumartesi / 0 = Sunday ... 6 = Saturday
9const char* GUNLER[] = {"Pazar", "Pazartesi", "Salı", "Çarşamba", "Perşembe", "Cuma", "Cumartesi"};
10const char* AYLAR[] = {"Ocak", "Şubat", "Mart", "Nisan", "Mayıs", "Haziran",
11 "Temmuz", "Ağustos", "Eylül", "Ekim", "Kasım", "Aralık"};
12
13void setup() {
14 Serial.begin(115200);
15 WiFi.begin(WIFI_SSID, WIFI_PASS);
16 while (WiFi.status() != WL_CONNECTED) delay(500);
17 configTzTime(TZ_INFO, "pool.ntp.org");
18}
19
20void loop() {
21 struct tm t;
22 if (!getLocalTime(&t)) return; // saat henüz yok / time not set yet
23
24 char saat[9]; // "HH:MM:SS" + '\0'
25 char iso[20]; // "YYYY-MM-DD HH:MM:SS" + '\0'
26 strftime(saat, sizeof(saat), "%H:%M:%S", &t);
27 strftime(iso, sizeof(iso), "%Y-%m-%d %H:%M:%S", &t);
28
29 // Türkçe tarih: 16 Kasım 2026 Pazartesi / Turkish date
30 Serial.printf("%d %s %d %s %s\n", t.tm_mday, AYLAR[t.tm_mon], t.tm_year + 1900, GUNLER[t.tm_wday], saat);
31 Serial.printf("Kayit / log: %s epoch: %ld\n", iso, (long)time(nullptr));
32 delay(1000);
33}
34Tijd en datum tonen op een OLED-display
Om de uitvoer van de Serial Monitor om te zetten in een echte bureauklok is het SSD1306 OLED-display van 0,96 inch ideaal: het is goedkoop, wordt met twee draden aangesloten en toont grote cijfers messcherp. De sketch hieronder toont bovenaan de weekdag en datum, in het midden de tijd in een groot lettertype en onderaan de wifistatus. Omdat hij alleen opnieuw tekent als de seconde verandert, en niet bij elke lus, houdt hij de I2C-bus niet nodeloos bezig. Installeer de bibliotheken Adafruit SSD1306 en Adafruit GFX via de Library Manager; het display zelf komt aan bod in het bericht OLED-display (SSD1306).
1#include <WiFi.h>
2#include <Wire.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5#include <time.h>
6
7const char* WIFI_SSID = "AgAdi";
8const char* WIFI_PASS = "Sifre123";
9const char* TZ_INFO = "<+03>-3";
10// OLED yazı tipinde Türkçe harf yok / the OLED font has no Turkish letters
11const char* GUNLER[] = {"Pazar", "Pazartesi", "Sali", "Carsamba", "Persembe", "Cuma", "Cumartesi"};
12
13Adafruit_SSD1306 display(128, 64, &Wire, -1);
14int sonSaniye = -1; // son çizilen saniye / last drawn second
15
16void yaz(const char* mesaj) { // ekrana tek satır / one line on screen
17 display.clearDisplay();
18 display.setTextSize(1);
19 display.setCursor(0, 0);
20 display.print(mesaj);
21 display.display();
22}
23
24void setup() {
25 Wire.begin(21, 22); // SDA = 21, SCL = 22
26 display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
27 display.setTextColor(SSD1306_WHITE);
28 yaz("Wi-Fi baglaniyor...");
29
30 WiFi.begin(WIFI_SSID, WIFI_PASS);
31 while (WiFi.status() != WL_CONNECTED) delay(300);
32 configTzTime(TZ_INFO, "pool.ntp.org", "time.cloudflare.com");
33 yaz("NTP bekleniyor...");
34}
35
36void loop() {
37 struct tm t;
38 if (!getLocalTime(&t, 0)) { // 0 = beklemeden dene / try without waiting
39 delay(200);
40 return;
41 }
42 if (t.tm_sec == sonSaniye) { // saniye değişmediyse çizme / redraw only on a new second
43 delay(20);
44 return;
45 }
46 sonSaniye = t.tm_sec;
47
48 char saat[9], tarih[11];
49 strftime(saat, sizeof(saat), "%H:%M:%S", &t);
50 strftime(tarih, sizeof(tarih), "%d.%m.%Y", &t);
51
52 display.clearDisplay();
53 display.setTextSize(1);
54 display.setCursor(0, 0);
55 display.print(GUNLER[t.tm_wday]); // gün adı / day name
56 display.setCursor(68, 0);
57 display.print(tarih); // 10 karakter = 60 piksel / 10 chars = 60 px
58 display.setTextSize(2);
59 display.setCursor(16, 26);
60 display.print(saat); // 8 x 12 = 96 piksel genişlik / 96 px wide
61 display.setTextSize(1);
62 display.setCursor(0, 56);
63 display.print(WiFi.status() == WL_CONNECTED ? "Wi-Fi: var" : "Wi-Fi: yok");
64 display.display();
65}
66Let op dat de dagnamen zonder accenttekens zijn geschreven: het standaardlettertype van Adafruit GFX heeft geen tekens als ş, ç of é en toont in plaats daarvan betekenisloze symbolen. Bij tekstgrootte 2 is elk teken 12 pixels breed; de 8 tekens van "14:05:09" nemen 96 pixels in beslag, dus beginnen bij pixel 16 centreert ze precies op het scherm van 128 pixels. Gebruik je liever een tekens-LCD van 16x2, print dan dezelfde strftime-uitvoer met lcd.print(); de bedrading staat in het bericht I2C LCD-display.
Wat gebeurt er met de tijd als de wifi wegvalt? DS3231 RTC-backup
De meest gestelde vraag is: als de wifi weg is, is de tijd dan ook weg? Nee. Zodra de ESP32 de tijd van NTP heeft, telt hij verder met zijn eigen timer; het verlies van wifi stopt de klok niet. Omdat deze timer op het 40 MHz-kristal loopt, wijkt hij ongeveer een seconde of twee per dag af, en de volgende synchronisatie corrigeert dat zodra de wifi terug is. Het echte probleem is een stroomstoring of een herstart met de EN-knop: dan gaat de systeemtijd terug naar 1970 en kan de ESP32 zonder wifi de tijd niet weten.
| Situatie | Blijft de tijd bewaard? | Wat te doen |
|---|---|---|
| Wifi valt een tijdje weg | Ja, de ESP32 blijft tellen | Niets; NTP corrigeert het als de wifi terugkomt |
| Deep sleep | Ja, de RTC-timer blijft tellen | Synchroniseer bij lange slaapperiodes bij sommige wake-ups opnieuw met NTP |
| Stroomstoring of EN-knop | Nee, de klok gaat terug naar 1970 | Voeg een RTC-module met batterijback-up toe, zoals de DS3231 |
| Helemaal geen internet (veld, magazijn) | NTP komt nooit binnen | Haal de tijd alleen uit een RTC-module |
Tijdens deep sleep wordt de tijd niet door het hoofdkristal geteld, maar door een minder nauwkeurige RC-oscillator in de chip. Deze oscillator wordt beïnvloed door temperatuur, dus bij lange slaapperiodes kan de klok enkele seconden of meer afwijken; in batterijprojecten die uren slapen is het een goede gewoonte om elke paar wake-ups een NTP-synchronisatie uit te voeren. Details staan in het bericht ESP32 deep sleep.

De beste manier om een klok te krijgen die stroomuitval overleeft is beide te combineren: haal bij het opstarten meteen de tijd uit de DS3231-module, corrigeer die met NTP zodra de wifi aanstaat en werk de DS3231 bij na elke NTP-synchronisatie. In de sketch hieronder slaat de DS3231 UTC op in plaats van lokale tijd; zo staat de tijdzoneregel op één plek (de TZ-string) en verstoren zomertijdwijzigingen de RTC nooit. Om de NTP-synchronisatie op te vangen wordt een callback geregistreerd met sntp_set_time_sync_notification_cb(). Omdat deze callback in de netwerktaak draait, gebeurt daar geen I2C-werk; hij zet alleen een vlag en loop() zorgt voor het schrijven naar de DS3231. De sketch gebruikt de bibliotheek RTClib.
1#include <WiFi.h>
2#include <Wire.h>
3#include <RTClib.h>
4#include <sys/time.h>
5#include "esp_sntp.h"
6
7const char* WIFI_SSID = "AgAdi";
8const char* WIFI_PASS = "Sifre123";
9const char* TZ_INFO = "<+03>-3";
10
11RTC_DS3231 rtc;
12volatile bool ntpGeldi = false; // NTP eşitlemesi oldu mu? / did an NTP sync happen?
13
14void ntpCallback(struct timeval* tv) { // her NTP eşitlemesinde çağrılır / called on every NTP sync
15 ntpGeldi = true; // I2C işini loop() yapsın / let loop() do the I2C work
16}
17
18void setup() {
19 Serial.begin(115200);
20 Wire.begin(21, 22);
21 setenv("TZ", TZ_INFO, 1); // NTP gelmese de saat dilimi geçerli / TZ valid even without NTP
22 tzset();
23
24 // 1) Sistem saatini önce DS3231'den kur (DS3231'de UTC saklanır) / set system time from the DS3231 (stores UTC)
25 if (rtc.begin() && !rtc.lostPower()) {
26 struct timeval tv = { (time_t)rtc.now().unixtime(), 0 };
27 settimeofday(&tv, nullptr);
28 Serial.println("Saat DS3231'den / time from DS3231");
29 }
30
31 // 2) Wi-Fi gelince NTP saati düzeltir; bağlantı sonra gelse de SNTP yeniden dener
32 // NTP corrects the clock once Wi-Fi is up; SNTP keeps retrying if the link comes later
33 sntp_set_time_sync_notification_cb(ntpCallback);
34 WiFi.begin(WIFI_SSID, WIFI_PASS);
35 configTzTime(TZ_INFO, "pool.ntp.org", "time.cloudflare.com");
36}
37
38void loop() {
39 if (ntpGeldi) {
40 ntpGeldi = false;
41 rtc.adjust(DateTime((uint32_t)time(nullptr))); // DS3231'e UTC yaz / write UTC to the DS3231
42 Serial.println("DS3231 NTP ile guncellendi / DS3231 updated from NTP");
43 }
44
45 struct tm t;
46 if (getLocalTime(&t, 0)) {
47 Serial.println(&t, "%d.%m.%Y %H:%M:%S");
48 } else {
49 Serial.println("Saat yok: NTP ve DS3231 bekleniyor / no time yet");
50 }
51 delay(1000);
52}
53Elke dag op een vast tijdstip een taak uitvoeren
Het meest voorkomende gebruik van NTP-tijd is een geplande taak: de waterpomp 10 minuten laten draaien om 07:30, de tuinverlichting om 19:00 aanzetten, elk heel uur een meting versturen. De methode is simpel: lees de tijd in loop() en start de taak als uur en minuut overeenkomen met het doel. Het lastige is te voorkomen dat de taak honderden keren binnen dezelfde minuut afgaat. Daarvoor sla je de dag waarop de taak draaide (tm_yday) op in een variabele, zodat hij nooit twee keer op dezelfde dag draait. De sketch hieronder schakelt elke werkdagochtend om 07:30 het relais op GPIO 26 gedurende 10 minuten in; omdat hij de duur meet met millis(), blokkeert de code nooit.
1#include <WiFi.h>
2#include <time.h>
3
4const char* WIFI_SSID = "AgAdi";
5const char* WIFI_PASS = "Sifre123";
6const char* TZ_INFO = "<+03>-3";
7
8const int ROLE_PIN = 26; // röle modülü IN / relay module IN
9const int GOREV_SAAT = 7; // her gün 07:30 / every day at 07:30
10const int GOREV_DAKIKA = 30;
11const unsigned long SURE_MS = 10UL * 60 * 1000; // 10 dakika çalış / run for 10 minutes
12
13int sonGun = -1; // görevin çalıştığı son gün (tm_yday) / last day the task ran
14bool roleAcik = false;
15unsigned long acilisMs = 0;
16
17void setup() {
18 Serial.begin(115200);
19 pinMode(ROLE_PIN, OUTPUT);
20 digitalWrite(ROLE_PIN, LOW);
21 WiFi.begin(WIFI_SSID, WIFI_PASS);
22 while (WiFi.status() != WL_CONNECTED) delay(500);
23 configTzTime(TZ_INFO, "pool.ntp.org");
24}
25
26void loop() {
27 struct tm t;
28 if (getLocalTime(&t, 0)) { // saat geçerliyse / only when the time is valid
29 bool haftaici = (t.tm_wday >= 1 && t.tm_wday <= 5); // Pzt-Cuma / Mon-Fri
30 if (haftaici && t.tm_hour == GOREV_SAAT && t.tm_min == GOREV_DAKIKA && t.tm_yday != sonGun) {
31 sonGun = t.tm_yday; // bugün bir kez / once per day
32 digitalWrite(ROLE_PIN, HIGH);
33 roleAcik = true;
34 acilisMs = millis();
35 Serial.println(&t, "%H:%M gorev basladi / task started");
36 }
37 }
38 if (roleAcik && millis() - acilisMs >= SURE_MS) { // süre dolunca kapat / switch off after the period
39 digitalWrite(ROLE_PIN, LOW);
40 roleAcik = false;
41 Serial.println("Gorev bitti / task finished");
42 }
43 delay(200);
44}
45- Op seconden vergelijken: een voorwaarde als t.tm_sec == 0 slaat de taak over als de lus die seconde mist (terwijl de wifi opnieuw verbindt of tijdens een lange delay). Het controleren van minuut en dag is veiliger.
- Op een geldige tijd controleren: voer geen taken uit zolang getLocalTime() false teruggeeft, anders neem je direct na het opstarten verkeerde beslissingen op basis van 1970.
- Gemiste taken: valt de stroom uit om 07:29 en komt hij terug om 07:35, dan draait de taak die dag niet. Als dat uitmaakt, schrijf de voorwaarde dan als "het is na 07:30 en hij heeft vandaag nog niet gedraaid" en sla sonGun met Preferences op in het flashgeheugen.
- Meerdere taken: bewaar het uur, de minuut en de duur in een array en gebruik voor elke taak een aparte variabele voor de laatste uitvoerdag.
- Belastingen met hoge stroom: stuur een pomp of lamp aan via een relaismodule of een MOSFET, nooit rechtstreeks vanaf een pin.
Het synchronisatie-interval wijzigen en NTP bewaken
Het standaardinterval van 3 uur past bij de meeste projecten. Wil je vaker synchroniseren (bijvoorbeeld buiten bij grote temperatuurschommelingen) of juist minder verkeer, geef dan het nieuwe interval in milliseconden mee aan sntp_set_sync_interval(). Roep het aan vóór configTzTime(), want het nieuwe interval gaat in bij de volgende start of als het huidige interval verloopt. Volgens de protocolregels kan het interval niet korter zijn dan 15 seconden. sntp_get_sync_status() geeft eenmaal SNTP_SYNC_STATUS_COMPLETED terug nadat een synchronisatie is voltooid en reset zichzelf daarna, zodat je elke nieuwe synchronisatie kunt opvangen.
1#include <WiFi.h>
2#include <time.h>
3#include "esp_sntp.h"
4
5const char* TZ_INFO = "<+03>-3";
6
7void setup() {
8 Serial.begin(115200);
9 WiFi.begin("AgAdi", "Sifre123");
10 while (WiFi.status() != WL_CONNECTED) delay(500);
11
12 sntp_set_sync_interval(6UL * 60 * 60 * 1000); // 6 saatte bir eşitle (en az 15 sn) / sync every 6 hours (min 15 s)
13 configTzTime(TZ_INFO, "pool.ntp.org"); // ayar sntp_init() öncesi verilir / set before sntp_init()
14}
15
16void loop() {
17 if (sntp_get_sync_status() == SNTP_SYNC_STATUS_COMPLETED) {
18 Serial.println("Yeni NTP esitlemesi / new NTP sync");
19 }
20 delay(1000);
21}
22Welke NTP-server kun je gebruiken?
De meest gebruikte keuze is pool.ntp.org: een pool van duizenden servers van vrijwilligers wereldwijd, die bij elk verzoek het adres van een server bij jou in de buurt geeft. Landsubdomeinen (uk.pool.ntp.org, de.pool.ntp.org) halen de server nog dichterbij. configTzTime() accepteert maximaal drie servernamen; antwoordt de eerste niet, dan gaat hij door naar de volgende.
| Server | Kenmerk | Opmerking |
|---|---|---|
| pool.ntp.org | Vrijwilligerspool, dichtstbijzijnde server | Eerste keuze voor algemeen gebruik |
| uk.pool.ntp.org / europe.pool.ntp.org | Pool van een land of continent | Iets lagere latentie |
| time.cloudflare.com | Infrastructuur van een groot bedrijf | Goed als backupserver |
| time.google.com | Verdeelt schrikkelseconden over de tijd (leap smear) | Meng hem niet met andere servers |
| Het IP-adres van je router | Sommige routers bieden lokale NTP aan | Handig op een lokaal netwerk zonder internet |
NTP op de Raspberry Pi Pico W: ntptime
Op de Raspberry Pi Pico W (en Pico 2 W) gebeurt hetzelfde met de ntptime-module van MicroPython. ntptime.settime() vraagt de NTP-server en zet de interne RTC van de Pico op UTC. MicroPython heeft geen tijdzonestring zoals de ESP32; voor lokale tijd tel je je offset in seconden op bij UTC (3 × 3600 voor UTC+3 in het voorbeeld). ntptime haalt de tijd maar één keer op en synchroniseert niet automatisch; in langlopende projecten verhelpt het één of twee keer per dag aanroepen van settime() de afwijking. De RTC van de Pico W wordt ook gereset bij stroomuitval, dus dezelfde DS3231-backup geldt hier. Hoe je de Pico W met wifi verbindt, staat uitgebreid in het bericht Pico W wifi en webserver.
1import network
2import ntptime
3import time
4
5SSID = "AgAdi"
6PASS = "Sifre123"
7UTC_OFFSET = 3 * 3600 # Türkiye UTC+3 / Turkey UTC+3
8# localtime(): 0 = Pazartesi / 0 = Monday
9GUNLER = ("Pazartesi", "Sali", "Carsamba", "Persembe", "Cuma", "Cumartesi", "Pazar")
10
11wlan = network.WLAN(network.STA_IF)
12wlan.active(True)
13wlan.connect(SSID, PASS)
14while not wlan.isconnected(): # bağlanana kadar bekle / wait until connected
15 time.sleep(0.5)
16
17ntptime.host = "pool.ntp.org"
18for deneme in range(5): # NTP bazen zaman aşımına uğrar / NTP may time out
19 try:
20 ntptime.settime() # dahili RTC'yi UTC'ye ayarlar / sets the internal RTC to UTC
21 break
22 except OSError:
23 time.sleep(2)
24
25def yerel_saat(): # UTC + 3 saat / UTC + 3 hours
26 return time.localtime(time.time() + UTC_OFFSET)
27
28son_gun = -1
29while True:
30 yil, ay, gun, saat, dk, sn, hgun, ygun = yerel_saat()
31 print("{:02d}.{:02d}.{} {} {:02d}:{:02d}:{:02d}".format(gun, ay, yil, GUNLER[hgun], saat, dk, sn))
32 if saat == 7 and dk == 30 and ygun != son_gun: # her gün 07:30'da bir kez / once a day at 07:30
33 son_gun = ygun
34 print("Gorev calisti / task ran")
35 time.sleep(1)
36In MicroPython geeft time.localtime() een tuple van acht elementen terug: jaar, maand (1–12), dag, uur, minuut, seconde, weekdag en dag van het jaar. Het verschilt op twee punten van de struct tm van de ESP32: de maand begint bij 1 en de weekdag telt 0 = maandag. ntptime.settime() geeft OSError als het netwerk een time-out geeft, daarom heeft de sketch een lus met vijf pogingen.
Ideeën voor ESP32 NTP-klokprojecten
- Wifi-bureauklok: toon de tijd, datum en kamertemperatuur op één OLED-display en dim het 's nachts.
- Gigantische ledklok: toon de NTP-tijd als scrollende tekst op een MAX7219-ledmatrix.
- Planten op tijd water geven: controleer elke ochtend de bodemvochtigheid en laat zo nodig een minipomp een ingestelde tijd draaien.
- Datalogging met tijdstempel: schrijf sensormetingen met ISO-datums naar een SD-kaart.
- Weerklok: voeg het weer dat je van internet haalt toe naast de tijd; het bericht ESP32-weer gaat hier verder.
- Ochtendrapport: stuur elke dag om 08:00 de temperatuur in huis en de 's nachts gedetecteerde beweging via Telegram naar je telefoon.
Veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Tijd toont 1970 of komt nooit binnen | Wifi is niet verbonden of de NTP-poort (UDP 123) is geblokkeerd | Controleer eerst WiFi.status(); probeer op school- en kantoornetwerken een ander netwerk of een hotspot van je telefoon |
| Tijd loopt precies je UTC-offset af | Geen tijdzone ingesteld, UTC wordt getoond | configTzTime("<+03>-3", ...) of de string voor jouw zone |
| Tijd loopt tweemaal de offset af | Omgekeerd teken in de TZ-string ("UTC+3") | Gebruik "<+03>-3" of "UTC-3" voor UTC+3 |
| Maand is er één te weinig, jaar is 126 | tm_mon telt vanaf 0, tm_year vanaf 1900 | Gebruik tm_mon + 1, tm_year + 1900 of strftime |
| Taak gaat vaak af binnen dezelfde minuut | Geen bescherming tegen herhaling | Sla de dag van uitvoering op (tm_yday) en controleer die |
| Lus loopt bij elke ronde 5 seconden vast | Zonder geldige tijd wacht getLocalTime() standaard 5000 ms | Gebruik getLocalTime(&t, 0) in loop() |
| Vreemde symbolen in de dagnaam op de OLED | Het lettertype heeft geen letters met accenten | Schrijf dagnamen in gewone ASCII of schakel over op de bibliotheek U8g2 |
ESP32 NTP is de goedkoopste en makkelijkste manier om nauwkeurige tijd aan een project toe te voegen: met een paar regels code heb je de tijd op de seconde nauwkeurig, regelt hij tijdzone en zomertijd zelf, en met een DS3231 erbij overleeft hij ook stroomuitval. In de BlueGrays-app vind je stapsgewijze projecten met schakelschema's en code voor een realtimeklok via ESP32 NTP, een digitale klok met een DS1307 RTC, een weerdisplay op een OLED en een temperatuurlogger met tijdstempels.
Veelgestelde vragen
Kan de ESP32 de tijd bijhouden zonder internet?
Ja, zodra hij de tijd van NTP heeft ontvangen: de ESP32 telt de systeemtijd verder met zijn eigen timer en het verlies van wifi stopt de klok niet. Valt de stroom echter uit of herstart het board, dan gaat de tijd terug naar 1970. Voeg op plekken zonder internet, of voor een klok die stroomuitval overleeft, een RTC-module met batterijback-up toe, zoals de DS3231.
Waarom loopt mijn ESP32 NTP-tijd een paar uur af?
Als er geen tijdzone is ingesteld, toont de ESP32 UTC, dus de klok loopt precies je UTC-offset af. Gebruik configTzTime met de juiste POSIX-string, bijvoorbeeld "CET-1CEST,M3.5.0,M10.5.0/3" voor Midden-Europa of "GMT0BST,M3.5.0/1,M10.5.0" voor het VK. Loopt hij tweemaal de offset af, dan is het teken in je TZ-string omgekeerd.
Wat is het verschil tussen configTime en configTzTime?
configTime neemt de UTC-offset en een zomertijdoffset in seconden, maar weet niet wanneer de zomertijd in jouw regio begint en eindigt. configTzTime neemt een POSIX-tijdzonestring met de zomertijdregels, zodat de ESP32 automatisch tussen zomer- en wintertijd schakelt. Voor elke regio met zomertijd is configTzTime de juiste keuze.
Hoe vaak synchroniseert de ESP32 met NTP?
In de Arduino ESP32-core vraagt SNTP standaard elke 3 uur opnieuw bij de server en houdt hij tussendoor de tijd bij met zijn eigen timer. Je kunt het interval in milliseconden wijzigen met sntp_set_sync_interval(), maar volgens de protocolregels kan het niet korter zijn dan 15 seconden.
Heb ik een RTC-module nodig bij de ESP32?
Niet als het apparaat altijd stroom heeft en wifi kan bereiken; NTP geeft nauwkeurigere tijd. Heb je na een stroomstoring de juiste tijd nodig voordat het internet terug is, of draait het apparaat ergens zonder internet, voeg dan een RTC-module met batterijback-up toe, zoals de DS3231.
Hoe krijg ik NTP-tijd op de Raspberry Pi Pico W?
Voer in MicroPython na het verbinden met wifi gewoon import ntptime en ntptime.settime() uit; dit zet de interne RTC van de Pico op UTC. Voor lokale tijd tel je je offset in seconden op, bijvoorbeeld time.localtime(time.time() + 3600) voor UTC+1. ntptime synchroniseert niet automatisch, dus roep settime() één of twee keer per dag opnieuw aan.
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.

Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)
In dit project tonen we de tijd en de datum op een 16x2 I2C-LCD met de DS1307 realtimeklok-module (RTC). De DS1307 is een RTC met batterijback-up die de tijd bijhoudt, ook als de ESP32 uit staat. Beide modules delen dezelfde I2C-bus (SDA/SCL), zodat je leert hoe je met slechts twee signaaldraden meerdere apparaten bestuurt. Met dit project krijg je praktische kennis van het I2C-communicatieprotocol, de werking van RTC-modules en het dynamisch tonen van gegevens op een LCD.

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 HTTPClient + weer-API (met SSD1306 OLED-display)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Anders dan bij de I2C-LCD-versie gebruiken we hier een SSD1306 OLED-display (128×64), met grote tekst en vectoricoontjes voor een rijkere weergave. Zeven weericonen (zonnig, regenachtig, sneeuw en meer) worden direct getekend, zonder bitmapbestanden.

ESP32 HTTPClient + weer-API (met lcd-scherm)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Het JSON-antwoord wordt verwerkt met ArduinoJson v7 en stad, temperatuur, luchtvochtigheid, weer en wind verschijnen op een I2C-LCD. wttr.in vraagt geen API-sleutel; typ gewoon de naam van een willekeurige stad.

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

ESP32 I2C-LCD-display (16x2)
In dit project sluit je een 16x2-tekens-LCD via I2C aan op de ESP32 en toon je tekst. Met I2C bedien je het scherm met slechts 2 datapinnen (SDA en SCL), in plaats van de 6+ pinnen die een klassieke parallelle aansluiting verspilt. De code toont op de eerste regel een vaste tekst en op de tweede regel een teller die elke seconde oploopt. Bij het opstarten schrijft een I2C-scanner ook het adres van het display naar de Serial Monitor (meestal 0x27 of 0x3F).
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

