Guide · 10 min di lettura

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.

Modulo RTC DS1307 con portabatteria CR2032
Modulo RTC DS1307: pin GND, 5V, SDA, SCL e SQW; la batteria CR2032 sul retro tiene l'orologio in funzione quando manca la corrente.

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.

ComponenteCompitoNota
Arduino Uno o NanoIl cervelloSulla Nano gli stessi pin (A4/A5)
Modulo RTC DS3231 o DS1307Tiene l'oraEntrambi I2C, indirizzo 0x68
LCD 16x2 I2CMostra ora, data e svegliaIndirizzo di solito 0x27 o 0x3F
3 pulsantiMENU, più (+) e meno (-)Nessuna resistenza (INPUT_PULLUP)
Buzzer passivoSuona la melodiaUn buzzer attivo fa un solo tono
Batteria a bottone CR2032Alimenta l'RTC durante i blackoutAttenzione al circuito di ricarica del modulo
Breadboard e cavetti jumperCollegamentiMillefori 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.

CaratteristicaDS1307DS3231
PrecisioneDipende dal quarzo, può sgarrare di 1-5 minuti al mese±2 ppm, circa 1 minuto all'anno
Compensazione in temperaturaNoSì (TCXO)
Alimentazione4,5-5,5 V2,3-5,5 V (con l'ESP32 funziona anche a 3,3 V)
Allarme integratoNo2 allarmi e uscita INT/SQW
Sensore di temperaturaNoSì (±3 °C)
Indirizzo I2C0x680x68
Classe RTClibRTC_DS1307RTC_DS3231

Collegamenti della sveglia Arduino

CollegamentoArduino UnoESP32 (versione NTP)
SDA di LCD e RTCA4GPIO 21 (solo LCD)
SCL di LCD e RTCA5GPIO 22 (solo LCD)
VCC dell'LCD5VVIN (5V)
VCC dell'RTC5VNon serve
Pulsante MENUD2-
Pulsante più (+)D3-
Pulsante meno (-) / snoozeD4GPIO 27 (pulsante unico)
Buzzer passivo (+)D8GPIO 25
Tutti i GNDGNDGND
Molti moduli DS3231 economici (ZS-042) hanno una resistenza e un diodo che cercano di ricaricare la batteria. Quel circuito è pensato per una batteria ricaricabile LIR2032; con una normale CR2032 la cella col tempo può gonfiarsi. Se usi una CR2032, dissalda dalla scheda la resistenza da 200 Ω o il diodo, oppure usa una LIR2032.

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

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)MENUPiù (+)Meno (-)
Schermata dell'oraEntra nell'impostazione dell'oraAttiva / disattiva la svegliaAnnulla lo snooze
SET TIME: orePassa ai minutiOra +1Ora -1
SET TIME: minutiScrive l'ora nell'RTC e passa alla svegliaMinuto +1Minuto -1
SET ALARM: orePassa ai minutiOra della sveglia +Ora della sveglia -
SET ALARM: minutiSalva in EEPROM, attiva la sveglia e torna all'oraMinuto +Minuto -
WAKE UP! (sveglia che suona)SpegniSnooze 5 minutiSnooze 5 minuti
Nelle modalità di impostazione, se tieni premuto il pulsante più o meno, dopo 0,6 secondi il valore avanza veloce, circa 7 passi al secondo. Così non devi premere 45 volte per portare i minuti da 0 a 45. Nella schermata dell'ora la ripetizione è disattivata, altrimenti tenendo premuto la sveglia si accenderebbe e spegnerebbe di continuo.

Librerie e prima configurazione

  1. Dal Gestore librerie installa RTClib (di Adafruit) e lascia che installi anche Adafruit BusIO come dipendenza.
  2. Per l'LCD installa LiquidCrystal I2C (di Frank de Brabander). Le librerie EEPROM e Wire sono già incluse in Arduino.
  3. 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.
  4. Se usi un DS1307, imposta USE_DS3231 a 0 nel codice.
  5. 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.
  6. 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.

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}

Come funziona il codice?

ParteCosa 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 switchGestiscono 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.
snoozeAtMemorizza 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_DS3231Passa 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 EEPROMContenutoEsempio
0Ora della sveglia (0-23)7
1Minuti della sveglia (0-59)30
2Sveglia attiva? (1 = sì, 0 = no)1
3Marcatore 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.

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}
AreaStringa TZ_INFOOra legale
Turchia<+03>-3Nessuna
Spagna, Germania, Francia, ItaliaCET-1CEST,M3.5.0,M10.5.0/3Ultima domenica di marzo e di ottobre
Regno UnitoGMT0BST,M3.5.0/1,M10.5.0Ultima domenica di marzo e di ottobre
Messico (centro)CST6Nessuna dal 2022
Argentina<-03>3Nessuna
Colombia<-05>5Nessuna
Stati Uniti orientaliEST5EDT,M3.2.0,M11.1.0Seconda 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.
L'ora di compilazione è indietro di qualche secondo rispetto al caricamento. Se vuoi l'ora esatta al secondo, imposta i minuti guardando l'orologio del telefono e premi MENU proprio quando scatta il minuto; dato che il codice scrive i secondi a 0, la sveglia sarà allineata a quell'istante.

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.

Vedi tutti i progetti
Uso del cicalino
AR-13Principiante

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.

4.7(92)
170
Configurazione del modulo orologio RTC DS1302
AR-45Principiante

Configurazione del modulo orologio RTC DS1302

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

4.5(23)
31
DS1302 Orologio RTC con display LCD
AR-46Intermedio
Premium

DS1302 Orologio RTC con display LCD

Un piccolo orologio da scrivania che non dimentica l'ora nemmeno se manca la corrente.

4.7(41)
51
Orologio digitale con ESP32 e RTC DS1307 (I2C + LCD)
ES-18Intermedio
Premium

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.

4.6(26)
40
ESP32: ora reale da Internet tramite NTP
ES-26Avanzato
Premium

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.

4.5(13)
22
Orologio digitale con display a 7 segmenti a 4 cifre
AR-48Intermedio
Premium

Orologio digitale con display a 7 segmenti a 4 cifre

Un orologio digitale luminoso a quattro cifre, simile a quello del forno in cucina.

4.8(56)
73
Orologio e calendario a matrice di punti (MAX7219, DS1307)
AR-84Intermedio
Premium

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.

5.0(37)
59
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70