Réveil Arduino : RTC DS3231, écran LCD, buzzer et snooze
Réveil Arduino pas à pas : RTC DS3231 ou DS1307, LCD I2C, 3 boutons pour l'heure et l'alarme, mélodie au buzzer, snooze, alarme en EEPROM et version ESP32 NTP.
Fabriquer un réveil Arduino réunit dans un seul projet le module RTC, l'écran LCD, les boutons et le buzzer : tu apprends énormément et tu obtiens un objet que tu utiliseras vraiment chaque matin. Dans ce guide, nous allons construire avec un module RTC DS3231 (ou DS1307), un LCD 16x2 I2C, trois boutons poussoirs et un buzzer passif un réveil dont l'heure et l'alarme se règlent avec les boutons, qui joue une mélodie, propose un snooze (répétition) de 5 minutes et ne perd pas l'heure même en cas de coupure de courant.
Tu trouveras le câblage pas à pas, un tableau qui décrit le menu des boutons, une mélodie jouée sans delay, l'enregistrement de l'heure d'alarme en EEPROM et le code complet, déjà compilé. Dans la dernière partie, nous ferons tourner le même réveil sans module RTC, avec un ESP32 qui récupère l'heure sur Internet (NTP) et passe tout seul à l'heure d'été.

Comment fonctionne un réveil Arduino ?
L'horloge interne d'Arduino (millis) ne compte que tant que la carte est alimentée et repart de zéro à chaque redémarrage ; en plus, les cartes à résonateur céramique comme l'Uno peuvent dériver de plusieurs minutes par jour. C'est pourquoi l'heure est confiée à un module RTC (horloge temps réel) : cette petite carte, avec son propre quartz et sa pile bouton, continue de compter même quand l'Arduino est éteint. À chaque tour de boucle, l'Arduino lit l'heure du RTC, l'affiche sur le LCD, surveille les boutons et, quand l'heure correspond à l'heure d'alarme, déclenche le buzzer. Tout le comportement est géré par une petite machine à états : affichage de l'heure, réglage de l'heure, réglage de l'alarme et alarme en cours.
| Composant | Rôle | Remarque |
|---|---|---|
| Arduino Uno ou Nano | Le cerveau | Sur le Nano, mêmes broches (A4/A5) |
| Module RTC DS3231 ou DS1307 | Garde l'heure | Tous deux en I2C, adresse 0x68 |
| LCD 16x2 I2C | Affiche l'heure, la date et l'alarme | Adresse généralement 0x27 ou 0x3F |
| 3 boutons poussoirs | MENU, plus (+) et moins (-) | Pas de résistance (INPUT_PULLUP) |
| Buzzer passif | Joue la mélodie | Un buzzer actif ne donne qu'une seule note |
| Pile bouton CR2032 | Alimente le RTC pendant les coupures | Attention au circuit de charge du module |
| Breadboard et câbles Dupont | Connexions | Plaque à pastilles pour un réveil définitif |
DS1307 ou DS3231 ?
Les deux modules utilisent la même adresse I2C et fonctionnent avec presque le même code grâce à la bibliothèque RTClib, mais leur précision est très différente. Le DS1307 dépend d'un quartz externe de 32,768 kHz et dérive quand la température de la pièce change ; sur les modules bon marché, quelques minutes d'écart par mois sont normales. Le DS3231, lui, intègre le quartz dans la puce et le compense en température : il dérive d'environ une minute par an. Pour une horloge censée te réveiller tous les matins, le DS3231 est de loin le meilleur choix ; si tu as déjà un DS1307, le code fonctionne aussi avec lui.
| Caractéristique | DS1307 | DS3231 |
|---|---|---|
| Précision | Dépend du quartz, peut dériver de 1 à 5 minutes par mois | ±2 ppm, environ 1 minute par an |
| Compensation en température | Non | Oui (TCXO) |
| Alimentation | 4,5-5,5 V | 2,3-5,5 V (fonctionne aussi en 3,3 V avec un ESP32) |
| Alarme intégrée | Non | 2 alarmes et une sortie INT/SQW |
| Capteur de température | Non | Oui (±3 °C) |
| Adresse I2C | 0x68 | 0x68 |
| Classe RTClib | RTC_DS1307 | RTC_DS3231 |
Câblage du réveil Arduino
| Connexion | Arduino Uno | ESP32 (version NTP) |
|---|---|---|
| SDA du LCD et du RTC | A4 | GPIO 21 (LCD seulement) |
| SCL du LCD et du RTC | A5 | GPIO 22 (LCD seulement) |
| VCC du LCD | 5V | VIN (5V) |
| VCC du RTC | 5V | Inutile |
| Bouton MENU | D2 | - |
| Bouton plus (+) | D3 | - |
| Bouton moins (-) / snooze | D4 | GPIO 27 (bouton unique) |
| Buzzer passif (+) | D8 | GPIO 25 |
| Toutes les masses | GND | GND |
Le LCD et le RTC partagent le même bus I2C : les SDA des deux modules vont sur A4 et les SCL sur A5 ; comme leurs adresses sont différentes, ils ne se gênent pas. Pour les boutons, il suffit de relier une patte à la broche et la patte opposée à GND ; comme le code utilise INPUT_PULLUP, aucune résistance externe n'est nécessaire et la broche lit LOW quand on appuie (détails dans comment brancher un bouton poussoir). Le + du buzzer va sur D8 et le - sur GND. Comme la mélodie utilise la fonction tone(), il te faut un buzzer passif ; la différence est expliquée dans Qu'est-ce qu'un buzzer ?.
Menu à boutons : régler l'heure et l'alarme avec trois boutons
Pour tout régler avec seulement trois boutons, chaque bouton a un rôle différent selon le mode. Le bouton MENU passe à l'étape suivante, les boutons plus et moins modifient la valeur sélectionnée. Cette structure s'appelle une machine à états : elle permet d'écrire chaque mode dans son propre case au lieu d'imbriquer des dizaines de if. Le tableau ci-dessous montre le menu complet ; garde-le sous les yeux en lisant le code et tu comprendras tout de suite ce que fait chaque ligne.
| Mode (à l'écran) | MENU | Plus (+) | Moins (-) |
|---|---|---|---|
| Écran de l'heure | Entrer dans le réglage de l'heure | Activer / désactiver l'alarme | Annuler le snooze |
| SET TIME : heures | Passer aux minutes | Heure +1 | Heure -1 |
| SET TIME : minutes | Écrire l'heure dans le RTC, passer à l'alarme | Minute +1 | Minute -1 |
| SET ALARM : heures | Passer aux minutes | Heure d'alarme + | Heure d'alarme - |
| SET ALARM : minutes | Enregistrer en EEPROM, activer l'alarme, revenir à l'heure | Minute + | Minute - |
| WAKE UP! (alarme en cours) | Arrêter | Snooze 5 minutes | Snooze 5 minutes |
Bibliothèques et première configuration
- Dans le gestionnaire de bibliothèques, installe RTClib (d'Adafruit) et laisse-le installer Adafruit BusIO comme dépendance.
- Pour le LCD, installe LiquidCrystal I2C (de Frank de Brabander). Les bibliothèques EEPROM et Wire sont fournies avec Arduino.
- Si tu n'es pas sûr de l'adresse du LCD, lance le croquis scanner du guide LCD I2C et remplace 0x27 dans le code par l'adresse trouvée.
- Si tu utilises un DS1307, mets USE_DS3231 à 0 dans le code.
- Téléverse le code. Si le RTC démarre pour la première fois ou si sa pile est vide, l'horloge est réglée sur le moment de la compilation et un bref avertissement de pile s'affiche.
- Entre dans le réglage de l'heure avec MENU, règle l'heure exacte, puis l'alarme.
Code du réveil Arduino
Voici le code complet. Aucun long delay dans la boucle : les boutons, la mélodie et l'affichage sont cadencés avec millis(), donc les boutons réagissent instantanément même pendant que l'alarme sonne. L'écran n'est réécrit que lorsque la seconde change ou qu'un bouton est pressé, ce qui évite le scintillement du LCD.
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}Comment fonctionne le code ?
| Partie | Rôle |
|---|---|
| pressed() | Lit le bouton avec un anti-rebond de 30 ms ; renvoie true à chaque nouvel appui et répète tant qu'il est maintenu dans les modes de réglage. |
| enum Mode et switch | Gèrent séparément les modes horloge, réglage de l'heure, réglage de l'alarme et alarme en cours. |
| key (jour × 1440 + minute) | Empêche l'alarme de sonner deux fois dans la même minute. |
| snoozeAt | Mémorise la fin du snooze en unixtime ; fonctionne aussi quand il passe minuit. |
| playMelody() | Joue les notes l'une après l'autre avec millis(), sans delay. |
| draw() et printLine() | N'écrivent sur l'écran que si nécessaire et effacent la fin de ligne avec des espaces. |
| loadAlarm() et saveAlarm() | Lisent et enregistrent en EEPROM l'heure d'alarme et son état activé/désactivé. |
| USE_DS3231 | Passe du DS3231 au DS1307 en changeant une seule ligne. |
Pour déclencher l'alarme, on regarde les minutes et non les secondes. Guetter la seconde 0 est risqué : si la boucle est occupée à rafraîchir l'écran pendant cette seconde-là, l'alarme pourrait ne jamais sonner. À la place, l'alarme démarre quand l'heure et la minute correspondent, et on mémorise l'identité de cette minute dans lastAlarmKey. Ainsi, si tu arrêtes l'alarme dans la même minute, elle ne redémarre pas. La durée du snooze est calculée avec l'unixtime fourni par le RTC (secondes écoulées depuis 1970) : si tu repousses de 5 minutes à 23 h 58, l'alarme sonne sans souci à 0 h 03. La logique de temporisation avec millis() est expliquée dans millis ou delay.
Mélodie au buzzer et fonction snooze
La mélodie tient dans un petit tableau de paires fréquence et durée : les notes à 1047 Hz (do), 1319 Hz (mi), 1568 Hz (sol) et 2093 Hz (le do à l'octave supérieure) s'enchaînent avec de courtes pauses, puis viennent 600 ms de silence et la boucle recommence. Pour un réveil plus énergique, tu peux raccourcir le silence ou ajouter tes propres notes ; une fréquence de 0 correspond à un silence. Si personne n'arrête l'alarme, elle se tait d'elle-même au bout de 60 secondes et ne dérange pas les voisins quand tu es absent. Un appui sur plus ou moins repousse l'alarme de 5 minutes et l'écran affiche le temps restant ; le bouton MENU la coupe pour la journée, et elle sonnera de nouveau le lendemain à la même heure.
Enregistrer l'alarme en EEPROM
Le RTC garde l'heure, mais l'heure d'alarme se trouve dans la RAM de l'Arduino et s'efface quand le courant disparaît. Pour l'éviter, on l'écrit dans l'EEPROM de 1 Ko de l'Arduino Uno. Comme chaque cellule supporte environ 100 000 écritures, on utilise EEPROM.update(), qui n'écrit rien si la valeur est déjà identique. Le marqueur 0xA5 du quatrième octet indique que l'EEPROM a déjà été écrite par ce programme ; au tout premier démarrage, on ne lit donc pas de valeurs aléatoires et l'alarme ne se retrouve pas réglée sur une heure absurde comme 37:99. Plus de détails dans le guide EEPROM Arduino.
| Adresse EEPROM | Contenu | Exemple |
|---|---|---|
| 0 | Heure de l'alarme (0-23) | 7 |
| 1 | Minute de l'alarme (0-59) | 30 |
| 2 | Alarme activée ? (1 = oui, 0 = non) | 1 |
| 3 | Marqueur de validité | 0xA5 |
Pourquoi l'heure ne se perd-elle pas pendant une coupure de courant ?
Lors d'une coupure, la puce RTC bascule toute seule sur la pile CR2032 et se contente de continuer à compter. Dans ce mode, le DS3231 consomme quelques microampères et le DS1307 encore moins ; sur le papier, une pile bouton de 220 mAh tient plus de dix ans, et en pratique c'est le vieillissement de la pile elle-même qui fixe sa durée de vie. Au retour du courant, l'Arduino redémarre, lit l'heure dans le RTC et l'alarme dans l'EEPROM, puis reprend comme si de rien n'était. Seule limite : l'alarme ne peut pas sonner pendant la coupure, car le buzzer et l'Arduino ne sont pas sur batterie. Dans un logement où les coupures sont fréquentes, alimenter l'Arduino avec un accu 18650, un module de charge et un convertisseur élévateur règle aussi ce problème. Si l'horloge revient à l'heure de compilation à chaque reset, la pile du RTC est vide ou mal insérée.
Version ESP32 NTP : l'heure par Internet sans module RTC
Comme l'ESP32 se connecte au Wi-Fi, il peut récupérer l'heure auprès des serveurs de temps d'Internet (NTP) au lieu d'un module RTC. La chaîne de fuseau horaire passée à configTzTime() contient aussi les règles de l'heure d'été : le changement de fin mars et de fin octobre se fait donc automatiquement. Sur l'ESP32, on utilise la bibliothèque Preferences au lieu de l'EEPROM ; elle enregistre l'heure d'alarme dans la flash sous forme de paires clé-valeur. Dans cette version, un seul bouton suffit : quand l'alarme sonne, un appui court la repousse de 5 minutes et un appui de plus de 1,5 seconde l'arrête. Pour régler l'alarme, tape une heure comme 07:30 dans le moniteur série, et off pour la désactiver. Les détails sur le NTP sont dans horloge NTP avec l'ESP32.
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}| Région | Chaîne TZ_INFO | Heure d'été |
|---|---|---|
| Turquie | <+03>-3 | Aucune |
| Espagne, Allemagne, France, Italie | CET-1CEST,M3.5.0,M10.5.0/3 | Dernier dimanche de mars et d'octobre |
| Royaume-Uni | GMT0BST,M3.5.0/1,M10.5.0 | Dernier dimanche de mars et d'octobre |
| Mexique (centre) | CST6 | Aucune depuis 2022 |
| Argentine | <-03>3 | Aucune |
| Colombie | <-05>5 | Aucune |
| Est des États-Unis | EST5EDT,M3.2.0,M11.1.0 | Deuxième dimanche de mars, premier de novembre |
Le point faible de la version NTP, c'est qu'après une coupure elle ne connaît pas l'heure tant que le Wi-Fi n'est pas revenu ; si ta box redémarre plus lentement que l'ESP32, l'écran peut rester vide quelques minutes. La solution la plus robuste consiste à combiner les deux : branche un DS3231 sur l'ESP32, récupère l'heure par NTP une fois par jour et écris-la dans le RTC, puis lis-la dans le RTC quand Internet manque. L'heure d'été se règle alors toute seule et tu ne perds pas l'heure en cas de coupure.
Idées pour améliorer ton réveil
- Alarme en semaine : avec dayOfTheWeek() de DateTime, fais sonner l'alarme seulement du lundi au vendredi ; enregistre les jours sous forme de masque de 7 bits en EEPROM.
- Simulateur d'aube : 15 minutes avant l'alarme, allume progressivement un anneau de LED WS2812B du rouge au blanc.
- Réveil en musique : remplace le buzzer par un DFPlayer Mini pour jouer ta chanson préférée depuis une carte SD.
- Affichage de la température : affiche la valeur rtc.getTemperature() du DS3231 sur la deuxième ligne de l'écran.
- Luminosité automatique : avec une photorésistance (LDR), éteins le rétroéclairage du LCD la nuit et rallume-le le matin.
- Gros chiffres : pour lire l'heure depuis le lit, utilise un TM1637 ou un afficheur 7 segments à la place du LCD.
Erreurs fréquentes et solutions
- Erreur "'class LiquidCrystal_I2C' has no member named 'init'" : deux bibliothèques LiquidCrystal_I2C différentes sont installées et le compilateur choisit la mauvaise. Garde celle de Frank de Brabander et supprime l'autre du dossier libraries.
- Le LCD s'allume mais n'affiche rien : règle le contraste avec le potentiomètre bleu au dos du module ; si rien ne change, l'adresse est 0x3F et non 0x27.
- Le message "RTC not found" s'affiche : SDA et SCL sont inversés ou le VCC du RTC n'est pas branché. Le scanner I2C doit afficher l'adresse 0x68.
- L'heure revient à l'heure de compilation à chaque mise sous tension : la pile du RTC est vide, à l'envers ou absente. Remplace-la et règle de nouveau l'heure depuis le menu.
- Le buzzer ne fait que cliquer ou ne joue qu'une note : tu utilises un buzzer actif. Pour jouer des mélodies avec tone(), il faut un buzzer passif.
- Les boutons s'activent tout seuls : INPUT_PULLUP manque dans pinMode ou le bouton est relié au 5V au lieu de GND ; une broche en l'air lit des valeurs aléatoires.
- L'horloge dérive de quelques minutes : c'est normal avec un DS1307 ; passe au DS3231 ou synchronise l'heure par NTP chaque jour avec la version ESP32.
Ce réveil rassemble dans un seul objet utile les notions de base d'Arduino : RTC, I2C, EEPROM, lecture de boutons et buzzer. Si tu veux essayer pas à pas des projets d'horloge similaires, l'application BlueGrays propose l'horloge LCD avec RTC DS1302, l'horloge numérique ESP32 avec DS1307, l'horloge Internet ESP32 avec NTP, l'horloge numérique sur afficheur 7 segments à 4 chiffres et des mélodies au buzzer, chacun avec son schéma de câblage et son code prêt à l'emploi.
Questions fréquentes
Comment fabriquer un réveil avec Arduino ?
Un module RTC (DS3231 ou DS1307) garde l'heure, un LCD I2C l'affiche, des boutons règlent l'heure et l'alarme, et à l'heure dite un buzzer passif joue une mélodie. Si tu enregistres l'heure d'alarme en EEPROM, elle survit aussi aux coupures de courant.
Un Arduino peut-il garder l'heure sans module RTC ?
Avec millis(), il peut la garder approximativement, mais l'heure repart de zéro à chaque reset ou coupure de courant et peut dériver de plusieurs minutes par jour. Pour une vraie horloge, il faut un module RTC ou, si tu as du Wi-Fi, un ESP32 avec NTP.
Lequel est le meilleur, le DS1307 ou le DS3231 ?
Le DS3231 est bien plus précis : grâce à son quartz interne compensé en température, il dérive d'environ une minute par an. Le DS1307 peut dériver de quelques minutes par mois et demande 5 V ; pour un réveil, choisis le DS3231.
L'horloge d'un Arduino se remet-elle à zéro en cas de coupure de courant ?
Pas si le module RTC a une pile : le RTC continue de compter sur la pile et l'Arduino relit l'heure exacte au redémarrage. Comme l'heure d'alarme est en EEPROM, tes réglages sont aussi conservés ; l'alarme ne peut simplement pas sonner pendant la coupure.
Quel buzzer faut-il pour un réveil Arduino ?
Pour jouer une mélodie, il faut un buzzer passif, capable de produire différentes fréquences avec la fonction tone(). Un buzzer actif ne donne qu'une note fixe ; si un simple bip te suffit, tu peux le piloter avec digitalWrite.
Comment ajouter un snooze à un réveil Arduino ?
Quand on appuie sur un bouton pendant que l'alarme sonne, on ajoute 300 secondes à l'unixtime du moment et on stocke le résultat dans une variable. La boucle principale relance l'alarme quand l'heure atteint cette valeur ; l'unixtime garantit un résultat correct même si le snooze passe minuit.
Projets à réaliser après cet article
Voir tous les projets
Utilisation du buzzer
Tu t'es déjà demandé comment une sonnette ou une alarme produit son son ? L'Arduino fait biper un petit buzzer à intervalles courts : bip, silence, bip, silence.

Configuration du module horloge RTC DS1302
Tu fais fonctionner un petit module horloge qui n'oublie jamais l'heure, même quand l'Arduino est éteint.

Horloge RTC DS1302 avec écran LCD
Une petite horloge de bureau qui n'oublie pas l'heure, même en cas de coupure de courant.

Horloge numérique avec ESP32 et RTC DS1307 (I2C + LCD)
Dans ce projet, nous affichons l'heure et la date sur un écran LCD 16x2 I2C à l'aide du module d'horloge en temps réel (RTC) DS1307. Le DS1307 est une RTC avec batterie de secours qui conserve l'heure même si l'ESP32 s'éteint. Les deux modules partagent la même ligne I2C (SDA/SCL), ce qui nous permet d'apprendre à contrôler plusieurs appareils avec seulement deux fils de signal. Vous decouvrirez ainsi le protocole I2C et le fonctionnement des modules RTC en pratique.

ESP32 : heure réelle depuis Internet via NTP
L'ESP32 se connecte au Wi-Fi et récupère l'heure exacte auprès de serveurs NTP (Network Time Protocol) à la milliseconde près. Avec configTzTime(), le fuseau horaire de la Turquie (TRT, UTC+3) s'applique automatiquement, et dans les pays à heure d'été, le changement (DST) est géré tout seul par une chaîne POSIX TZ. L'heure s'affiche dans le Serial Monitor et sur un LCD I2C en option.

Horloge numérique avec afficheur 7 segments à 4 chiffres
Une horloge numérique lumineuse à quatre chiffres, comme celle du four de la cuisine.

Horloge et calendrier matriciel (MAX7219, DS1307)
Un panneau lumineux pour ton bureau ou ton mur, qui affiche l'heure et la date en texte défilant.

Utilisation de l'écran LCD avec I2C
Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

