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.

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.
| Bauteil | Aufgabe | Hinweis |
|---|---|---|
| Arduino Uno oder Nano | Das Gehirn | Beim Nano dieselben Pins (A4/A5) |
| RTC-Modul DS3231 oder DS1307 | Hält die Uhrzeit | Beide I2C, Adresse 0x68 |
| 16x2-LCD mit I2C | Zeigt Uhrzeit, Datum und Weckzeit | Adresse meist 0x27 oder 0x3F |
| 3 Taster | MENU, Plus (+) und Minus (-) | Keine Widerstände nötig (INPUT_PULLUP) |
| Passiver Buzzer | Spielt die Melodie | Ein aktiver Buzzer kann nur einen Ton |
| Knopfzelle CR2032 | Versorgt die RTC bei Stromausfall | Achtung bei der Ladeschaltung des Moduls |
| Steckbrett und Jumperkabel | Verbindungen | Fü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.
| Eigenschaft | DS1307 | DS3231 |
|---|---|---|
| Genauigkeit | Vom Quarz abhängig, 1-5 Minuten Abweichung pro Monat möglich | ±2 ppm, etwa 1 Minute pro Jahr |
| Temperaturkompensation | Nein | Ja (TCXO) |
| Versorgung | 4,5-5,5 V | 2,3-5,5 V (am ESP32 auch mit 3,3 V) |
| Interner Alarm | Nein | 2 Alarme und INT/SQW-Ausgang |
| Temperatursensor | Nein | Ja (±3 °C) |
| I2C-Adresse | 0x68 | 0x68 |
| RTClib-Klasse | RTC_DS1307 | RTC_DS3231 |
Schaltung des Arduino-Weckers
| Verbindung | Arduino Uno | ESP32 (NTP-Version) |
|---|---|---|
| SDA von LCD und RTC | A4 | GPIO 21 (nur LCD) |
| SCL von LCD und RTC | A5 | GPIO 22 (nur LCD) |
| VCC des LCD | 5V | VIN (5V) |
| VCC der RTC | 5V | Nicht nötig |
| Taster MENU | D2 | - |
| Taster Plus (+) | D3 | - |
| Taster Minus (-) / Schlummern | D4 | GPIO 27 (ein einziger Taster) |
| Passiver Buzzer (+) | D8 | GPIO 25 |
| Alle GND | GND | GND |
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) | MENU | Plus (+) | Minus (-) |
|---|---|---|---|
| Uhranzeige | Uhrzeit stellen | Wecker an / aus | Schlummern abbrechen |
| SET TIME: Stunde | Weiter zu den Minuten | Stunde +1 | Stunde -1 |
| SET TIME: Minute | Zeit in die RTC schreiben, weiter zur Weckzeit | Minute +1 | Minute -1 |
| SET ALARM: Stunde | Weiter zu den Minuten | Weckstunde hoch | Weckstunde runter |
| SET ALARM: Minute | Im EEPROM speichern, Wecker einschalten, zurück zur Uhr | Minute hoch | Minute runter |
| WAKE UP! (Alarm läuft) | Ausschalten | 5 Minuten schlummern | 5 Minuten schlummern |
Bibliotheken und Ersteinrichtung
- Installiere im Bibliotheksverwalter RTClib (von Adafruit) und lass Adafruit BusIO als Abhängigkeit mitinstallieren.
- Für das LCD installierst du LiquidCrystal I2C (von Frank de Brabander). Die Bibliotheken EEPROM und Wire sind beim Arduino schon dabei.
- 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.
- Verwendest du einen DS1307, setz USE_DS3231 im Code auf 0.
- 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.
- 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.
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?
| Teil | Was 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 switch | Behandeln die Modi Uhr, Zeit stellen, Weckzeit stellen und Alarm getrennt. |
| key (Tag × 1440 + Minute) | Verhindert, dass der Alarm innerhalb derselben Minute zweimal startet. |
| snoozeAt | Speichert 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_DS3231 | Wechselt 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-Adresse | Inhalt | Beispiel |
|---|---|---|
| 0 | Weckstunde (0-23) | 7 |
| 1 | Weckminute (0-59) | 30 |
| 2 | Wecker an? (1 = an, 0 = aus) | 1 |
| 3 | Gültigkeitsmarke | 0xA5 |
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.
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}| Region | TZ_INFO-String | Sommerzeit |
|---|---|---|
| Türkei | <+03>-3 | Keine |
| Spanien, Deutschland, Frankreich, Italien | CET-1CEST,M3.5.0,M10.5.0/3 | Letzter Sonntag im März und Oktober |
| Vereinigtes Königreich | GMT0BST,M3.5.0/1,M10.5.0 | Letzter Sonntag im März und Oktober |
| Mexiko (Zentrum) | CST6 | Seit 2022 keine |
| Argentinien | <-03>3 | Keine |
| Kolumbien | <-05>5 | Keine |
| USA Ostküste | EST5EDT,M3.2.0,M11.1.0 | Zweiter 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.
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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.

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

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…

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.

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.

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…

Punktmatrixuhr und Kalender (MAX7219, DS1307)
Eine leuchtende Tafel für Tisch oder Wand, die Uhrzeit und Datum als Laufschrift zeigt.

Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

