Guides · 11 min de lecture

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

Module RTC DS1307 avec support de pile CR2032
Module RTC DS1307 : broches GND, 5V, SDA, SCL et SQW ; la pile CR2032 au dos fait tourner l'horloge pendant les coupures de courant.

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.

ComposantRôleRemarque
Arduino Uno ou NanoLe cerveauSur le Nano, mêmes broches (A4/A5)
Module RTC DS3231 ou DS1307Garde l'heureTous deux en I2C, adresse 0x68
LCD 16x2 I2CAffiche l'heure, la date et l'alarmeAdresse généralement 0x27 ou 0x3F
3 boutons poussoirsMENU, plus (+) et moins (-)Pas de résistance (INPUT_PULLUP)
Buzzer passifJoue la mélodieUn buzzer actif ne donne qu'une seule note
Pile bouton CR2032Alimente le RTC pendant les coupuresAttention au circuit de charge du module
Breadboard et câbles DupontConnexionsPlaque à 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éristiqueDS1307DS3231
PrécisionDépend du quartz, peut dériver de 1 à 5 minutes par mois±2 ppm, environ 1 minute par an
Compensation en températureNonOui (TCXO)
Alimentation4,5-5,5 V2,3-5,5 V (fonctionne aussi en 3,3 V avec un ESP32)
Alarme intégréeNon2 alarmes et une sortie INT/SQW
Capteur de températureNonOui (±3 °C)
Adresse I2C0x680x68
Classe RTClibRTC_DS1307RTC_DS3231

Câblage du réveil Arduino

ConnexionArduino UnoESP32 (version NTP)
SDA du LCD et du RTCA4GPIO 21 (LCD seulement)
SCL du LCD et du RTCA5GPIO 22 (LCD seulement)
VCC du LCD5VVIN (5V)
VCC du RTC5VInutile
Bouton MENUD2-
Bouton plus (+)D3-
Bouton moins (-) / snoozeD4GPIO 27 (bouton unique)
Buzzer passif (+)D8GPIO 25
Toutes les massesGNDGND
La plupart des modules DS3231 bon marché (ZS-042) comportent une résistance et une diode qui tentent de recharger la pile. Ce circuit est prévu pour une pile rechargeable LIR2032 ; avec une CR2032 ordinaire, la pile peut gonfler avec le temps. Si tu utilises une CR2032, dessoude la résistance de 200 Ω ou la diode de la carte, ou prends une pile LIR2032.

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

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)MENUPlus (+)Moins (-)
Écran de l'heureEntrer dans le réglage de l'heureActiver / désactiver l'alarmeAnnuler le snooze
SET TIME : heuresPasser aux minutesHeure +1Heure -1
SET TIME : minutesÉcrire l'heure dans le RTC, passer à l'alarmeMinute +1Minute -1
SET ALARM : heuresPasser aux minutesHeure d'alarme +Heure d'alarme -
SET ALARM : minutesEnregistrer en EEPROM, activer l'alarme, revenir à l'heureMinute +Minute -
WAKE UP! (alarme en cours)ArrêterSnooze 5 minutesSnooze 5 minutes
Dans les modes de réglage, si tu maintiens le bouton plus ou moins enfoncé, la valeur se met à défiler au bout de 0,6 seconde, à environ 7 pas par seconde. Plus besoin d'appuyer 45 fois pour passer les minutes de 0 à 45. Sur l'écran de l'heure, cette répétition est désactivée, sinon un appui prolongé allumerait et éteindrait l'alarme en boucle.

Bibliothèques et première configuration

  1. Dans le gestionnaire de bibliothèques, installe RTClib (d'Adafruit) et laisse-le installer Adafruit BusIO comme dépendance.
  2. Pour le LCD, installe LiquidCrystal I2C (de Frank de Brabander). Les bibliothèques EEPROM et Wire sont fournies avec Arduino.
  3. 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.
  4. Si tu utilises un DS1307, mets USE_DS3231 à 0 dans le code.
  5. 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.
  6. 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.

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}

Comment fonctionne le code ?

PartieRô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 switchGè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.
snoozeAtMé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_DS3231Passe 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 EEPROMContenuExemple
0Heure de l'alarme (0-23)7
1Minute de l'alarme (0-59)30
2Alarme activée ? (1 = oui, 0 = non)1
3Marqueur 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.

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}
RégionChaîne TZ_INFOHeure d'été
Turquie<+03>-3Aucune
Espagne, Allemagne, France, ItalieCET-1CEST,M3.5.0,M10.5.0/3Dernier dimanche de mars et d'octobre
Royaume-UniGMT0BST,M3.5.0/1,M10.5.0Dernier dimanche de mars et d'octobre
Mexique (centre)CST6Aucune depuis 2022
Argentine<-03>3Aucune
Colombie<-05>5Aucune
Est des États-UnisEST5EDT,M3.2.0,M11.1.0Deuxiè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.
L'heure de compilation a quelques secondes de retard sur le moment du téléversement. Si tu veux une heure exacte à la seconde près, règle les minutes en regardant l'horloge de ton téléphone et appuie sur MENU pile au changement de minute ; comme le code écrit les secondes à 0, ton réveil sera calé sur cet instant.

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.

Voir tous les projets
Utilisation du buzzer
AR-13Débutant

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.

4.7(92)
170
Configuration du module horloge RTC DS1302
AR-45Débutant

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.

4.5(23)
31
Horloge RTC DS1302 avec écran LCD
AR-46Intermédiaire
Premium

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.

4.7(41)
51
Horloge numérique avec ESP32 et RTC DS1307 (I2C + LCD)
ES-18Intermédiaire
Premium

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.

4.6(26)
40
ESP32 : heure réelle depuis Internet via NTP
ES-26Avancé
Premium

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.

4.5(13)
22
Horloge numérique avec afficheur 7 segments à 4 chiffres
AR-48Intermédiaire
Premium

Horloge numérique avec afficheur 7 segments à 4 chiffres

Une horloge numérique lumineuse à quatre chiffres, comme celle du four de la cuisine.

4.8(56)
73
Horloge et calendrier matriciel (MAX7219, DS1307)
AR-84Intermédiaire
Premium

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.

5.0(37)
59
Utilisation de l'écran LCD avec I2C
AR-32Débutant
Premium

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…

4.8(53)
70