Sveglia Arduino: RTC DS3231, LCD, buzzer e funzione snooze
Sveglia Arduino passo passo: RTC DS3231 o DS1307, LCD I2C, 3 pulsanti per ora e sveglia, melodia col buzzer, snooze, EEPROM e versione ESP32 con NTP.
Costruire una sveglia Arduino mette insieme in un unico progetto modulo RTC, display LCD, pulsanti e buzzer: impari tantissimo e alla fine hai un oggetto che userai davvero ogni mattina. In questa guida realizzeremo, con un modulo RTC DS3231 (o DS1307), un LCD 16x2 I2C, tre pulsanti e un buzzer passivo, una sveglia in cui ora e allarme si impostano con i pulsanti, che suona una melodia, ha la funzione snooze (posticipa) di 5 minuti e non perde l'ora nemmeno quando salta la corrente.
Troverai il collegamento passo passo, una tabella con il flusso del menu dei pulsanti, come suonare una melodia senza delay, come salvare l'ora della sveglia in EEPROM e il codice completo già compilato. Nell'ultima parte faremo funzionare la stessa sveglia senza modulo RTC, con un ESP32 che prende l'ora da Internet (NTP) e passa da solo all'ora legale.

Come funziona una sveglia con Arduino?
L'orologio interno di Arduino (millis) conta solo finché la scheda è alimentata e riparte da zero a ogni reset; in più, le schede con risonatore ceramico come la Uno possono sbagliare di diversi minuti al giorno. Per questo l'ora è affidata a un modulo RTC (orologio in tempo reale): questa schedina, con il suo quarzo e la sua batteria a bottone, continua a contare anche quando Arduino è spento. A ogni giro del loop Arduino legge l'ora dall'RTC, la scrive sull'LCD, controlla i pulsanti e, quando l'ora coincide con quella della sveglia, fa partire il buzzer. Tutto il comportamento è gestito da una piccola macchina a stati: visualizzazione dell'ora, impostazione dell'ora, impostazione della sveglia e sveglia che suona.
| Componente | Compito | Nota |
|---|---|---|
| Arduino Uno o Nano | Il cervello | Sulla Nano gli stessi pin (A4/A5) |
| Modulo RTC DS3231 o DS1307 | Tiene l'ora | Entrambi I2C, indirizzo 0x68 |
| LCD 16x2 I2C | Mostra ora, data e sveglia | Indirizzo di solito 0x27 o 0x3F |
| 3 pulsanti | MENU, più (+) e meno (-) | Nessuna resistenza (INPUT_PULLUP) |
| Buzzer passivo | Suona la melodia | Un buzzer attivo fa un solo tono |
| Batteria a bottone CR2032 | Alimenta l'RTC durante i blackout | Attenzione al circuito di ricarica del modulo |
| Breadboard e cavetti jumper | Collegamenti | Millefori per una sveglia definitiva |
DS1307 o DS3231?
I due moduli usano lo stesso indirizzo I2C e funzionano quasi con lo stesso codice grazie alla libreria RTClib, ma la loro precisione è molto diversa. Il DS1307 dipende da un quarzo esterno da 32,768 kHz e deriva quando cambia la temperatura della stanza; sui moduli economici qualche minuto di scarto al mese è normale. Il DS3231 invece ha il quarzo dentro il chip e lo compensa in temperatura, così sgarra di circa un minuto all'anno. Per un orologio che deve svegliarti ogni mattina il DS3231 è di gran lunga la scelta migliore; se hai già un DS1307, il codice funziona anche con quello.
| Caratteristica | DS1307 | DS3231 |
|---|---|---|
| Precisione | Dipende dal quarzo, può sgarrare di 1-5 minuti al mese | ±2 ppm, circa 1 minuto all'anno |
| Compensazione in temperatura | No | Sì (TCXO) |
| Alimentazione | 4,5-5,5 V | 2,3-5,5 V (con l'ESP32 funziona anche a 3,3 V) |
| Allarme integrato | No | 2 allarmi e uscita INT/SQW |
| Sensore di temperatura | No | Sì (±3 °C) |
| Indirizzo I2C | 0x68 | 0x68 |
| Classe RTClib | RTC_DS1307 | RTC_DS3231 |
Collegamenti della sveglia Arduino
| Collegamento | Arduino Uno | ESP32 (versione NTP) |
|---|---|---|
| SDA di LCD e RTC | A4 | GPIO 21 (solo LCD) |
| SCL di LCD e RTC | A5 | GPIO 22 (solo LCD) |
| VCC dell'LCD | 5V | VIN (5V) |
| VCC dell'RTC | 5V | Non serve |
| Pulsante MENU | D2 | - |
| Pulsante più (+) | D3 | - |
| Pulsante meno (-) / snooze | D4 | GPIO 27 (pulsante unico) |
| Buzzer passivo (+) | D8 | GPIO 25 |
| Tutti i GND | GND | GND |
LCD e RTC condividono lo stesso bus I2C: gli SDA dei due moduli vanno su A4 e gli SCL su A5; avendo indirizzi diversi non si danno fastidio. Per i pulsanti basta collegare una zampa al pin e quella opposta a GND; poiché nel codice usiamo INPUT_PULLUP, non servono resistenze esterne e premendo il pin legge LOW (dettagli in come collegare un pulsante). Il positivo del buzzer va su D8, il negativo su GND. Dato che la melodia usa la funzione tone(), serve un buzzer passivo; la differenza la spieghiamo in Cos'è un buzzer?.
Menu con i pulsanti: impostare ora e sveglia con tre pulsanti
Per fare tutte le impostazioni con soli tre pulsanti, ogni pulsante ha un compito diverso a seconda della modalità. Il pulsante MENU passa al passo successivo, i pulsanti più e meno cambiano il valore selezionato. Questa struttura si chiama macchina a stati e permette di scrivere ogni modalità nel suo case invece di annidare tanti if. La tabella mostra il menu completo; tienila accanto mentre leggi il codice e capirai subito cosa fa ogni riga.
| Modalità (sul display) | MENU | Più (+) | Meno (-) |
|---|---|---|---|
| Schermata dell'ora | Entra nell'impostazione dell'ora | Attiva / disattiva la sveglia | Annulla lo snooze |
| SET TIME: ore | Passa ai minuti | Ora +1 | Ora -1 |
| SET TIME: minuti | Scrive l'ora nell'RTC e passa alla sveglia | Minuto +1 | Minuto -1 |
| SET ALARM: ore | Passa ai minuti | Ora della sveglia + | Ora della sveglia - |
| SET ALARM: minuti | Salva in EEPROM, attiva la sveglia e torna all'ora | Minuto + | Minuto - |
| WAKE UP! (sveglia che suona) | Spegni | Snooze 5 minuti | Snooze 5 minuti |
Librerie e prima configurazione
- Dal Gestore librerie installa RTClib (di Adafruit) e lascia che installi anche Adafruit BusIO come dipendenza.
- Per l'LCD installa LiquidCrystal I2C (di Frank de Brabander). Le librerie EEPROM e Wire sono già incluse in Arduino.
- Se non sei sicuro dell'indirizzo dell'LCD, esegui lo sketch scanner della guida al display LCD I2C e metti l'indirizzo trovato al posto di 0x27 nel codice.
- Se usi un DS1307, imposta USE_DS3231 a 0 nel codice.
- Carica il codice. Se l'RTC parte per la prima volta o ha la batteria scarica, l'ora viene impostata al momento della compilazione e sul display compare un breve avviso sulla batteria.
- Con MENU entra nell'impostazione dell'ora, imposta l'ora esatta e poi la sveglia.
Codice della sveglia Arduino
Ecco il codice completo. Nel loop non c'è nessun delay lungo: pulsanti, melodia e display sono temporizzati con millis(), quindi i pulsanti rispondono subito anche mentre la sveglia suona. Il display viene riscritto solo quando cambia il secondo o si preme un pulsante, così l'LCD non sfarfalla.
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}Come funziona il codice?
| Parte | Cosa fa? |
|---|---|
| pressed() | Legge il pulsante con un filtro antirimbalzo di 30 ms; restituisce true a ogni nuova pressione e, nelle modalità di impostazione, ripete finché lo tieni premuto. |
| enum Mode e switch | Gestiscono separatamente le modalità ora, impostazione ora, impostazione sveglia e sveglia che suona. |
| key (giorno × 1440 + minuto) | Impedisce che la sveglia suoni due volte nello stesso minuto. |
| snoozeAt | Memorizza come unixtime il momento in cui finisce lo snooze; funziona anche a cavallo della mezzanotte. |
| playMelody() | Suona le note una dopo l'altra con millis(), senza delay. |
| draw() e printLine() | Scrivono sul display solo quando serve e puliscono la fine della riga con spazi. |
| loadAlarm() e saveAlarm() | Leggono e salvano in EEPROM l'ora della sveglia e lo stato attivo/disattivo. |
| USE_DS3231 | Passa dal DS3231 al DS1307 cambiando una sola riga. |
Per far scattare la sveglia guardiamo i minuti, non i secondi. Cercare di cogliere il secondo 0 è rischioso: se in quel secondo il loop è impegnato ad aggiornare il display, la sveglia potrebbe non suonare mai. Invece la sveglia parte quando ora e minuto coincidono, e memorizziamo l'identità di quel minuto in lastAlarmKey. Così, se la spegni nello stesso minuto, non ricomincia. La durata dello snooze si calcola con l'unixtime fornito dall'RTC (secondi dal 1970): se posticipi di 5 minuti alle 23:58, la sveglia suona senza problemi alle 00:03. La logica della temporizzazione con millis() la trovi in millis o delay.
Melodia col buzzer e funzione snooze
La melodia sta in un piccolo array di coppie frequenza e durata: le note a 1047 Hz (do), 1319 Hz (mi), 1568 Hz (sol) e 2093 Hz (il do un'ottava sopra) suonano con brevi pause, poi arrivano 600 ms di silenzio e il ciclo ricomincia. Per un risveglio più deciso puoi accorciare il silenzio o aggiungere note tue; una frequenza 0 indica una pausa. Se nessuno spegne la sveglia, si ferma da sola dopo 60 secondi e non disturba i vicini quando non sei a casa. Premendo più o meno la sveglia viene posticipata di 5 minuti e il display mostra il tempo rimanente; il pulsante MENU la spegne per quel giorno, e il giorno dopo suona di nuovo alla stessa ora.
Salvare la sveglia in EEPROM
L'RTC conserva l'ora, ma l'ora della sveglia sta nella RAM di Arduino e si cancella quando manca la corrente. Per evitarlo la scriviamo nella EEPROM da 1 KB di Arduino Uno. Dato che ogni cella regge circa 100.000 scritture, usiamo EEPROM.update(), che non scrive se il valore è già lo stesso. Il marcatore 0xA5 nel quarto byte indica che la EEPROM è già stata scritta da questo programma; così al primissimo avvio non vengono letti valori casuali e la sveglia non finisce su un orario assurdo come 37:99. Maggiori dettagli nella guida alla EEPROM di Arduino.
| Indirizzo EEPROM | Contenuto | Esempio |
|---|---|---|
| 0 | Ora della sveglia (0-23) | 7 |
| 1 | Minuti della sveglia (0-59) | 30 |
| 2 | Sveglia attiva? (1 = sì, 0 = no) | 1 |
| 3 | Marcatore di validità | 0xA5 |
Perché l'ora non si perde quando manca la corrente?
Quando salta la corrente, il chip RTC passa da solo alla batteria CR2032 e si limita a continuare a contare. In questa modalità il DS3231 assorbe pochi microampere e il DS1307 ancora meno; sulla carta una batteria a bottone da 220 mAh dura più di dieci anni, in pratica la durata la decide l'invecchiamento della batteria stessa. Quando torna la corrente, Arduino riparte, legge l'ora dall'RTC e la sveglia dalla EEPROM e prosegue come se nulla fosse. L'unico limite è che durante il blackout la sveglia non può suonare, perché buzzer e Arduino non sono a batteria. In una casa con blackout frequenti, alimentare Arduino con una cella 18650, un modulo di ricarica e un convertitore step-up risolve anche questo. Se l'ora torna a quella di compilazione a ogni reset, la batteria dell'RTC è scarica o non è inserita bene.
Versione ESP32 con NTP: l'ora da Internet senza modulo RTC
Visto che l'ESP32 si collega al Wi-Fi, può prendere l'ora dai server di tempo di Internet (NTP) invece che da un modulo RTC. La stringa del fuso orario che passi a configTzTime() contiene anche le regole dell'ora legale, quindi il cambio di fine marzo e fine ottobre avviene in automatico. Sull'ESP32 al posto della EEPROM si usa la libreria Preferences, che salva l'ora della sveglia nella flash come coppie chiave-valore. In questa versione basta un solo pulsante: mentre la sveglia suona, una pressione breve posticipa di 5 minuti e una pressione di oltre 1,5 secondi la spegne. Per impostare la sveglia scrivi un orario come 07:30 nel Monitor seriale, e off per disattivarla. I dettagli su NTP sono in orologio NTP con 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}| Area | Stringa TZ_INFO | Ora legale |
|---|---|---|
| Turchia | <+03>-3 | Nessuna |
| Spagna, Germania, Francia, Italia | CET-1CEST,M3.5.0,M10.5.0/3 | Ultima domenica di marzo e di ottobre |
| Regno Unito | GMT0BST,M3.5.0/1,M10.5.0 | Ultima domenica di marzo e di ottobre |
| Messico (centro) | CST6 | Nessuna dal 2022 |
| Argentina | <-03>3 | Nessuna |
| Colombia | <-05>5 | Nessuna |
| Stati Uniti orientali | EST5EDT,M3.2.0,M11.1.0 | Seconda domenica di marzo, prima di novembre |
Il punto debole della versione NTP è che, dopo un blackout, non conosce l'ora finché non torna il Wi-Fi; se il modem si riavvia più lentamente dell'ESP32, il display può restare vuoto per qualche minuto. La soluzione più robusta è combinarle: collega un DS3231 all'ESP32, prendi l'ora via NTP una volta al giorno e scrivila nell'RTC, e quando Internet manca leggila dall'RTC. Così l'ora legale si regola da sola e non perdi l'ora durante i blackout.
Idee per migliorare la tua sveglia
- Sveglia solo nei giorni feriali: con dayOfTheWeek() di DateTime falla suonare solo dal lunedì al venerdì; salva i giorni come maschera a 7 bit in EEPROM.
- Sveglia all'alba: 15 minuti prima della sveglia, accendi lentamente un anello di LED WS2812B dal rosso al bianco.
- Risveglio con MP3: al posto del buzzer usa un DFPlayer Mini per suonare la tua canzone preferita da una scheda SD.
- Termometro: mostra sulla seconda riga del display il valore rtc.getTemperature() del DS3231.
- Luminosità automatica: con una fotoresistenza (LDR) spegni la retroilluminazione dell'LCD di notte e riaccendila al mattino.
- Cifre grandi: per leggere l'ora dal letto, usa un TM1637 o un display a 7 segmenti al posto dell'LCD.
Errori comuni e come risolverli
- Errore "'class LiquidCrystal_I2C' has no member named 'init'": hai installate due librerie LiquidCrystal_I2C diverse e il compilatore sceglie quella sbagliata. Tieni quella di Frank de Brabander e rimuovi l'altra dalla cartella libraries.
- L'LCD si accende ma non mostra testo: regola il contrasto con il trimmer blu sul retro del modulo; se non cambia nulla, l'indirizzo è 0x3F e non 0x27.
- Compare "RTC not found": SDA e SCL sono invertiti o il VCC dell'RTC non è collegato. Nello scanner I2C deve comparire l'indirizzo 0x68.
- L'ora torna a quella di compilazione a ogni accensione: la batteria dell'RTC è scarica, inserita al contrario o manca. Sostituiscila e reimposta l'ora dal menu.
- Il buzzer fa solo un clic o un unico tono: stai usando un buzzer attivo. Per suonare melodie con tone() serve un buzzer passivo.
- I pulsanti si premono da soli: manca INPUT_PULLUP nel pinMode o il pulsante è collegato a 5V invece che a GND; un pin flottante legge valori casuali.
- L'orologio sgarra di qualche minuto: con il DS1307 è normale; passa al DS3231 oppure sincronizza l'ora via NTP ogni giorno con la versione ESP32.
Questa sveglia riunisce in un unico oggetto utile gli argomenti base di Arduino: RTC, I2C, EEPROM, lettura dei pulsanti e buzzer. Se vuoi provare passo passo progetti di orologi simili, nell'app BlueGrays trovi l'orologio LCD con RTC DS1302, l'orologio digitale ESP32 con DS1307, l'orologio Internet ESP32 con NTP, l'orologio digitale con display a 7 segmenti da 4 cifre e le melodie con buzzer, ognuno con schema dei collegamenti e codice pronto.
Domande frequenti
Come si costruisce una sveglia con Arduino?
Un modulo RTC (DS3231 o DS1307) tiene l'ora, un LCD I2C la mostra, con i pulsanti si impostano ora e sveglia e all'ora stabilita un buzzer passivo suona una melodia. Se salvi l'ora della sveglia in EEPROM, sopravvive anche ai blackout.
Arduino può tenere l'ora senza modulo RTC?
Con millis() può tenerla in modo approssimativo, ma l'ora riparte da zero a ogni reset o blackout e può sgarrare di minuti al giorno. Per un vero orologio serve un modulo RTC oppure, se hai il Wi-Fi, un ESP32 con NTP.
Meglio il DS1307 o il DS3231?
Il DS3231 è molto più preciso: grazie al quarzo interno compensato in temperatura sgarra di circa un minuto all'anno. Il DS1307 può sbagliare di qualche minuto al mese e richiede 5 V; per una sveglia scegli il DS3231.
L'orologio di Arduino si azzera quando manca la corrente?
No, se il modulo RTC ha la batteria: l'RTC continua a contare con la batteria e Arduino, alla riaccensione, legge l'ora giusta. Dato che l'ora della sveglia è in EEPROM, anche le impostazioni restano; solo durante il blackout la sveglia non può suonare.
Che buzzer serve per una sveglia Arduino?
Per suonare una melodia serve un buzzer passivo, che con la funzione tone() produce frequenze diverse. Un buzzer attivo dà solo un tono fisso; se ti basta un semplice bip, puoi comandarlo con digitalWrite.
Come aggiungere lo snooze a una sveglia Arduino?
Quando si preme un pulsante mentre la sveglia suona, aggiungi 300 secondi all'unixtime di quel momento e lo salvi in una variabile. Il loop principale fa ripartire la sveglia quando l'ora raggiunge quel valore; usare l'unixtime la rende corretta anche se lo snooze passa la mezzanotte.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Uso del cicalino
Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

Configurazione del modulo orologio RTC DS1302
Metti in funzione un piccolo modulo orologio che non dimentica l'ora nemmeno quando l'Arduino è spento.

DS1302 Orologio RTC con display LCD
Un piccolo orologio da scrivania che non dimentica l'ora nemmeno se manca la corrente.

Orologio digitale con ESP32 e RTC DS1307 (I2C + LCD)
In questo progetto, utilizziamo il modulo orologio in tempo reale (RTC) DS1307 per visualizzare l'ora e la data su un display LCD 16x2 I2C. Il DS1307 è un RTC con batteria di supporto che mantiene l'ora anche se l'ESP32 si spegne. Entrambi i moduli condividono la stessa linea I2C (SDA/SCL), permettendoci di imparare a controllare più dispositivi utilizzando solo due cavi di segnale. Cosi imparerai il protocollo I2C e il funzionamento dei moduli RTC nella pratica.

ESP32: ora reale da Internet tramite NTP
L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

Orologio digitale con display a 7 segmenti a 4 cifre
Un orologio digitale luminoso a quattro cifre, simile a quello del forno in cucina.

Orologio e calendario a matrice di punti (MAX7219, DS1307)
Un pannello luminoso per la scrivania o la parete che mostra ora e data con scritte scorrevoli.

Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

