Arduino RTC-module: DS3231 vs DS1307 vs DS1302, tijd en alarmen
Arduino RTC-module gids: DS3231 vs DS1307 vs DS1302, de tijd instellen met RTClib, een LCD-klok, geplande bewatering, de oplaadval van de CR2032 en ESP32 NTP.
Een Arduino RTC-module is een klein klokboard dat de datum en tijd blijft bijhouden, ook als je board geen stroom meer krijgt. RTC staat voor "Real Time Clock". De millis()-teller van de Arduino begint bij elke start weer bij nul en kan binnen een paar dagen minuten afwijken, terwijl een RTC-module dankzij de knoopcel (CR2032) jarenlang op de seconde nauwkeurig doorloopt. Je vindt deze module in bureauklokken, automatische bewateringssystemen, voerautomaten voor huisdieren, dataloggers met tijdstempel en projecten met tijdgestuurde verlichting.
In deze gids vergelijk je de drie meest gebruikte chips, de DS1307, DS3231 en DS1302, en zie je welke je moet kiezen en waarom. Daarna stellen we stap voor stap de tijd in en lezen we die uit met de RTClib-bibliotheek, tonen we tijd en datum op een I2C-LCD, bouwen we een timer die elke dag op vaste tijden een pomp laat draaien en gebruiken we het hardwarealarm van de DS3231. De laatste delen gaan over de oplaadval van de CR2032 die veel modules om zeep helpt, de tijd van internet halen met NTP op de ESP32 en de ingebouwde RTC van de Raspberry Pi Pico.

Wat is een RTC-module en hoe werkt die?
In het hart van een RTC-chip zit een horlogekristal van 32.768 kHz. Dat getal is geen toeval: 32.768 is 2 tot de macht 15, dus de chip halveert deze frequentie 15 keer om een exacte tik van 1 seconde te krijgen. Bij elke tik worden de registers voor seconden, minuten, uren, dag, maand en jaar bijgewerkt; maandlengtes en schrikkeljaren worden tot het jaar 2100 automatisch verwerkt. De Arduino leest deze registers via I2C of schrijft er een nieuwe tijd in. De waarden worden opgeslagen in BCD-formaat (59 seconden staat bijvoorbeeld als 0x59 opgeslagen); de bibliotheken regelen die omzetting voor je.
De echte kracht van een RTC zijn de twee voedingsingangen. Als VCC wegvalt, schakelt de chip automatisch over op de batterij-ingang (VBAT) en neemt alleen net genoeg stroom op om te blijven tellen: minder dan een microampère of enkele microampères. Ondertussen sluit de DS1307 de I2C-toegang af, terwijl de DS3231 op batterij nog wel uit te lezen is; in beide gevallen stopt de klok niet. Als de stroom terugkomt, start de Arduino op, leest de juiste tijd uit de RTC en gaat verder waar hij gebleven was. Door de tolerantie van de keramische resonator op de Arduino Uno kan een klok die met millis() wordt bijgehouden per dag minuten afwijken en gaat die bij elke reset verloren. Daarom heeft elk tijdgebonden project een aparte RTC nodig.
DS1307 vs DS3231 vs DS1302: de verschillen
| Eigenschap | DS1307 | DS3231 | DS1302 |
|---|---|---|---|
| Interface | I2C (100 kHz), adres 0x68 | I2C (tot 400 kHz), adres 0x68 | 3-draads serieel: CE (RST), I/O (DAT), SCLK (CLK) |
| Voedingsspanning | 4,5–5,5 V | 2,3–5,5 V | 2,0–5,5 V |
| Kristal | Extern 32.768 kHz (12,5 pF) | Ingebouwd in de chip, temperatuurgecompenseerd (TCXO) | Extern 32.768 kHz (6 pF) |
| Nauwkeurigheid | Hangt af van het kristal; bij ±20 ppm ongeveer 1,7 s/dag, ongeveer 1 min/maand | ±2 ppm (0–40 °C): ongeveer 5 s/maand, ongeveer 1 min/jaar | Hangt af van het kristal; vergelijkbaar met de DS1307 of slechter |
| Extra's | 56 bytes RAM met batterijback-up, blokgolfuitgang (SQW) | 2 alarmen, INT/SQW-uitgang, temperatuursensor (±3 °C), aging-trim | 31 bytes RAM, ingebouwde druppellader |
| Batterijstroom | Ongeveer 300–500 nA | Ongeveer 1–3 µA | Minder dan 300 nA bij 2 V |
| Arduino-bibliotheek | RTClib (Adafruit) | RTClib (Adafruit) | Rtc by Makuna |
| Het best voor | Eenvoudige 5V-klokprojecten | Bijna elk project; ook ideaal voor de ESP32 en Pico | Oudere kits en leerprojecten |
Laten we het verschil in nauwkeurigheid concreet maken: 1 ppm is één deel per miljoen en een dag heeft 86.400 seconden. Een gewoon kristal van ±20 ppm kan tot 1,7 seconde per dag afwijken, ongeveer 52 seconden per maand, en hoe verder je van kamertemperatuur af komt, hoe meer de frequentie van het kristal verandert en hoe groter de fout. De DS3231 heeft zijn kristal daarentegen in de chip zitten, meet elke 64 seconden de temperatuur en corrigeert de frequentie daarop. Dat geeft ±2 ppm tussen 0 en 40 °C, ongeveer een minuut per jaar, en hij blijft binnen ±3,5 ppm, zelfs van -40 tot +85 °C.
Welke RTC-module moet ik kiezen?
- Een nieuw project, ESP32 of Pico: neem een DS3231. Hij werkt op zowel 3,3 V als 5 V, heeft alarmen en houdt de nauwkeurigste tijd bij. Het prijsverschil is minimaal.
- Je hebt al een DS1307 en gebruikt een Arduino Uno: gebruik hem gerust; houd alleen rekening met ongeveer een minuut afwijking per maand en corrigeer de tijd af en toe.
- Je starterskit bevatte een DS1302: prima om te leren hoe een RTC werkt, maar verwacht geen klok die maandenlang nauwkeurig blijft.
- ESP32 met een permanente internetverbinding: begin met NTP en zonder module; voeg een DS3231 toe als de tijd na een stroomstoring bekend moet zijn voordat het internet terug is.
Je komt vooral twee kant-en-klare boards tegen: de ZS-042 met een DS3231-chip en de Tiny RTC met een DS1307. Beide hebben ook een AT24C32 EEPROM van 4 KB om gegevens in op te slaan. Daarom is het normaal dat je naast 0x68 een tweede adres ziet als je een I2C-scanner draait (meestal 0x57 op de ZS-042 en 0x50 op de Tiny RTC); dat adres hoort bij de EEPROM, niet bij de klok. De DS1302 gebruikt helemaal geen I2C: hij praat via zijn eigen 3-draads protocol en neemt drie digitale pins in beslag.
Bedrading van de RTC-module: Arduino Uno, ESP32 en Pico
| RTC-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V | 3V3 (DS3231) | 3V3(OUT), fysieke pin 36 (DS3231) |
| GND | GND | GND | GND |
| SDA | A4 | GPIO 21 | GP4 (I2C0) |
| SCL | A5 | GPIO 22 | GP5 (I2C0) |
| SQW / INT (optioneel) | D2 (interruptpin) | Elke GPIO (bijv. GPIO 4) | Elke GP-pin (bijv. GP15) |
Op de Uno R3 zijn de SDA- en SCL-headers naast de AREF-pin ook verbonden met A4 en A5, dus het maakt niet uit welke je gebruikt. De RTC kan dezelfde twee draden delen met een I2C-LCD of OLED-display; elk apparaat heeft een eigen adres, dus er is geen conflict. Draden korter dan 20–30 cm voorkomen willekeurige leesfouten, vooral op een breadboard. Je hoeft de SQW/INT-pin alleen aan te sluiten als je het hardwarealarm wilt gebruiken.
RTClib installeren en de tijd instellen
- Open de Library Manager in de Arduino IDE, typ RTClib en installeer de bibliotheek van Adafruit. Kies bij de vraag over afhankelijkheden voor Install all, zodat ook Adafruit BusIO wordt geïnstalleerd. Heb je nog nooit een bibliotheek toegevoegd, dan helpt Een bibliotheek toevoegen in Arduino je op weg.
- Sluit de module aan zoals in de tabel hierboven en plaats de batterij in de houder.
- Upload de onderstaande code. Bij de eerste start kent de module de tijd niet, dus de code schrijft de compileertijd van je computer in de RTC.
- Open de Serial Monitor op 9600 baud met het regeleinde "Newline". Om de tijd op de seconde nauwkeurig te corrigeren typ je hem als 2026-11-03 14:30:00 en druk je op Enter.
- Haal de USB-kabel los, wacht een paar minuten en steek hem er weer in. Als de klok correct doorloopt vanaf waar hij was, werkt de batterijback-up.
1#include <Wire.h>
2#include <RTClib.h>
3
4RTC_DS3231 rtc; // DS1307 kullanıyorsan: RTC_DS1307 rtc; / for a DS1307: RTC_DS1307 rtc;
5
6void setup() {
7 Serial.begin(9600);
8 if (!rtc.begin()) { // modül I2C hattında yok / module not found on the I2C bus
9 Serial.println(F("RTC bulunamadi / RTC not found"));
10 while (true);
11 }
12 if (rtc.lostPower()) { // ilk çalıştırma ya da pil bitmiş / first run or dead battery
13 rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // derleme saatini yaz / write the compile time
14 Serial.println(F("Saat derleme zamanina ayarlandi / Clock set to compile time"));
15 }
16 Serial.println(F("Ayar icin yaz / To set, type: 2026-11-03 14:30:00"));
17}
18
19void loop() {
20 // Seri monitörden saat geldiyse ayarla / set the time sent from the Serial Monitor
21 if (Serial.available()) {
22 String line = Serial.readStringUntil('\n');
23 int y, mo, d, h, mi, s;
24 if (sscanf(line.c_str(), "%d-%d-%d %d:%d:%d", &y, &mo, &d, &h, &mi, &s) == 6) {
25 rtc.adjust(DateTime(y, mo, d, h, mi, s));
26 Serial.println(F("Saat ayarlandi / Time set"));
27 }
28 }
29
30 DateTime now = rtc.now();
31 char buf[] = "DD.MM.YYYY hh:mm:ss"; // biçim şablonu / format template
32 Serial.print(now.toString(buf));
33 Serial.print(F(" "));
34 Serial.print(rtc.getTemperature()); // yalnız DS3231 / DS3231 only
35 Serial.println(F(" C"));
36 delay(1000);
37}rtc.begin() geeft false terug als de module niet op de I2C-bus wordt gevonden; controleer in dat geval eerst de bedrading. rtc.lostPower() leest de oscillator stop flag (OSF) van de DS3231: hij geeft true terug als de module voor het eerst draait of als de klok is gestopt doordat de batterij leeg raakte, en de code zet de klok dan op de compileertijd. DateTime(F(__DATE__), F(__TIME__)) gebruikt het moment waarop de compiler je code bouwde; omdat het uploaden een paar seconden duurt, loopt de klok iets achter, dus bijstellen via de Serial Monitor is handig. toString() vervangt de letters in het sjabloon "DD.MM.YYYY hh:mm:ss" door de echte waarden.
| Functie | Wat het doet |
|---|---|
| rtc.begin() | Start de module; geeft false terug als hij niet wordt gevonden |
| rtc.adjust(DateTime(...)) | Schrijft de tijd en datum |
| rtc.now() | Leest de huidige tijd als DateTime-object |
| now.year(), now.month(), now.day() | Jaar, maand, dag |
| now.hour(), now.minute(), now.second() | Uur (0–23), minuut, seconde |
| now.dayOfTheWeek() | Dag van de week: 0 = zondag, 6 = zaterdag |
| now.unixtime() | Seconden sinds 1 januari 1970; ideaal om twee tijden te vergelijken |
| now + TimeSpan(0, 1, 30, 0) | Telt 1 uur 30 minuten op (dagen, uren, minuten, seconden) |
| rtc.lostPower() / rtc.isrunning() | Geeft aan of de tijd geldig is (DS3231 / DS1307) |
| rtc.getTemperature() | Chiptemperatuur in °C (alleen DS3231) |
Gebruik je een DS1307, dan is het enige verschil de objectnaam: schrijf RTC_DS1307 rtc;, gebruik een !rtc.isrunning()-controle in plaats van lostPower() en verwijder de regel met getTemperature(). Als een DS1307 voor het eerst van stroom wordt voorzien, staat zijn oscillator stil (CH-bit op 1); adjust() wist deze bit en start de klok. Met rtc.writenvram() en rtc.readnvram() kun je kleine instellingen, zoals een alarmtijd, opslaan in de 56 bytes RAM met batterijback-up van de DS1307; dankzij de batterij overleven die gegevens ook stroomstoringen.
Tijd en datum tonen op een LCD
De tijd op een display zien in plaats van in de Serial Monitor maakt van het project een echte bureauklok. Een 16x2 I2C-LCD en de RTC worden op dezelfde SDA-SCL-bus aangesloten: de LCD zit meestal op adres 0x27 of 0x3F en de RTC op 0x68. De onderstaande code schrijft de datum en de afkorting van de dag op de bovenste regel, en de tijd plus de door de DS3231 gemeten temperatuur op de onderste regel. Voor de bedrading van de LCD en het installeren van de bibliotheek kijk je in Een I2C-LCD-display gebruiken.
1#include <Wire.h>
2#include <RTClib.h>
3#include <LiquidCrystal_I2C.h>
4
5RTC_DS3231 rtc;
6LiquidCrystal_I2C lcd(0x27, 16, 2); // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8// dayOfTheWeek(): 0 = Pazar / 0 = Sunday
9const char* const days[7] = {"Paz", "Pzt", "Sal", "Car", "Per", "Cum", "Cmt"};
10int lastSecond = -1;
11
12void setup() {
13 lcd.init();
14 lcd.backlight();
15 if (!rtc.begin()) {
16 lcd.print("RTC yok!"); // modül bulunamadı / module not found
17 while (true);
18 }
19 if (rtc.lostPower()) rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
20}
21
22void loop() {
23 DateTime now = rtc.now();
24 if (now.second() == lastSecond) return; // saniye değişmediyse yazma / skip until the second changes
25 lastSecond = now.second();
26
27 char line1[17], line2[17];
28 snprintf(line1, sizeof(line1), "%02d.%02d.%04d %s",
29 now.day(), now.month(), now.year(), days[now.dayOfTheWeek()]);
30 snprintf(line2, sizeof(line2), "%02d:%02d:%02d %2dC",
31 now.hour(), now.minute(), now.second(), (int)rtc.getTemperature());
32 lcd.setCursor(0, 0);
33 lcd.print(line1); // ör. / e.g. 03.11.2026 Sal
34 lcd.setCursor(0, 1);
35 lcd.print(line2); // ör. / e.g. 14:05:09 23C
36}De %02d in snprintf voegt een voorloopnul toe aan getallen van één cijfer, zodat de tijd als 09:05:03 wordt getoond in plaats van 9:5:3 en de lengte van de regel nooit verandert. Dankzij die vaste lengte heb je lcd.clear() niet nodig; het scherm bij elke lus wissen veroorzaakt geflikker. De code schrijft alleen naar het display als de seconde verandert, zodat de I2C-bus niet nodeloos bezet blijft. De array days bevat Turkse afkortingen; vervang ze door Zo, Ma, Di enzovoort, waarbij zondag het eerste element blijft.
Alarmen en geplande taken: automatische bewatering en dierenvoeding
Het nuttigste aan een RTC is dat je taken op een vast tijdstip kunt laten uitvoeren: elke ochtend om 08:00 de planten water geven, om 19:30 het voer van de kat uitdelen of 's nachts het aquariumlicht uitschakelen. Daarvoor zijn er twee manieren. De eerste is een vergelijking in software: je leest de tijd in loop() en controleert of het tijdstip van een taak is aangebroken. Dat is simpel en je kunt zoveel taken toevoegen als je wilt. De tweede is het hardwarealarm van de DS3231: op het ingestelde moment trekt de chip zijn INT-pin LAAG en waarschuwt hij de Arduino met een interrupt; hij kan zelfs een slapende microcontroller wekken.
Een veelgemaakte fout bij vergelijken in software is controleren op een exacte seconde, zoals now.second() == 0. Als er een lange delay() in loop() zit, kan die seconde voorbijglippen en wordt de taak nooit uitgevoerd. De onderstaande code vergelijkt uur en minuut, bewaart een sleutel van dag en minuut zodat de taak niet twee keer in dezelfde minuut draait, en timet de pomp met millis(). De pomp wordt aangestuurd via een relaismodule; de bedrading van de pomp vind je in het artikel over de mini-waterpomp.
1#include <Wire.h>
2#include <RTClib.h>
3
4RTC_DS3231 rtc;
5
6const byte RELAY_PIN = 7;
7const byte RELAY_ON = LOW; // çoğu röle modülü LOW ile çeker / most relay modules switch on LOW
8const byte RELAY_OFF = HIGH;
9const unsigned long RUN_MS = 10000; // pompa 10 saniye çalışır / the pump runs for 10 seconds
10
11struct Task { byte hour; byte minute; };
12Task tasks[] = { {8, 0}, {19, 30} }; // her gün 08:00 ve 19:30 / every day at 08:00 and 19:30
13const byte TASK_COUNT = sizeof(tasks) / sizeof(tasks[0]);
14
15long lastRunKey = -1; // aynı dakikada ikinci kez çalışmasın / never run twice in one minute
16bool running = false;
17unsigned long startMs = 0;
18
19void setup() {
20 pinMode(RELAY_PIN, OUTPUT);
21 digitalWrite(RELAY_PIN, RELAY_OFF); // açılışta kapalı / off at start-up
22 rtc.begin();
23}
24
25void loop() {
26 DateTime now = rtc.now();
27 long key = (long)now.day() * 1440 + now.hour() * 60 + now.minute(); // gün + dakika / day + minute
28
29 for (byte i = 0; i < TASK_COUNT; i++) {
30 if (now.hour() == tasks[i].hour && now.minute() == tasks[i].minute && key != lastRunKey) {
31 lastRunKey = key;
32 running = true;
33 startMs = millis();
34 digitalWrite(RELAY_PIN, RELAY_ON); // pompayı aç / pump on
35 }
36 }
37
38 if (running && millis() - startMs >= RUN_MS) {
39 running = false;
40 digitalWrite(RELAY_PIN, RELAY_OFF); // pompayı kapat / pump off
41 }
42 delay(200);
43}Het is belangrijk dat de dag in de sleutel zit: als je alleen de minuut bewaarde en één taak had, zou de sleutel op die minuut de volgende dag nog steeds hetzelfde zijn en zou de taak nooit meer draaien. Voor een voerautomaat gebruik je een servomotor in plaats van het relais: de servo op het tijdstip van de taak naar 90 graden draaien en een seconde later terug opent de klep van de voorraadbak en laat één portie voer vallen. Om de bewatering slimmer te maken, lees je op het tijdstip van de taak een bodemvochtsensor uit en sla je de pomp over als de grond al vochtig is. Het tweede voorbeeld hieronder doet hetzelfde werk met het hardwarealarm van de DS3231.
1#include <Wire.h>
2#include <RTClib.h>
3
4RTC_DS3231 rtc;
5const byte ALARM_PIN = 2; // DS3231 SQW/INT -> D2 (kesme pini / interrupt pin)
6volatile bool alarmFlag = false;
7
8void onAlarm() { // kesme fonksiyonu kısa olmalı / keep the ISR short
9 alarmFlag = true;
10}
11
12void setup() {
13 Serial.begin(9600);
14 rtc.begin();
15 rtc.disable32K(); // 32K çıkışını kapat / turn off the 32K output
16 rtc.writeSqwPinMode(DS3231_OFF); // SQW pini alarm çıkışı olur / SQW becomes the alarm output
17 rtc.clearAlarm(1);
18 rtc.clearAlarm(2);
19 rtc.disableAlarm(2);
20
21 // Her gün 07:30:00; tarih kısmı yok sayılır / every day at 07:30:00; the date part is ignored
22 rtc.setAlarm1(DateTime(2026, 1, 1, 7, 30, 0), DS3231_A1_Hour);
23
24 pinMode(ALARM_PIN, INPUT_PULLUP); // INT çıkışı open-drain / INT is an open-drain output
25 attachInterrupt(digitalPinToInterrupt(ALARM_PIN), onAlarm, FALLING);
26}
27
28void loop() {
29 if (alarmFlag) {
30 alarmFlag = false;
31 rtc.clearAlarm(1); // temizlenmezse pin LOW kalır / the pin stays LOW until cleared
32 Serial.println(F("Alarm: mama vakti / Feeding time"));
33 // Servo, röle ya da buzzer kodunu buraya yaz / put your servo, relay or buzzer code here
34 }
35}De DS3231 heeft twee alarmen. Alarm 1 heeft een resolutie van één seconde; de modus DS3231_A1_Hour gaat af als uren, minuten en seconden overeenkomen, dus elke dag op hetzelfde tijdstip. Met de andere modi kun je een alarm instellen elke seconde (PerSecond), elke minuut (Second), elk uur (Minute), op een bepaalde dag van de maand (Date) of op een bepaalde dag van de week (Day). Alarm 2 heeft een resolutie van één minuut. De SQW/INT-pin is een open-drain uitgang die actief LAAG is: hij gaat LAAG als het alarm afgaat en blijft zo tot clearAlarm() wordt aangeroepen. Daarom zet je in de interruptfunctie het best alleen een vlag en doe je het echte werk in loop(). Hoe interrupts werken lees je in Arduino-interrupts.
Hoe lang gaat de batterij van een RTC mee?
De levensduur van een batterij is makkelijk te schatten: looptijd (uren) = batterijcapaciteit (mAh) ÷ stroomverbruik (mA). Een CR2032 heeft ongeveer 220 mAh. Op batterij neemt de DS3231 in het slechtste geval ongeveer 3 µA op, dat is 0,003 mA: 220 ÷ 0,003 ≈ 73.000 uur, ofwel ongeveer 8 jaar. De batterij wordt alleen gebruikt als VCC uit is; zit de module in een apparaat dat altijd stroom heeft, dan wordt de batterij nauwelijks belast en gaat hij veel langer mee. In de praktijk wordt de grens meestal bepaald door de houdbaarheid van de batterij zelf en de oplaadschakeling van de module.
| Chip | Batterijstroom | Berekende looptijd op een CR2032 (220 mAh) |
|---|---|---|
| DS1307 | ~0,5 µA | ~50 jaar; in de praktijk beperkt door de houdbaarheid van de batterij (ongeveer 10 jaar) |
| DS3231 | ~3 µA (slechtste geval) | ~8 jaar |
| DS1302 | ~0,3 µA | Beperkt door de houdbaarheid van de batterij |
| Module met actieve lader + CR2032 | Er wordt stroom in de batterij geduwd | Onvoorspelbaar; de cel kan opzwellen en vroegtijdig sneuvelen |
De CR2032-batterij en de oplaadval
De meeste goedkope DS3231-modules (ZS-042) en DS1307-modules (Tiny RTC) hebben een eenvoudige oplaadschakeling die eigenlijk bedoeld is voor een oplaadbare LIR2032-cel. Op de ZS-042 loopt stroom van VCC naar de batterij via een 1N4148-diode en een weerstand van 200 Ω; de Tiny RTC heeft een vergelijkbare schakeling. Het probleem is dat deze modules vaak worden verkocht met een niet-oplaadbare CR2032. Als de module op 5 V draait, blijft de ongeveer 4,3 V die na de diode overblijft stroom in de lithiumcel van 3 V duwen. Een cel die nooit bedoeld was om te worden opgeladen, kan na verloop van tijd opzwellen, lekken en vroegtijdig sneuvelen, en dan heb je het probleem "er zit een batterij in, maar de klok blijft resetten".
- Gebruik je een CR2032, knip dan het oplaadpad door: desolder op de ZS-042 de SMD-weerstand van 200 Ω met opdruk "201" bij de pinheader, of de diode ernaast. Voor weerstanden waarvan je de code niet kunt lezen, gebruik je de SMD-codedecoder. Dit is de meest gebruikelijke en veiligste oplossing.
- Laat je de schakeling zoals hij is, plaats dan een LIR2032: de capaciteit van de oplaadbare cel (ongeveer 40 mAh) is ruwweg een vijfde van die van een CR2032 (ongeveer 220 mAh), maar hij blijft bijgevuld zolang de module stroom heeft.
- Voed je de module vanaf 3,3 V: dan komt er na de diode maar ongeveer 2,6 V bij de batterij; een LIR2032 laadt nooit volledig op en in een CR2032 loopt bijna geen stroom. De weerstand verwijderen blijft de schoonste oplossing.
- De ingebouwde druppellader van de DS1302 staat bij het opstarten uit; gebruik je een CR2032, zet hem dan niet aan in de code.
- Meet de batterij: een nieuwe CR2032 geeft 3,0–3,2 V; vervang hem zodra hij onder 2,5 V zakt.
De DS1302 gebruiken (3-draadsaansluiting)

De DS1302-module heeft vijf pins: VCC, GND, CLK, DAT en RST. Omdat hij geen I2C gebruikt, sluit hij aan op drie willekeurige digitale pins in plaats van A4-A5; in het onderstaande voorbeeld gaat DAT naar D4, CLK naar D5 en RST naar D2, en de module wordt gevoed vanaf 5V. De RTClib van Adafruit ondersteunt de DS1302 niet, dus installeer in plaats daarvan de bibliotheek Rtc by Makuna via de Library Manager. De DS1302 heeft twee beveiligingsbits: zolang de schrijfbeveiliging aan staat, kan de tijd niet worden ingesteld, en zolang de clock-halt-bit is gezet, loopt de klok niet door. De code controleert beide en zet de klok op de compileertijd als de opgeslagen tijd niet geldig is.
1#include <RtcDS1302.h>
2
3ThreeWire myWire(4, 5, 2); // DAT, CLK, RST pinleri / DAT, CLK, RST pins
4RtcDS1302<ThreeWire> rtc(myWire);
5
6void setup() {
7 Serial.begin(9600);
8 rtc.Begin();
9 if (rtc.GetIsWriteProtected()) rtc.SetIsWriteProtected(false); // yazma korumasını kaldır / remove write protection
10 if (!rtc.GetIsRunning()) rtc.SetIsRunning(true); // saati başlat / start the clock
11
12 RtcDateTime compiled(__DATE__, __TIME__);
13 if (!rtc.IsDateTimeValid() || rtc.GetDateTime() < compiled) {
14 rtc.SetDateTime(compiled); // derleme saatine ayarla / set to compile time
15 }
16}
17
18void loop() {
19 RtcDateTime now = rtc.GetDateTime();
20 char buf[20];
21 snprintf(buf, sizeof(buf), "%02u.%02u.%04u %02u:%02u:%02u",
22 now.Day(), now.Month(), now.Year(), now.Hour(), now.Minute(), now.Second());
23 Serial.println(buf);
24 delay(1000);
25}De meest gehoorde klacht over DS1302-modules is dat de klok per week minuten afwijkt. Een reden is dat de chip een kristal nodig heeft dat is getrimd voor een belastingscapaciteit van 6 pF, terwijl goedkope modules kristallen met een andere specificatie kunnen gebruiken. Lange, losse draden veroorzaken ook leesfouten op de seriële lijn van de DS1302. Heb je een DS1302, dan is het een prima manier om te leren hoe een RTC werkt; maar bouw je een klok die maandenlang nauwkeurig moet blijven, stap dan over op een DS3231.
NTP in plaats van een RTC op de ESP32: de tijd van internet halen
Omdat de ESP32 verbinding kan maken met Wi-Fi, heeft hij vaak helemaal geen RTC-module nodig: met NTP (Network Time Protocol) krijgt hij binnen een paar seconden de juiste tijd van tijdservers zoals pool.ntp.org. De ESP32 Arduino-core levert hiervoor kant-en-klare functies configTzTime() en getLocalTime(), en de tijdzone wordt opgegeven als een regelstring. Turkije zit sinds 2016 zonder zomertijd op UTC+3, dus de regel in de code is een vaste verschuiving van +3 uur. In regio's met zomertijd, zoals het grootste deel van Europa, berekent de Centraal-Europese regel in de codecommentaar de omschakeldata zelf; in het Verenigd Koninkrijk gebruik je "GMT0BST,M3.5.0/1,M10.5.0".
De zwakke plek van NTP is de afhankelijkheid van internet: na een stroomstoring, tot de router is opgestart, of als het wifiwachtwoord verandert, kan de ESP32 de tijd niet weten. De interne RTC-timer van de ESP32 houdt de tijd bij tijdens deep sleep, maar wordt gereset zodra de stroom helemaal wegvalt. De robuustste oplossing combineert de twee: bij het opstarten synchroniseert de ESP32 de DS3231 met de internettijd als hij NTP kan bereiken, anders leest hij de tijd uit de DS3231, en hij synchroniseert één keer per dag opnieuw. Meer over NTP lees je in ESP32 NTP-tijd.
1#include <WiFi.h>
2#include <Wire.h>
3#include <RTClib.h>
4#include <time.h>
5
6const char* WIFI_SSID = "AgAdin"; // Wi-Fi ağ adı / Wi-Fi network name
7const char* WIFI_PASS = "Sifren"; // Wi-Fi şifresi / Wi-Fi password
8// Türkiye: UTC+3, yaz saati yok / Turkey: UTC+3, no daylight saving
9// Orta Avrupa / Central Europe: "CET-1CEST,M3.5.0,M10.5.0/3"
10const char* TZ_INFO = "<+03>-3";
11
12RTC_DS3231 rtc;
13unsigned long lastSync = 0;
14
15void syncFromNtp() {
16 struct tm t;
17 if (getLocalTime(&t, 10000)) { // en fazla 10 sn bekle / wait up to 10 s
18 rtc.adjust(DateTime(t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec));
19 Serial.println("DS3231 NTP ile ayarlandi / DS3231 synced from NTP");
20 }
21 lastSync = millis();
22}
23
24void setup() {
25 Serial.begin(115200);
26 Wire.begin(21, 22); // SDA, SCL pinleri / SDA, SCL pins
27 rtc.begin();
28
29 WiFi.begin(WIFI_SSID, WIFI_PASS);
30 unsigned long start = millis();
31 while (WiFi.status() != WL_CONNECTED && millis() - start < 15000) delay(250);
32
33 if (WiFi.status() == WL_CONNECTED) {
34 configTzTime(TZ_INFO, "pool.ntp.org", "time.google.com");
35 syncFromNtp();
36 } else {
37 Serial.println("Wi-Fi yok, DS3231 saati kullaniliyor / No Wi-Fi, using the DS3231");
38 }
39}
40
41void loop() {
42 DateTime now = rtc.now();
43 char buf[] = "DD.MM.YYYY hh:mm:ss";
44 Serial.println(now.toString(buf));
45
46 if (WiFi.status() == WL_CONNECTED && millis() - lastSync > 86400000UL) {
47 syncFromNtp(); // günde bir kez eşitle / sync once a day
48 }
49 delay(1000);
50}De ingebouwde RTC van de Raspberry Pi Pico
De RP2040-chip op de Raspberry Pi Pico bevat een RTC-blok, terwijl de RP2350 op de Pico 2 hetzelfde werk doet met een always-on timer (AON-timer). In MicroPython worden beide gebruikt via dezelfde klasse machine.RTC: RTC().datetime() leest of schrijft de tijd als (jaar, maand, dag, weekdag, uren, minuten, seconden, subseconden), en time.localtime() gebruikt deze klok ook. Maar deze klok heeft geen batterij: als de Pico de stroom verliest, start MicroPython de klok op 1 januari 2021, 00:00.
Hier zit een valkuil waar beginners in trappen: standaard synchroniseert Thonny de klok van de Pico met de klok van je computer zodra hij verbinding maakt. Tijdens het testen lijkt dus alles goed, maar zodra je de Pico aan een telefoonlader of een batterij hangt, springt de klok terug naar 2021. De oplossing is een DS3231 op de Pico aan te sluiten en de interne RTC er bij het opstarten mee in te stellen. De onderstaande code heeft geen driverbestand nodig; hij leest de eerste zeven registers van de DS3231 via I2C en zet ze van BCD om naar decimaal. Op een Pico W kun je de tijd ook van internet halen met ntptime.settime(); omdat die UTC teruggeeft, moet je je tijdzoneverschuiving zelf optellen. Ben je nieuw met de Pico, begin dan met Wat is de Raspberry Pi Pico?.
1from machine import Pin, I2C, RTC
2import time
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)
5DS_ADDR = 0x68 # DS3231 ve DS1307 adresi / DS3231 and DS1307 address
6
7def bcd2dec(b):
8 return (b >> 4) * 10 + (b & 0x0F)
9
10def dec2bcd(d):
11 return ((d // 10) << 4) | (d % 10)
12
13def ds_read():
14 b = i2c.readfrom_mem(DS_ADDR, 0x00, 7) # saniyeden yıla 7 kayıt / 7 registers, seconds to year
15 return (2000 + bcd2dec(b[6]), bcd2dec(b[5] & 0x1F), bcd2dec(b[4] & 0x3F),
16 bcd2dec(b[2] & 0x3F), bcd2dec(b[1] & 0x7F), bcd2dec(b[0] & 0x7F))
17
18def ds_write(y, mo, d, h, mi, s):
19 # 24 saat biçiminde yazar; 4. bayt haftanın günü (1-7) / writes 24-hour time; 4th byte is day of week (1-7)
20 i2c.writeto_mem(DS_ADDR, 0x00, bytes([dec2bcd(s), dec2bcd(mi), dec2bcd(h), 1,
21 dec2bcd(d), dec2bcd(mo), dec2bcd(y - 2000)]))
22
23# İlk kurulumda bir kez çalıştır, sonra satırı sil / run once on first setup, then delete the line
24# ds_write(2026, 11, 3, 14, 30, 0)
25
26y, mo, d, h, mi, s = ds_read()
27RTC().datetime((y, mo, d, 0, h, mi, s, 0)) # dahili RTC'yi ayarla / set the internal RTC
28
29while True:
30 t = time.localtime() # artık dahili RTC'den okunur / now read from the internal RTC
31 print("{:02d}.{:02d}.{} {:02d}:{:02d}:{:02d}".format(t[2], t[1], t[0], t[3], t[4], t[5]))
32 time.sleep(1)Projectideeën met een RTC-module
- Digitale bureauklok en kalender: toon de tijd, de datum en de door de DS3231 gemeten temperatuur op een LCD, OLED of ledmatrix.
- Automatische plantenbewatering: controleer elke ochtend het bodemvocht en laat indien nodig de pomp een vaste tijd draaien.
- Voerautomaat voor huisdieren: open twee of drie keer per dag met een servo de klep van de voorraadbak en laat een portie voer vallen.
- Datalogger met tijdstempel: schrijf temperatuur- en vochtigheidsmetingen samen met datum en tijd naar een SD-kaartmodule en zet ze daarna in een grafiek in Excel.
- School- of werkplaatsbel: laat aan het begin en einde van elke les een buzzer of een door een relais bediende bel afgaan en sla weekenden over met dayOfTheWeek().
- Timer voor aquarium en kweeklamp: zet het licht 's ochtends aan en 's avonds uit en laat de helderheid met PWM langzaam in- en uitfaden voor een zonsopgang- en zonsondergangeffect.
Veelgemaakte fouten en hoe je ze oplost
- "RTC not found", begin() geeft false: SDA en SCL zijn verwisseld, GND is niet gedeeld of de module krijgt geen stroom. Draai een I2C-scannersketch en controleer of adres 0x68 verschijnt.
- Onzinwaarden zoals het jaar 2165, 165 of 85: er komen geen gegevens van de chip en elke gelezen byte is 0xFF. Controleer de bedrading; voed je een DS1307 vanaf 3,3 V, schakel dan over op 5 V.
- De klok springt na elke reset terug naar hetzelfde moment: de regel rtc.adjust() staat nog zonder voorwaarde in setup(); koppel hem aan lostPower().
- De klok reset na een stroomstoring: de batterij is leeg, verkeerd om geplaatst of afwezig. Meet de spanning en bedenk dat de oplaadschakeling de CR2032 mogelijk heeft gedood.
- De klok wijkt per week minuten af: het kristal van een DS1307 of DS1302 en temperatuurschommelingen veroorzaken dit. Stap over op een DS3231 of synchroniseer de tijd regelmatig met NTP.
- De tijd loopt precies één of meer uren af: de instelling voor tijdzone of zomertijd klopt niet. Schrijf de lokale tijd naar de RTC; gebruik je NTP, kies dan de juiste tijdzoneregel.
- De DS3231 meet warmer dan de kamer: die waarde is de eigen temperatuur van de chip, nauwkeurig tot ±3 °C en beïnvloed door het opwarmen van het board. Gebruik een aparte sensor voor de omgevingstemperatuur.
Kort gezegd: de DS3231 is de juiste keuze voor bijna elk project dat tijd en datum nodig heeft; de DS1307 doet zijn werk in eenvoudige 5V-projecten en de DS1302 is prima om mee te leren. Gebruik op de ESP32 NTP als er internet is en een DS3231 als dat er niet is; op de Pico is de interne RTC bij het opstarten instellen vanuit een DS3231 de betrouwbaarste aanpak. In de BlueGrays-app vind je stap-voor-stapprojecten met schakelschema's en code: een DS1302-klok opzetten en een LCD-klok, een DS1307-dotmatrixklok en kalender, een digitale ESP32-klok met een RTC, internettijd met NTP en een temperatuurlogger met tijdstempels.
Veelgestelde vragen
Werkt een RTC-module zonder batterij?
Zolang VCC is aangesloten, loopt de klok en kan hij worden uitgelezen. Maar zodra de stroom wegvalt, stopt of reset de klok en moet je hem bij de volgende start opnieuw instellen. Omdat het hele doel van een RTC is de tijd bij te houden tijdens stroomuitval, heb je de batterij vrijwel altijd nodig; gebruik je een DS1307 zonder, dan moet zijn VBAT-pin met GND zijn verbonden.
Wat is beter, de DS3231 of de DS1307?
De DS3231 is in bijna alle gevallen beter. Dankzij het temperatuurgecompenseerde ingebouwde kristal wijkt hij maar ongeveer een minuut per jaar af, terwijl een DS1307 tot een minuut per maand kan afwijken. De DS3231 werkt bovendien op 2,3–5,5 V, dus hij werkt rechtstreeks met de ESP32 en Pico, en hij heeft twee alarmen en een temperatuursensor. Met RTClib is de code voor beide vrijwel identiek.
Hoe lang gaat de batterij van een RTC-module mee?
Als de module alleen op de batterij draait, neemt een DS3231 tot ongeveer 3 µA op en een DS1307 zo'n 0,5 µA. Op papier gaat een CR2032 van 220 mAh bij deze stromen meer dan 8 jaar mee. In de praktijk kunnen de houdbaarheid van de cel en de oplaadschakeling van de module dat verkorten; in een module met een actieve lader kan een CR2032 veel eerder het loodje leggen.
Waarom reset mijn RTC-module steeds de tijd?
Er zijn drie veelvoorkomende oorzaken: de regel rtc.adjust() in setup() die de klok bij elke start terugzet naar de compileertijd, een lege of verkeerd om geplaatste batterij, en een oplaadschakeling die de CR2032 heeft verpest. Koppel eerst de adjust()-regel aan lostPower(), meet dan de batterijspanning met een multimeter en vervang de cel als die onder 2,5 V zit.
Heb ik een RTC-module nodig bij de ESP32?
Niet als het apparaat altijd online is; de ESP32 krijgt de juiste tijd binnen een paar seconden via NTP. Voor projecten waarbij het internet kan wegvallen, waarbij de tijd na een stroomstoring bekend moet zijn voordat de router weer draait, of die helemaal offline werken, is een DS3231 toevoegen de veiligste optie. Het best gebruik je beide en synchroniseer je de DS3231 één keer per dag met NTP.
Kan ik een CR2032 in een DS3231-module plaatsen?
Ja, maar bij modules met een oplaadschakeling, zoals de ZS-042, moet je eerst het oplaadpad doorknippen. Als je de weerstand van 200 Ω (code 201) of de diode ernaast desoldeert, werkt een CR2032 jarenlang veilig. Wil je het board niet aanpassen, gebruik dan een oplaadbare LIR2032.
Projecten om hierna te bouwen
Alle projecten bekijken
DS1302 RTC-klokmodule instellen
Je krijgt een kleine klokmodule aan de praat die de tijd nooit vergeet, ook niet als de Arduino uit staat.

DS1302 RTC-klok met LCD-display
Een kleine bureauklok die de tijd bijhoudt, ook als de stroom uitvalt. De DS1302-klokmodule houdt de tijd bij dankzij een eigen kleine batterij; de Arduino leest hem elke seconde uit en schrijft tijd…

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.

Dotmatrix-klok en -kalender (MAX7219, DS1307)
Een oplichtend bord voor op je bureau of aan de muur dat de tijd en de datum toont in scrollende tekst.

Dotmatrixklok, kalender en weerstation (MAX7219, DS1307)
Een scrollend tekstbord voor op je bureau of aan de muur dat om de beurt de tijd, de datum en het weer in de kamer toont.

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.

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 7-segmentdisplay met 4 cijfers
Een lichtgevende digitale klok met vier cijfers, zoals op een keukenoven. De DS1302-klokmodule houdt de tijd bij en de Arduino leest elke seconde uren en minuten uit en toont ze op het display met…
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

