Gidsen · 14 min leestijd

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.

ESP32-ontwikkelboard
ESP32 DevKit: dankzij de ingebouwde wifi haalt het de tijd op bij NTP-servers en houdt het datum en tijd bij zonder aparte klokmodule.

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.

BegripWaarde / uitleg
Protocol en poortSNTP, UDP 123
TijdstempelSeconden sinds 1900 (de ESP32 zet dit om naar Unix-tijd, die op 1970 is gebaseerd)
Typische nauwkeurigheid10–50 ms op een thuisverbinding
HersynchronisatieStandaard 3 uur in Arduino ESP32, te wijzigen met sntp_set_sync_interval() (minimaal 15 s)
Maximaal aantal servers3 (de servernamen die je aan configTzTime meegeeft)
InternetverkeerVerzoek en antwoord zijn elk een NTP-pakket van 48 byte; hooguit een paar kilobyte per dag
Wat je nodig hebtESP32, 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.

RegioTZ-string (configTzTime)Equivalent in configTime
Turkije (het hele jaar UTC+3)<+03>-3configTime(10800, 0, ...)
Duitsland, Frankrijk, Italië, SpanjeCET-1CEST,M3.5.0,M10.5.0/3Niet geschikt, gebruik configTzTime
VK, PortugalGMT0BST,M3.5.0/1,M10.5.0Niet geschikt, gebruik configTzTime
US Eastern (New York)EST5EDT,M3.2.0,M11.1.0Niet geschikt, gebruik configTzTime
Azerbeidzjan, Georgië (UTC+4)<+04>-4configTime(14400, 0, ...)
UTC (voor tijdstempels)UTC0configTime(0, 0, ...)
Het teken in een POSIX-tijdzonestring is omgekeerd: als je "UTC+3" of "GMT+3" schrijft voor een UTC+3-zone, leest de ESP32 dat als "3 uur achter op UTC" en loopt de klok 6 uur af. De juiste string is "<+03>-3" of "UTC-3". Midden-Europa is ook "CET-1...", niet "CET+1". Loopt je klok precies 3 of 6 uur af, dan ligt het bijna altijd aan het teken.

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 onderdeelESP32Raspberry Pi Pico WOpmerking
OLED / DS3231 VCC3V33V3 (OUT)Beide werken op 3,3 V
OLED / DS3231 GNDGNDGNDGemeenschappelijke massa
OLED / DS3231 SDAGPIO 21GP4I2C-datalijn
OLED / DS3231 SCLGPIO 22GP5I2C-klokllijn
IN van de relaismoduleGPIO 26GP15Voorbeeld van de geplande taak
VCC van de relaismodule5V (VIN)VBUSDe meeste relaisspoelen hebben 5 V nodig
De ESP32 verbindt alleen met 2,4 GHz-wifinetwerken. Gebruikt je router dezelfde naam voor 5 GHz en 2,4 GHz, of bevat de netwerknaam speciale tekens, dan kan de verbinding mislukken. Komt de tijd nooit binnen, controleer dan eerst in de Serial Monitor of de wifi verbonden is; NTP werkt pas als de wifi aanstaat.

Stap voor stap: je eerste ESP32 NTP-sketch

  1. 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.
  2. Je hebt geen extra bibliotheek nodig: WiFi.h en time.h zitten in de ESP32-core.
  3. Vervang de waarden WIFI_SSID en WIFI_PASS door die van je eigen netwerk en TZ_INFO door je tijdzone uit de tabel hierboven.
  4. Upload de sketch en open de Serial Monitor op 115200 baud.
  5. Je ziet eerst wifi-puntjes en na een paar seconden de datum en tijd, die elke seconde worden bijgewerkt.
C++ (Arduino IDE)
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
RegelWat 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.

VeldBereikVoorbeeld (maandag 16 november 2026, 14:05:09)
tm_sec0–59 (60 bij een schrikkelseconde)9
tm_min0–595
tm_hour0–2314
tm_mday1–3116
tm_mon0–11 (0 = januari)10
tm_yearJaren sinds 1900126 (1900 + 126 = 2026)
tm_wday0–6 (0 = zondag)1
tm_yday0–365 (dag van het jaar, vanaf 0)319
Toont het scherm "16.10.2026" terwijl het november is, dan ben je vergeten 1 bij tm_mon op te tellen. Zie je het jaar als 126, dan heb je tm_year + 1900 nodig. Gebruik je strftime, dan doet die deze omrekeningen voor je.

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:

CodeBetekenisVoorbeelduitvoer
%H / %M / %SUur (00–23) / minuut / seconde14 / 05 / 09
%I en %p12-uursklok en AM/PM02 PM
%d / %m / %YDag / maand (01–12) / jaar met vier cijfers16 / 11 / 2026
%yJaar met twee cijfers26
%A / %aNaam van de weekdag, lang / kort (Engels)Monday / Mon
%B / %bNaam van de maand, lang / kort (Engels)November / Nov
%jDag van het jaar (001–366)320
%F / %TAfkortingen voor %Y-%m-%d / %H:%M:%S2026-11-16 / 14:05:09
%ZAfkorting 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.

C++ (Arduino IDE)
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}
34
Schrijf de datum bij het loggen van data (SD-kaart, Google Sheets, een server) altijd als %Y-%m-%d %H:%M:%S of als ruwe Unix-tijd. Dit formaat sorteert alfabetisch ook chronologisch, en Excel en databases herkennen het als datum. Op het scherm kun je nog steeds een lokaal formaat gebruiken.

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

C++ (Arduino IDE)
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}
66

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

SituatieBlijft de tijd bewaard?Wat te doen
Wifi valt een tijdje wegJa, de ESP32 blijft tellenNiets; NTP corrigeert het als de wifi terugkomt
Deep sleepJa, de RTC-timer blijft tellenSynchroniseer bij lange slaapperiodes bij sommige wake-ups opnieuw met NTP
Stroomstoring of EN-knopNee, de klok gaat terug naar 1970Voeg een RTC-module met batterijback-up toe, zoals de DS3231
Helemaal geen internet (veld, magazijn)NTP komt nooit binnenHaal 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.

RTC-klokmodule
RTC-module met batterijback-up: hij blijft tellen, ook als de ESP32 zonder stroom valt, zodat je de tijd daarvan kunt halen tot de wifi terug is.

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.

C++ (Arduino IDE)
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}
53
De DS1307 werkt met dezelfde code (schrijf RTC_DS1307 en gebruik isrunning in plaats van lostPower), maar kan een minuut of twee per maand afwijken. Dankzij het temperatuurgecompenseerde kristal blijft de DS3231 binnen ongeveer een minuut per jaar. Voor de verschillen tussen modules en de valkuil van de oplaadschakeling voor de batterij, zie het bericht Arduino RTC-module.

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

C++ (Arduino IDE)
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.
GPIO-pins van de ESP32 leveren 3,3 V en kunnen maar enkele tientallen milliampère leveren. De IN-ingang van een relaismodule schakelt meestal bij 3,3 V, maar sommige 5 V-relaisboards schakelen mogelijk niet betrouwbaar; gebruik dan een board met een 3,3 V-trigger of een transistordriver. Als je aan de netspanningskant werkt, raak de bedrading dan nooit aan terwijl de schakeling aangesloten is.

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.

C++ (Arduino IDE)
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}
22

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

ServerKenmerkOpmerking
pool.ntp.orgVrijwilligerspool, dichtstbijzijnde serverEerste keuze voor algemeen gebruik
uk.pool.ntp.org / europe.pool.ntp.orgPool van een land of continentIets lagere latentie
time.cloudflare.comInfrastructuur van een groot bedrijfGoed als backupserver
time.google.comVerdeelt schrikkelseconden over de tijd (leap smear)Meng hem niet met andere servers
Het IP-adres van je routerSommige routers bieden lokale NTP aanHandig op een lokaal netwerk zonder internet
Lever je een eigen product uit aan honderden apparaten, dan is het goede praktijk om een pool onder je eigen naam te nemen (een vendor zone) in plaats van pool.ntp.org, of om de opstarttijd van de apparaten willekeurig te maken. Duizenden apparaten die in dezelfde seconde de servers bevragen belasten de servers van vrijwilligers zwaar.

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.

Python
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)
36

In 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

SymptoomWaarschijnlijke oorzaakOplossing
Tijd toont 1970 of komt nooit binnenWifi is niet verbonden of de NTP-poort (UDP 123) is geblokkeerdControleer eerst WiFi.status(); probeer op school- en kantoornetwerken een ander netwerk of een hotspot van je telefoon
Tijd loopt precies je UTC-offset afGeen tijdzone ingesteld, UTC wordt getoondconfigTzTime("<+03>-3", ...) of de string voor jouw zone
Tijd loopt tweemaal de offset afOmgekeerd teken in de TZ-string ("UTC+3")Gebruik "<+03>-3" of "UTC-3" voor UTC+3
Maand is er één te weinig, jaar is 126tm_mon telt vanaf 0, tm_year vanaf 1900Gebruik tm_mon + 1, tm_year + 1900 of strftime
Taak gaat vaak af binnen dezelfde minuutGeen bescherming tegen herhalingSla de dag van uitvoering op (tm_yday) en controleer die
Lus loopt bij elke ronde 5 seconden vastZonder geldige tijd wacht getLocalTime() standaard 5000 msGebruik getLocalTime(&t, 0) in loop()
Vreemde symbolen in de dagnaam op de OLEDHet lettertype heeft geen letters met accentenSchrijf dagnamen in gewone ASCII of schakel over op de bibliotheek U8g2
Om een probleem te isoleren draai je eerst de eerste sketch, die de tijd alleen naar de Serial Monitor print. Is de tijd daar goed, dan zit het probleem in het display, de RTC of de taaklogica; is hij daar ook fout, kijk dan naar de wifi en de tijdzone-instelling.

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.

Alle projecten bekijken
Echte tijd van internet met ESP32 en NTP
ES-26Gevorderd
Premium

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.

4.5(13)
22
Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)
ES-18Gemiddeld
Premium

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.

4.6(26)
40
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
ES-25Gevorderd

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.

4.4(21)
38
ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
ES-32Gevorderd
Premium

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.

4.3(10)
22
ESP32 HTTPClient + weer-API (met lcd-scherm)
ES-31Gevorderd
Premium

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.

4.7(13)
20
ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

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.

4.3(10)
16
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

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.

4.7(7)
12
ESP32 I2C-LCD-display (16x2)
ES-17Gemiddeld
Premium

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

4.9(23)
40