Ratgeber · 9 Min. Lesezeit

Wecker mit Arduino bauen: DS3231 RTC, LCD, Buzzer und Snooze

Wecker mit Arduino bauen: RTC DS3231 oder DS1307, I2C-LCD, 3 Taster für Uhrzeit und Weckzeit, Buzzer-Melodie, Schlummerfunktion, EEPROM und ESP32-NTP-Version.

Einen Wecker mit Arduino zu bauen bringt RTC-Modul, LCD, Taster und Buzzer in einem Projekt zusammen: Du lernst eine Menge und hast am Ende ein Gerät, das du wirklich jeden Morgen benutzt. In dieser Anleitung bauen wir mit einem RTC-Modul DS3231 (oder DS1307), einem 16x2-I2C-LCD, drei Tastern und einem passiven Buzzer einen Wecker, dessen Uhrzeit und Weckzeit per Taster eingestellt werden, der eine Melodie spielt, eine 5-Minuten-Schlummerfunktion (Snooze) hat und die Uhrzeit auch bei Stromausfall nicht verliert.

Du findest die Verdrahtung Schritt für Schritt, eine Ablauftabelle für das Tastermenü, eine Melodie ohne delay, das Speichern der Weckzeit im EEPROM und den vollständigen, kompilierten Code. Im letzten Teil betreiben wir dieselbe Uhr ohne RTC-Modul: Ein ESP32 holt die Zeit aus dem Internet (NTP) und stellt selbstständig auf Sommerzeit um.

DS1307-RTC-Modul mit CR2032-Batteriehalter
DS1307-RTC-Modul: Pins GND, 5V, SDA, SCL und SQW; die CR2032-Knopfzelle auf der Rückseite hält die Uhr bei Stromausfall am Laufen.

Wie funktioniert ein Wecker mit Arduino?

Die eigene Uhr des Arduino (millis) zählt nur, solange das Board Strom hat, und startet bei jedem Reset bei null; außerdem können Boards mit Keramikresonator wie der Uno pro Tag um Minuten abweichen. Deshalb übernimmt ein RTC-Modul (Echtzeituhr) die Zeit: Die kleine Platine mit eigenem Quarz und Knopfzelle zählt weiter, auch wenn der Arduino aus ist. In jedem Schleifendurchlauf liest der Arduino die Zeit aus der RTC, schreibt sie aufs LCD, fragt die Taster ab und startet den Buzzer, sobald die Uhrzeit der Weckzeit entspricht. Das ganze Verhalten steuert ein kleiner Zustandsautomat: Uhrzeit anzeigen, Uhrzeit stellen, Weckzeit stellen und Alarm läuft.

BauteilAufgabeHinweis
Arduino Uno oder NanoDas GehirnBeim Nano dieselben Pins (A4/A5)
RTC-Modul DS3231 oder DS1307Hält die UhrzeitBeide I2C, Adresse 0x68
16x2-LCD mit I2CZeigt Uhrzeit, Datum und WeckzeitAdresse meist 0x27 oder 0x3F
3 TasterMENU, Plus (+) und Minus (-)Keine Widerstände nötig (INPUT_PULLUP)
Passiver BuzzerSpielt die MelodieEin aktiver Buzzer kann nur einen Ton
Knopfzelle CR2032Versorgt die RTC bei StromausfallAchtung bei der Ladeschaltung des Moduls
Steckbrett und JumperkabelVerbindungenFür eine dauerhafte Uhr Lochrasterplatine

DS1307 oder DS3231?

Beide Module haben dieselbe I2C-Adresse und laufen dank der Bibliothek RTClib mit fast identischem Code, ihre Genauigkeit ist aber sehr unterschiedlich. Der DS1307 hängt an einem externen 32,768-kHz-Quarz und driftet, wenn sich die Raumtemperatur ändert; bei billigen Modulen sind ein paar Minuten Abweichung pro Monat normal. Der DS3231 trägt den Quarz im Chip und gleicht ihn temperaturabhängig aus, er weicht nur etwa eine Minute pro Jahr ab. Für eine Uhr, die dich jeden Morgen weckt, ist der DS3231 klar die bessere Wahl; hast du schon einen DS1307, läuft der Code auch damit.

EigenschaftDS1307DS3231
GenauigkeitVom Quarz abhängig, 1-5 Minuten Abweichung pro Monat möglich±2 ppm, etwa 1 Minute pro Jahr
TemperaturkompensationNeinJa (TCXO)
Versorgung4,5-5,5 V2,3-5,5 V (am ESP32 auch mit 3,3 V)
Interner AlarmNein2 Alarme und INT/SQW-Ausgang
TemperatursensorNeinJa (±3 °C)
I2C-Adresse0x680x68
RTClib-KlasseRTC_DS1307RTC_DS3231

Schaltung des Arduino-Weckers

VerbindungArduino UnoESP32 (NTP-Version)
SDA von LCD und RTCA4GPIO 21 (nur LCD)
SCL von LCD und RTCA5GPIO 22 (nur LCD)
VCC des LCD5VVIN (5V)
VCC der RTC5VNicht nötig
Taster MENUD2-
Taster Plus (+)D3-
Taster Minus (-) / SchlummernD4GPIO 27 (ein einziger Taster)
Passiver Buzzer (+)D8GPIO 25
Alle GNDGNDGND
Die meisten billigen DS3231-Module (ZS-042) haben einen Widerstand und eine Diode, die versuchen, die Batterie zu laden. Diese Schaltung ist für einen wiederaufladbaren LIR2032 gedacht; mit einer normalen CR2032 kann sich die Zelle mit der Zeit aufblähen. Wenn du eine CR2032 nutzt, lös den 200-Ω-Widerstand oder die Diode von der Platine aus oder verwende einen LIR2032.

LCD und RTC teilen sich denselben I2C-Bus: Die SDA-Pins beider Module gehen an A4, die SCL-Pins an A5; weil ihre Adressen verschieden sind, kommen sie sich nicht in die Quere. Bei den Tastern verbindest du einfach ein Bein mit dem Pin und das gegenüberliegende mit GND; da der Code INPUT_PULLUP nutzt, brauchst du keinen externen Widerstand, und beim Drücken liest der Pin LOW (Details in Taster am Arduino anschließen). Der Pluspol des Buzzers kommt an D8, der Minuspol an GND. Weil die Melodie mit tone() erzeugt wird, brauchst du einen passiven Buzzer; den Unterschied erklären wir in Was ist ein Buzzer?.

Tastermenü: Uhrzeit und Weckzeit mit drei Tastern einstellen

Damit sich alles mit nur drei Tastern einstellen lässt, bekommt jeder Taster je nach Modus eine andere Aufgabe. MENU springt zum nächsten Schritt, Plus und Minus ändern den gerade ausgewählten Wert. Diese Struktur heißt Zustandsautomat und erlaubt es, jeden Modus in einem eigenen case zu schreiben, statt viele if-Blöcke zu verschachteln. Die Tabelle zeigt das komplette Menü; hast du sie beim Lesen des Codes neben dir, siehst du sofort, was jede Zeile tut.

Modus (auf dem Display)MENUPlus (+)Minus (-)
UhranzeigeUhrzeit stellenWecker an / ausSchlummern abbrechen
SET TIME: StundeWeiter zu den MinutenStunde +1Stunde -1
SET TIME: MinuteZeit in die RTC schreiben, weiter zur WeckzeitMinute +1Minute -1
SET ALARM: StundeWeiter zu den MinutenWeckstunde hochWeckstunde runter
SET ALARM: MinuteIm EEPROM speichern, Wecker einschalten, zurück zur UhrMinute hochMinute runter
WAKE UP! (Alarm läuft)Ausschalten5 Minuten schlummern5 Minuten schlummern
Hältst du in den Einstellmodi Plus oder Minus gedrückt, läuft der Wert nach 0,6 Sekunden mit etwa 7 Schritten pro Sekunde weiter. So musst du nicht 45-mal drücken, um die Minuten von 0 auf 45 zu bringen. In der Uhranzeige ist diese Wiederholung abgeschaltet, sonst würde der Wecker beim Festhalten ständig an- und ausgehen.

Bibliotheken und Ersteinrichtung

  1. Installiere im Bibliotheksverwalter RTClib (von Adafruit) und lass Adafruit BusIO als Abhängigkeit mitinstallieren.
  2. Für das LCD installierst du LiquidCrystal I2C (von Frank de Brabander). Die Bibliotheken EEPROM und Wire sind beim Arduino schon dabei.
  3. Bist du dir bei der LCD-Adresse unsicher, lass den Scanner-Sketch aus der Anleitung zum I2C-LCD laufen und trag die gefundene Adresse statt 0x27 in den Code ein.
  4. Verwendest du einen DS1307, setz USE_DS3231 im Code auf 0.
  5. Lade den Code hoch. Startet die RTC zum ersten Mal oder ist ihre Batterie leer, wird die Uhr auf den Kompilierzeitpunkt gestellt und kurz eine Batteriewarnung angezeigt.
  6. Geh mit MENU in die Zeiteinstellung, stell die genaue Uhrzeit ein und danach die Weckzeit.

Code für den Arduino-Wecker

Hier ist der komplette Code. Nirgends in der Schleife steht ein langes delay: Taster, Melodie und Display werden mit millis() getaktet, deshalb reagieren die Taster auch während des Alarms sofort. Das Display wird nur neu beschrieben, wenn sich die Sekunde ändert oder ein Taster gedrückt wird; so flackert das LCD nicht.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <RTClib.h>
3#include <LiquidCrystal_I2C.h>
4#include <EEPROM.h>
5
6#define USE_DS3231 1                   // DS1307 için 0 yap / set to 0 for a DS1307
7#if USE_DS3231
8RTC_DS3231 rtc;
9#else
10RTC_DS1307 rtc;
11#endif
12
13LiquidCrystal_I2C lcd(0x27, 16, 2);    // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
14
15const byte BTN_PINS[3] = {2, 3, 4};    // MENU, UP (+), DOWN (-)
16const byte BUZZER_PIN = 8;             // pasif buzzer / passive buzzer
17const byte SNOOZE_MIN = 5;             // erteleme süresi (dk) / snooze length (min)
18const unsigned long RING_LIMIT_MS = 60000UL;   // 1 dk sonra sus / stop after 1 min
19const byte EE_MAGIC = 0xA5;            // EEPROM geçerlilik işareti / EEPROM validity marker
20
21enum Mode { CLOCK, SET_HOUR, SET_MIN, AL_HOUR, AL_MIN, RINGING };
22Mode mode = CLOCK;
23
24byte alarmHour = 7, alarmMin = 0;
25bool alarmOn = false;
26byte editHour = 0, editMin = 0;
27long lastAlarmKey = -1;                // aynı dakikada iki kez çalmasın / never ring twice in one minute
28uint32_t snoozeAt = 0;                 // 0 = erteleme yok / 0 = no snooze
29unsigned long ringStart = 0;
30bool redraw = true;
31int lastSecond = -1;
32
33// Melodi: frekans (Hz) ve süre (ms), 0 = es / melody: frequency (Hz) and length (ms), 0 = rest
34const int melody[][2] = { {1047, 150}, {0, 50}, {1319, 150}, {0, 50},
35                          {1568, 150}, {0, 50}, {2093, 300}, {0, 600} };
36const byte MELODY_LEN = sizeof(melody) / sizeof(melody[0]);
37byte noteIndex = 0;
38unsigned long noteStart = 0;
39
40// ---------- EEPROM ----------
41void loadAlarm() {
42  if (EEPROM.read(3) == EE_MAGIC && EEPROM.read(0) < 24 && EEPROM.read(1) < 60) {
43    alarmHour = EEPROM.read(0);
44    alarmMin = EEPROM.read(1);
45    alarmOn = EEPROM.read(2) == 1;
46  }
47}
48
49void saveAlarm() {
50  EEPROM.update(0, alarmHour);         // update yalnız değişen baytı yazar / update writes only changed bytes
51  EEPROM.update(1, alarmMin);
52  EEPROM.update(2, alarmOn ? 1 : 0);
53  EEPROM.update(3, EE_MAGIC);
54}
55
56// ---------- Butonlar / buttons ----------
57// Yeni basışta true döner; allowRepeat ise basılı tutunca tekrarlar
58// Returns true on a new press; with allowRepeat it repeats while held
59bool pressed(byte i, bool allowRepeat) {
60  static bool stable[3] = {HIGH, HIGH, HIGH};
61  static unsigned long changedAt[3], repeatAt[3];
62  bool reading = digitalRead(BTN_PINS[i]);
63  unsigned long t = millis();
64  if (reading != stable[i] && t - changedAt[i] > 30) {     // 30 ms sıçrama filtresi / 30 ms debounce
65    stable[i] = reading;
66    changedAt[i] = t;
67    if (reading == LOW) { repeatAt[i] = t + 600; return true; }
68  }
69  if (allowRepeat && stable[i] == LOW && (long)(t - repeatAt[i]) >= 0) {
70    repeatAt[i] = t + 150;                                 // hızlı ilerleme / fast repeat
71    return true;
72  }
73  return false;
74}
75
76// ---------- Buzzer ----------
77void startRinging() {
78  mode = RINGING;
79  ringStart = millis();
80  noteIndex = MELODY_LEN - 1;          // ilk çağrıda baştan başlar / restarts on the first call
81  noteStart = 0;
82  redraw = true;
83}
84
85void stopRinging() {
86  noTone(BUZZER_PIN);
87  mode = CLOCK;
88  redraw = true;
89}
90
91void playMelody() {                    // delay kullanmadan çalar / plays without delay()
92  unsigned long t = millis();
93  if (t - noteStart >= (unsigned long)melody[noteIndex][1]) {
94    noteIndex = (noteIndex + 1) % MELODY_LEN;
95    noteStart = t;
96    if (melody[noteIndex][0] > 0) tone(BUZZER_PIN, melody[noteIndex][0]);
97    else noTone(BUZZER_PIN);
98  }
99}
100
101// ---------- LCD ----------
102void printLine(byte row, const char* text) {
103  lcd.setCursor(0, row);
104  lcd.print(text);
105  for (byte i = strlen(text); i < 16; i++) lcd.print(' ');   // satırın kalanını sil / clear the rest of the row
106}
107
108void draw(const DateTime& now) {
109  if (!redraw && now.second() == lastSecond) return;         // değişiklik yoksa yazma / skip if nothing changed
110  redraw = false;
111  lastSecond = now.second();
112  char l1[17], l2[17];
113
114  if (mode == CLOCK) {
115    snprintf(l1, sizeof(l1), "%02d:%02d:%02d   %02d/%02d",
116             now.hour(), now.minute(), now.second(), now.day(), now.month());
117    if (snoozeAt) snprintf(l2, sizeof(l2), "Snooze %d min", (int)((snoozeAt - now.unixtime() + 59) / 60));
118    else snprintf(l2, sizeof(l2), "Alarm %02d:%02d  %s", alarmHour, alarmMin, alarmOn ? "ON" : "OFF");
119  } else if (mode == SET_HOUR || mode == SET_MIN) {
120    strcpy(l1, "SET TIME");
121    if (mode == SET_HOUR) snprintf(l2, sizeof(l2), ">%02d<:%02d", editHour, editMin);
122    else snprintf(l2, sizeof(l2), " %02d:>%02d<", editHour, editMin);
123  } else if (mode == AL_HOUR || mode == AL_MIN) {
124    strcpy(l1, "SET ALARM");
125    if (mode == AL_HOUR) snprintf(l2, sizeof(l2), ">%02d<:%02d", alarmHour, alarmMin);
126    else snprintf(l2, sizeof(l2), " %02d:>%02d<", alarmHour, alarmMin);
127  } else {
128    strcpy(l1, "   WAKE UP!");
129    strcpy(l2, "+/-:snooze M:off");
130  }
131  printLine(0, l1);
132  printLine(1, l2);
133}
134
135void setup() {
136  for (byte i = 0; i < 3; i++) pinMode(BTN_PINS[i], INPUT_PULLUP);   // basınca LOW / LOW when pressed
137  pinMode(BUZZER_PIN, OUTPUT);
138  lcd.init();
139  lcd.backlight();
140
141  if (!rtc.begin()) {
142    printLine(0, "RTC not found");
143    while (true);
144  }
145#if USE_DS3231
146  bool timeLost = rtc.lostPower();
147#else
148  bool timeLost = !rtc.isrunning();
149#endif
150  if (timeLost) {                      // pil bitmiş ya da ilk açılış / dead battery or first start
151    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
152    printLine(0, "Check RTC batt.");
153    delay(2000);
154  }
155  loadAlarm();
156}
157
158void loop() {
159  DateTime now = rtc.now();
160  long key = (long)now.day() * 1440 + now.hour() * 60 + now.minute();   // gün + dakika / day + minute
161
162  bool editing = (mode >= SET_HOUR && mode <= AL_MIN);
163  bool bMenu = pressed(0, false);
164  bool bUp = pressed(1, editing);
165  bool bDown = pressed(2, editing);
166  if (bMenu || bUp || bDown) redraw = true;
167
168  switch (mode) {
169    case CLOCK:
170      if (bMenu) { editHour = now.hour(); editMin = now.minute(); mode = SET_HOUR; }
171      if (bUp) { alarmOn = !alarmOn; snoozeAt = 0; saveAlarm(); }       // alarm aç/kapa / alarm on/off
172      if (bDown) snoozeAt = 0;                                          // ertelemeyi iptal / cancel snooze
173      if (alarmOn && now.hour() == alarmHour && now.minute() == alarmMin && key != lastAlarmKey) {
174        lastAlarmKey = key;
175        startRinging();
176      }
177      if (snoozeAt && now.unixtime() >= snoozeAt) { snoozeAt = 0; startRinging(); }
178      break;
179
180    case SET_HOUR:
181      if (bUp) editHour = (editHour + 1) % 24;
182      if (bDown) editHour = (editHour + 23) % 24;
183      if (bMenu) mode = SET_MIN;
184      break;
185
186    case SET_MIN:
187      if (bUp) editMin = (editMin + 1) % 60;
188      if (bDown) editMin = (editMin + 59) % 60;
189      if (bMenu) {                     // saati RTC'ye yaz, saniye 0 / write the time to the RTC, seconds 0
190        rtc.adjust(DateTime(now.year(), now.month(), now.day(), editHour, editMin, 0));
191        mode = AL_HOUR;
192      }
193      break;
194
195    case AL_HOUR:
196      if (bUp) alarmHour = (alarmHour + 1) % 24;
197      if (bDown) alarmHour = (alarmHour + 23) % 24;
198      if (bMenu) mode = AL_MIN;
199      break;
200
201    case AL_MIN:
202      if (bUp) alarmMin = (alarmMin + 1) % 60;
203      if (bDown) alarmMin = (alarmMin + 59) % 60;
204      if (bMenu) { alarmOn = true; saveAlarm(); mode = CLOCK; }        // kaydet ve çık / save and exit
205      break;
206
207    case RINGING:
208      playMelody();
209      if (bUp || bDown) {                                               // ertele / snooze
210        snoozeAt = now.unixtime() + SNOOZE_MIN * 60UL;
211        stopRinging();
212      } else if (bMenu || millis() - ringStart > RING_LIMIT_MS) {
213        stopRinging();                                                  // sustur / stop
214      }
215      break;
216  }
217  draw(now);
218}

Wie funktioniert der Code?

TeilWas macht er?
pressed()Liest den Taster mit 30 ms Entprellung; liefert bei einem neuen Druck true und wiederholt in den Einstellmodi, solange er gehalten wird.
enum Mode und switchBehandeln die Modi Uhr, Zeit stellen, Weckzeit stellen und Alarm getrennt.
key (Tag × 1440 + Minute)Verhindert, dass der Alarm innerhalb derselben Minute zweimal startet.
snoozeAtSpeichert das Ende des Schlummerns als Unixzeit; funktioniert auch über Mitternacht.
playMelody()Spielt die Noten nacheinander mit millis(), ohne delay.
draw() und printLine()Beschreiben das Display nur bei Bedarf und löschen das Zeilenende mit Leerzeichen.
loadAlarm() und saveAlarm()Lesen und speichern Weckzeit und Ein/Aus-Zustand im EEPROM.
USE_DS3231Wechselt mit einer einzigen Zeile zwischen DS3231 und DS1307.

Für den Alarm prüfen wir Minuten, nicht Sekunden. Sekunde 0 abzupassen ist riskant: Ist die Schleife genau in dieser Sekunde mit dem Display beschäftigt, klingelt der Wecker womöglich nie. Stattdessen startet der Alarm, sobald Stunde und Minute übereinstimmen, und wir merken uns diese Minute in lastAlarmKey. Schaltest du den Alarm in derselben Minute aus, beginnt er also nicht erneut. Die Schlummerzeit berechnen wir aus der Unixzeit der RTC (Sekunden seit 1970): Schlummerst du um 23:58 fünf Minuten, klingelt es problemlos um 00:03. Die Logik hinter der Zeitsteuerung mit millis() findest du in millis statt delay.

Buzzer-Melodie und Schlummerfunktion (Snooze)

Die Melodie steckt in einem kleinen Array aus Frequenz-Dauer-Paaren: Die Töne 1047 Hz (C6), 1319 Hz (E6), 1568 Hz (G6) und 2093 Hz (C7) erklingen mit kurzen Pausen, danach folgen 600 ms Stille und alles beginnt von vorn. Für ein energischeres Wecken kannst du die Pause kürzen oder eigene Töne ergänzen; die Frequenz 0 bedeutet Pause. Schaltet niemand den Alarm aus, verstummt er nach 60 Sekunden von selbst und stört nicht die Nachbarn, wenn du nicht zu Hause bist. Plus oder Minus schieben den Alarm um 5 Minuten auf und das Display zeigt die Restzeit; MENU schaltet ihn für diesen Tag ganz aus, am nächsten Tag klingelt er wieder zur selben Zeit.

Weckzeit im EEPROM speichern

Die RTC behält die Uhrzeit, die Weckzeit liegt aber im RAM des Arduino und ist nach einem Stromausfall weg. Deshalb schreiben wir sie in das 1 KB große EEPROM des Arduino Uno. Weil jede Zelle nur etwa 100.000 Schreibvorgänge verträgt, nutzen wir EEPROM.update(), das nichts schreibt, wenn der Wert schon gleich ist. Die Markierung 0xA5 im vierten Byte zeigt, dass das EEPROM bereits von diesem Programm beschrieben wurde; so werden beim allerersten Start keine Zufallswerte gelesen und der Wecker steht nicht auf einer unsinnigen Zeit wie 37:99. Mehr dazu im Artikel Arduino EEPROM.

EEPROM-AdresseInhaltBeispiel
0Weckstunde (0-23)7
1Weckminute (0-59)30
2Wecker an? (1 = an, 0 = aus)1
3Gültigkeitsmarke0xA5

Warum geht die Uhrzeit bei Stromausfall nicht verloren?

Fällt der Strom aus, schaltet der RTC-Chip selbstständig auf die CR2032-Zelle um und zählt nur noch weiter. In diesem Modus braucht der DS3231 ein paar Mikroampere, der DS1307 noch weniger; rechnerisch hält eine Knopfzelle mit 220 mAh über zehn Jahre, in der Praxis bestimmt ihre eigene Lagerfähigkeit die Lebensdauer. Kommt der Strom zurück, startet der Arduino neu, liest die Uhrzeit aus der RTC und die Weckzeit aus dem EEPROM und macht weiter, als wäre nichts gewesen. Einzige Lücke: Während des Ausfalls kann der Wecker nicht klingeln, weil Buzzer und Arduino nicht an einer Batterie hängen. Wo der Strom öfter ausfällt, löst eine Versorgung über eine 18650-Zelle, ein Lademodul und einen Aufwärtswandler auch das. Springt die Uhr bei jedem Reset auf die Kompilierzeit, ist die RTC-Batterie leer oder sitzt nicht richtig.

ESP32-NTP-Version: Uhrzeit aus dem Internet ohne RTC-Modul

Weil der ESP32 ins WLAN kann, holt er die Uhrzeit statt aus einem RTC-Modul von Zeitservern im Internet (NTP). Der Zeitzonen-String, den du configTzTime() übergibst, enthält auch die Sommerzeitregeln, die Umstellung Ende März und Ende Oktober passiert also automatisch. Auf dem ESP32 nimmt man statt EEPROM die Bibliothek Preferences; sie speichert die Weckzeit als Schlüssel-Wert-Paare im Flash. In dieser Version genügt ein einziger Taster: Läuft der Alarm, schlummert ein kurzer Druck 5 Minuten, ein Druck über 1,5 Sekunden schaltet ihn aus. Zum Stellen der Weckzeit tippst du eine Uhrzeit wie 07:30 in den seriellen Monitor, mit off schaltest du sie ab. Mehr zu NTP steht in ESP32-NTP-Uhr.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <time.h>
3#include <Preferences.h>
4#include <Wire.h>
5#include <LiquidCrystal_I2C.h>
6
7const char* WIFI_SSID = "MiRed";       // Wi-Fi ağ adı / Wi-Fi network name
8const char* WIFI_PASS = "MiClave";     // Wi-Fi şifresi / Wi-Fi password
9// POSIX saat dilimi / POSIX time zone:
10// Türkiye "<+03>-3" | España "CET-1CEST,M3.5.0,M10.5.0/3" | México "CST6"
11// Argentina "<-03>3" | Colombia "<-05>5" | Deutschland "CET-1CEST,M3.5.0,M10.5.0/3"
12const char* TZ_INFO = "<+03>-3";
13
14const int BUZZER_PIN = 25;             // pasif buzzer / passive buzzer
15const int BUTTON_PIN = 27;             // kısa: ertele, uzun: sustur / short: snooze, long: stop
16const int SNOOZE_MIN = 5;
17
18LiquidCrystal_I2C lcd(0x27, 16, 2);
19Preferences prefs;                     // ESP32'de EEPROM yerine / replaces EEPROM on the ESP32
20
21int alarmHour = 7, alarmMin = 0;
22bool alarmOn = false;
23bool ringing = false;
24bool beepOn = false;
25time_t snoozeAt = 0;
26int lastAlarmKey = -1;
27unsigned long ringStart = 0;
28
29void saveAlarm() {
30  prefs.putUChar("h", alarmHour);
31  prefs.putUChar("m", alarmMin);
32  prefs.putBool("on", alarmOn);
33}
34
35void handleSerial() {                  // "07:30" kurar, "off" kapatır / "07:30" sets, "off" disables
36  if (!Serial.available()) return;
37  String s = Serial.readStringUntil('\n');
38  s.trim();
39  int h, m;
40  if (s.equalsIgnoreCase("off")) {
41    alarmOn = false;
42    saveAlarm();
43    Serial.println("Alarm OFF");
44  } else if (sscanf(s.c_str(), "%d:%d", &h, &m) == 2 && h >= 0 && h < 24 && m >= 0 && m < 60) {
45    alarmHour = h;
46    alarmMin = m;
47    alarmOn = true;
48    saveAlarm();
49    Serial.printf("Alarm %02d:%02d ON\n", h, m);
50  }
51}
52
53void setup() {
54  Serial.begin(115200);
55  pinMode(BUTTON_PIN, INPUT_PULLUP);
56  Wire.begin(21, 22);                  // SDA, SCL
57  lcd.init();
58  lcd.backlight();
59
60  prefs.begin("alarm", false);         // kalıcı ayarlar / persistent settings
61  alarmHour = prefs.getUChar("h", 7);
62  alarmMin = prefs.getUChar("m", 0);
63  alarmOn = prefs.getBool("on", false);
64
65  lcd.print("Wi-Fi...");
66  WiFi.begin(WIFI_SSID, WIFI_PASS);
67  while (WiFi.status() != WL_CONNECTED) delay(250);
68  configTzTime(TZ_INFO, "pool.ntp.org", "time.google.com");   // yaz saati otomatik / DST is automatic
69  lcd.clear();
70}
71
72void loop() {
73  handleSerial();
74  struct tm t;
75  if (!getLocalTime(&t, 100)) return;  // NTP saati henüz gelmedi / NTP time not received yet
76  time_t nowEpoch = time(nullptr);
77  int key = t.tm_yday * 1440 + t.tm_hour * 60 + t.tm_min;   // gün + dakika / day + minute
78
79  if (!ringing && alarmOn && t.tm_hour == alarmHour && t.tm_min == alarmMin && key != lastAlarmKey) {
80    lastAlarmKey = key;
81    ringing = true;
82    ringStart = millis();
83  }
84  if (!ringing && snoozeAt && nowEpoch >= snoozeAt) {
85    snoozeAt = 0;
86    ringing = true;
87    ringStart = millis();
88  }
89
90  // Buton: basma süresini ölç / button: measure how long it was held
91  static unsigned long downAt = 0;
92  static bool wasDown = false;
93  bool isDown = digitalRead(BUTTON_PIN) == LOW;
94  if (isDown && !wasDown) downAt = millis();
95  if (!isDown && wasDown && ringing) {
96    unsigned long held = millis() - downAt;
97    if (held > 1500) ringing = false;                 // uzun: sustur / long: stop
98    else if (held > 30) {                             // kısa: ertele / short: snooze
99      ringing = false;
100      snoozeAt = nowEpoch + SNOOZE_MIN * 60;
101    }
102  }
103  wasDown = isDown;
104  if (ringing && millis() - ringStart > 60000) ringing = false;   // 1 dk sonra sus / stop after 1 min
105
106  // 0,5 sn bip, 0,5 sn sessiz / 0.5 s beep, 0.5 s pause
107  bool beep = ringing && (millis() / 500) % 2;
108  if (beep != beepOn) {
109    beepOn = beep;
110    if (beep) tone(BUZZER_PIN, 2000);
111    else noTone(BUZZER_PIN);
112  }
113
114  static int lastSec = -1;
115  if (t.tm_sec != lastSec) {            // saniyede bir yaz / update once per second
116    lastSec = t.tm_sec;
117    char l1[17], l2[17];
118    strftime(l1, sizeof(l1), "%H:%M:%S   %d/%m", &t);
119    if (ringing) snprintf(l2, sizeof(l2), "WAKE UP!        ");
120    else if (snoozeAt) snprintf(l2, sizeof(l2), "Snooze %2d min   ", (int)((snoozeAt - nowEpoch + 59) / 60));
121    else snprintf(l2, sizeof(l2), "Alarm %02d:%02d  %s", alarmHour, alarmMin, alarmOn ? "ON " : "OFF");
122    lcd.setCursor(0, 0); lcd.print(l1);
123    lcd.setCursor(0, 1); lcd.print(l2);
124  }
125}
RegionTZ_INFO-StringSommerzeit
Türkei<+03>-3Keine
Spanien, Deutschland, Frankreich, ItalienCET-1CEST,M3.5.0,M10.5.0/3Letzter Sonntag im März und Oktober
Vereinigtes KönigreichGMT0BST,M3.5.0/1,M10.5.0Letzter Sonntag im März und Oktober
Mexiko (Zentrum)CST6Seit 2022 keine
Argentinien<-03>3Keine
Kolumbien<-05>5Keine
USA OstküsteEST5EDT,M3.2.0,M11.1.0Zweiter Sonntag im März, erster im November

Die Schwachstelle der NTP-Version: Nach einem Stromausfall kennt sie die Uhrzeit erst, wenn das WLAN wieder da ist; bootet der Router langsamer als der ESP32, bleibt das Display ein paar Minuten leer. Am robustesten ist die Kombination: Schließ einen DS3231 an den ESP32 an, hol die Zeit einmal täglich per NTP und schreib sie in die RTC, ohne Internet liest du sie aus der RTC. So stellt sich die Sommerzeit von selbst um und bei Stromausfall geht die Uhrzeit trotzdem nicht verloren.

Ideen, um deinen Wecker zu erweitern

  • Wecker nur werktags: Lass ihn mit dayOfTheWeek() von DateTime nur Montag bis Freitag klingeln; speichere die Tage als 7-Bit-Maske im EEPROM.
  • Lichtwecker: Lass 15 Minuten vor der Weckzeit einen WS2812B-LED-Ring langsam von Rot nach Weiß aufleuchten.
  • Mit MP3 aufwachen: Spiel statt des Buzzers mit einem DFPlayer Mini dein Lieblingslied von der SD-Karte.
  • Temperaturanzeige: Zeig den Wert von rtc.getTemperature() des DS3231 in der zweiten Displayzeile an.
  • Automatische Helligkeit: Schalte mit einem LDR die LCD-Hintergrundbeleuchtung nachts aus und morgens an.
  • Große Ziffern: Damit du die Uhrzeit vom Bett aus liest, nimm statt des LCD ein TM1637 oder eine 7-Segment-Anzeige.

Häufige Fehler und ihre Lösung

  • Fehler "'class LiquidCrystal_I2C' has no member named 'init'": Auf deinem Rechner sind zwei verschiedene LiquidCrystal_I2C-Bibliotheken installiert und der Compiler nimmt die falsche. Behalte die von Frank de Brabander und entferne die andere aus dem libraries-Ordner.
  • Das LCD leuchtet, zeigt aber keinen Text: Stell mit dem blauen Trimmpoti auf der Rückseite den Kontrast ein; hilft das nicht, ist die Adresse 0x3F statt 0x27.
  • Es erscheint "RTC not found": SDA und SCL sind vertauscht oder VCC der RTC ist nicht angeschlossen. Im I2C-Scanner muss die Adresse 0x68 auftauchen.
  • Die Uhr springt bei jedem Einschalten auf die Kompilierzeit: Die RTC-Batterie ist leer, verkehrt herum eingelegt oder fehlt. Tausch sie und stell die Zeit im Menü neu ein.
  • Der Buzzer klickt nur oder spielt nur einen Ton: Du verwendest einen aktiven Buzzer. Für Melodien mit tone() brauchst du einen passiven.
  • Taster lösen von selbst aus: INPUT_PULLUP fehlt bei pinMode oder der Taster hängt an 5V statt an GND; ein offener Pin liest Zufallswerte.
  • Die Uhr geht ein paar Minuten falsch: Beim DS1307 ist das normal; steig auf den DS3231 um oder gleich die Zeit mit der ESP32-Version täglich per NTP ab.
Die Kompilierzeit hinkt dem Hochladen ein paar Sekunden hinterher. Willst du die Uhrzeit sekundengenau, stell die Minuten nach der Uhr deines Handys ein und drück MENU genau in dem Moment, in dem die Minute umspringt; weil der Code die Sekunden auf 0 setzt, stimmt deine Uhr dann exakt.

Dieser Wecker vereint die Grundthemen des Arduino, RTC, I2C, EEPROM, Taster abfragen und Buzzer, in einem wirklich nützlichen Gerät. Wenn du ähnliche Uhrenprojekte Schritt für Schritt ausprobieren möchtest, findest du in der BlueGrays-App die LCD-Uhr mit DS1302-RTC, die ESP32-Digitaluhr mit DS1307, die ESP32-Internetuhr mit NTP, die Digitaluhr mit vierstelliger 7-Segment-Anzeige und Buzzer-Melodien, jeweils mit Schaltplan und fertigem Code.

Häufige Fragen

Wie baut man einen Wecker mit Arduino?

Ein RTC-Modul (DS3231 oder DS1307) hält die Uhrzeit, ein I2C-LCD zeigt sie an, mit Tastern stellst du Uhrzeit und Weckzeit ein, und zur Weckzeit spielt ein passiver Buzzer eine Melodie. Speicherst du die Weckzeit im EEPROM, übersteht sie auch einen Stromausfall.

Kann der Arduino ohne RTC-Modul die Uhrzeit halten?

Mit millis() geht das grob, aber die Zeit beginnt bei jedem Reset und Stromausfall von vorn und kann pro Tag um Minuten abweichen. Für eine echte Uhr brauchst du ein RTC-Modul oder, wenn WLAN da ist, einen ESP32 mit NTP.

Was ist besser, DS1307 oder DS3231?

Der DS3231 ist viel genauer: Dank seines temperaturkompensierten internen Quarzes weicht er nur etwa eine Minute pro Jahr ab. Der DS1307 kann ein paar Minuten pro Monat danebenliegen und braucht 5 V; für einen Wecker nimm den DS3231.

Geht die Uhrzeit beim Arduino bei Stromausfall verloren?

Nicht, wenn das RTC-Modul eine Batterie hat: Die RTC zählt mit der Knopfzelle weiter und der Arduino liest nach dem Einschalten die richtige Zeit. Da die Weckzeit im EEPROM liegt, bleiben auch deine Einstellungen erhalten; nur während des Ausfalls kann der Wecker nicht klingeln.

Welchen Buzzer brauche ich für einen Arduino-Wecker?

Für eine Melodie brauchst du einen passiven Buzzer, der mit tone() verschiedene Frequenzen erzeugt. Ein aktiver Buzzer gibt nur einen festen Ton; reicht dir ein einfacher Piepton, kannst du ihn mit digitalWrite ansteuern.

Wie baue ich eine Schlummerfunktion in den Arduino-Wecker ein?

Wird während des Alarms ein Taster gedrückt, addierst du 300 Sekunden zur aktuellen Unixzeit und speicherst das Ergebnis in einer Variablen. Die Hauptschleife startet den Alarm neu, sobald die Uhrzeit diesen Wert erreicht; mit der Unixzeit klappt das auch über Mitternacht.

Alle Projekte ansehen
Verwendung des Summers
AR-13Anfänger

Verwendung des Summers

Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

4.7(92)
170
DS1302-RTC-Uhrenmodul einrichten
AR-45Anfänger

DS1302-RTC-Uhrenmodul einrichten

Du bringst ein kleines Uhrmodul zum Laufen, das die Zeit nicht vergisst, selbst wenn der Arduino ausgeschaltet ist.

4.5(23)
31
DS1302 RTC-Uhr mit LCD-Anzeige
AR-46Mittel
Premium

DS1302 RTC-Uhr mit LCD-Anzeige

Eine kleine Tischuhr, die die Zeit auch bei Stromausfall nicht vergisst. Das Uhrmodul DS1302 hält die Zeit mit seiner eigenen kleinen Batterie; jede Sekunde liest der Arduino sie aus und schreibt…

4.7(41)
51
Digitale Uhr mit ESP32 und RTC DS1307 (I2C + LCD)
ES-18Mittel
Premium

Digitale Uhr mit ESP32 und RTC DS1307 (I2C + LCD)

In diesem Projekt zeigen wir Uhrzeit und Datum auf einem 16x2-I2C-LCD-Display mithilfe des DS1307-Echtzeituhrmoduls (RTC) an. Das DS1307 ist ein batteriegestütztes RTC, das die Uhrzeit auch dann beibehält, wenn das ESP32 ausgeschaltet ist. Beide Module teilen sich denselben I2C-Bus (SDA/SCL), sodass wir mit nur zwei Signalkabeln die Steuerung mehrerer Geräte erlernen. So lernen Sie das I2C-Protokoll und die Funktionsweise von RTC-Modulen in der Praxis kennen.

4.6(26)
40
ESP32: Echtzeit aus dem Internet per NTP
ES-26Fortgeschritten
Premium

ESP32: Echtzeit aus dem Internet per NTP

Der ESP32 verbindet sich mit dem WLAN und holt die Uhrzeit millisekundengenau von NTP-Servern (Network Time Protocol). Mit configTzTime() gilt automatisch die türkische Zeitzone (TRT, UTC+3); in Ländern mit Sommerzeit regelt ein POSIX-TZ-String die Umstellung (DST) von selbst. Die Uhrzeit erscheint im Serial Monitor und auf einem optionalen I2C-LCD.

4.5(13)
22
Digitaluhr mit 4-stelliger 7-Segment-Anzeige
AR-48Mittel
Premium

Digitaluhr mit 4-stelliger 7-Segment-Anzeige

Eine leuchtende vierstellige Digitaluhr, ähnlich wie die am Backofen. Das Uhrmodul DS1302 hält die Zeit, der Arduino liest jede Sekunde Stunden und Minuten aus und zeigt sie auf der vierstelligen…

4.8(56)
73
Punktmatrixuhr und Kalender (MAX7219, DS1307)
AR-84Mittel
Premium

Punktmatrixuhr und Kalender (MAX7219, DS1307)

Eine leuchtende Tafel für Tisch oder Wand, die Uhrzeit und Datum als Laufschrift zeigt.

5.0(37)
59
Verwendung des LCD-Bildschirms mit I2C
AR-32Anfänger
Premium

Verwendung des LCD-Bildschirms mit I2C

Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

4.8(53)
70