Despertador con Arduino: RTC DS3231, LCD, alarma y posponer
Haz un despertador con Arduino: RTC DS3231 o DS1307, LCD I2C, 3 botones para la hora y la alarma, melodía con buzzer, posponer, EEPROM y versión ESP32 con NTP.
Hacer un despertador con Arduino es un proyecto que junta en una sola placa el módulo RTC, la pantalla LCD, los pulsadores y el buzzer: aprendes muchísimo y además lo puedes usar de verdad cada mañana. En esta guía vamos a armar, con un módulo RTC DS3231 (o DS1307), una LCD 16x2 I2C, tres pulsadores y un buzzer pasivo, un reloj despertador al que se le ajustan la hora y la alarma con botones, que suena con una melodía, tiene función de posponer 5 minutos (snooze) y no pierde la hora aunque se corte la luz.
Vas a encontrar paso a paso el cableado en la protoboard, una tabla con el flujo del menú de botones, cómo tocar una melodía sin usar delay, cómo guardar la hora de la alarma en la EEPROM y el código completo ya compilado. En la última parte haremos el mismo reloj sin módulo RTC, con un ESP32 que toma la hora de internet (NTP) y cambia solo al horario de verano.

¿Cómo funciona un despertador con Arduino?
El reloj interno de Arduino (millis) solo cuenta mientras la placa está encendida y vuelve a cero con cada reinicio; además, en placas con resonador cerámico como el Uno puede atrasarse o adelantarse varios minutos por día. Por eso la hora la lleva un módulo RTC (reloj de tiempo real): esta plaquita con su propio cristal y su pila de botón sigue contando aunque Arduino esté apagado. En cada vuelta del loop, Arduino lee la hora del RTC, la muestra en la LCD, revisa los pulsadores y, cuando la hora coincide con la de la alarma, hace sonar el buzzer. Todo el comportamiento lo controla una pequeña máquina de estados: mostrar la hora, ajustar la hora, ajustar la alarma y alarma sonando.
| Componente | Función | Nota |
|---|---|---|
| Arduino Uno o Nano | El cerebro | En el Nano los pines son los mismos (A4/A5) |
| Módulo RTC DS3231 o DS1307 | Lleva la hora | Ambos son I2C, dirección 0x68 |
| LCD 16x2 con módulo I2C | Muestra hora, fecha y alarma | Dirección normalmente 0x27 o 0x3F |
| 3 pulsadores | MENU, más (+) y menos (-) | Sin resistencias (INPUT_PULLUP) |
| Buzzer pasivo | Toca la melodía | Un buzzer activo solo da un tono |
| Pila de botón CR2032 | Alimenta el RTC cuando se va la luz | Cuidado con el circuito de carga del módulo |
| Protoboard y cables jumper | Conexiones | Para un reloj definitivo, placa perforada |
¿DS1307 o DS3231?
Los dos módulos usan la misma dirección I2C y funcionan casi con el mismo código gracias a la librería RTClib, pero su precisión es muy distinta. El DS1307 depende de un cristal externo de 32,768 kHz y se desvía cuando cambia la temperatura del cuarto; en los módulos baratos es normal que se corra unos minutos al mes. El DS3231, en cambio, lleva el cristal dentro del chip y lo compensa por temperatura, así que se desvía alrededor de un minuto al año. Para un reloj que te va a despertar todos los días, el DS3231 es por lejos la mejor opción; si ya tienes un DS1307, el código también funciona con él.
| Característica | DS1307 | DS3231 |
|---|---|---|
| Precisión | Depende del cristal, puede correrse 1-5 minutos al mes | ±2 ppm, alrededor de 1 minuto al año |
| Compensación de temperatura | No | Sí (TCXO) |
| Alimentación | 4,5-5,5 V | 2,3-5,5 V (con ESP32 funciona también a 3,3 V) |
| Alarma interna | No | 2 alarmas y salida INT/SQW |
| Sensor de temperatura | No | Sí (±3 °C) |
| Dirección I2C | 0x68 | 0x68 |
| Clase en RTClib | RTC_DS1307 | RTC_DS3231 |
Conexión del despertador con Arduino
| Conexión | Arduino Uno | ESP32 (versión NTP) |
|---|---|---|
| SDA de la LCD y el RTC | A4 | GPIO 21 (solo LCD) |
| SCL de la LCD y el RTC | A5 | GPIO 22 (solo LCD) |
| VCC de la LCD | 5V | VIN (5V) |
| VCC del RTC | 5V | No hace falta |
| Pulsador MENU | D2 | - |
| Pulsador más (+) | D3 | - |
| Pulsador menos (-) / posponer | D4 | GPIO 27 (un solo pulsador) |
| Buzzer pasivo (+) | D8 | GPIO 25 |
| Todos los GND | GND | GND |
La LCD y el RTC comparten el mismo bus I2C: los SDA de ambos módulos van a A4 y los SCL a A5; como tienen direcciones distintas, no chocan. En los pulsadores basta con conectar una pata al pin y la pata opuesta a GND; como en el código usamos INPUT_PULLUP, no hacen falta resistencias externas y al presionar el pin lee LOW (más detalles en cómo conectar un pulsador). El positivo del buzzer va a D8 y el negativo a GND. Como la melodía usa la función tone(), necesitas un buzzer pasivo; la diferencia la explicamos en ¿Qué es un buzzer?.
Menú con botones: ajustar la hora y la alarma con tres pulsadores
Para hacer todos los ajustes con solo tres pulsadores, cada botón cumple una función distinta según el modo. El botón MENU pasa al siguiente paso y los botones más y menos cambian el valor que está seleccionado. Esta estructura se llama máquina de estados y permite escribir cada modo en su propio case en lugar de anidar un montón de if. La tabla muestra el menú completo; si la tienes a mano mientras lees el código, vas a entender enseguida qué hace cada línea.
| Modo (en pantalla) | MENU | Más (+) | Menos (-) |
|---|---|---|---|
| Pantalla de la hora | Entrar a ajustar la hora | Activar / desactivar la alarma | Cancelar el posponer |
| SET TIME: hora | Pasar a los minutos | Subir la hora 1 | Bajar la hora 1 |
| SET TIME: minutos | Guardar la hora en el RTC y pasar a la alarma | Subir los minutos 1 | Bajar los minutos 1 |
| SET ALARM: hora | Pasar a los minutos | Subir la hora de la alarma | Bajar la hora de la alarma |
| SET ALARM: minutos | Guardar en la EEPROM, activar la alarma y volver a la hora | Subir los minutos | Bajar los minutos |
| WAKE UP! (alarma sonando) | Apagar | Posponer 5 minutos | Posponer 5 minutos |
Librerías y primera configuración
- Desde el Gestor de Librerías instala RTClib (de Adafruit) y deja que instale también Adafruit BusIO como dependencia.
- Para la LCD instala LiquidCrystal I2C (de Frank de Brabander). Las librerías EEPROM y Wire ya vienen con Arduino.
- Si no estás seguro de la dirección de la LCD, corre el escáner I2C de la guía de la LCD I2C y pon la dirección que aparezca en lugar del 0x27 del código.
- Si usas un DS1307, cambia el valor de USE_DS3231 a 0 en el código.
- Sube el código. Si el RTC arranca por primera vez o se le terminó la pila, la hora se ajusta al momento en que se compiló el código y en la pantalla aparece un breve aviso de la pila.
- Entra con MENU al ajuste de la hora, pon la hora exacta y después configura la alarma.
Código del despertador con Arduino
Aquí tienes el código completo. En ninguna parte del loop hay un delay largo: los pulsadores, la melodía y la pantalla se temporizan con millis(), así que los botones responden al instante incluso mientras suena la alarma. La pantalla solo se vuelve a escribir cuando cambia el segundo o se presiona un botón, lo que evita que la LCD parpadee.
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}¿Cómo funciona el código?
| Parte | ¿Qué hace? |
|---|---|
| pressed() | Lee el pulsador con un filtro antirrebote de 30 ms; devuelve true al presionar y, en los modos de ajuste, repite mientras lo mantienes. |
| enum Mode y switch | Manejan por separado los modos hora, ajuste de hora, ajuste de alarma y alarma sonando. |
| key (día × 1440 + minuto) | Evita que la alarma suene dos veces dentro del mismo minuto. |
| snoozeAt | Guarda como unixtime el momento en que termina el posponer; funciona bien aunque pase la medianoche. |
| playMelody() | Toca las notas una tras otra con millis(), sin usar delay. |
| draw() y printLine() | Escriben en la pantalla solo cuando hace falta y limpian el final de la línea con espacios. |
| loadAlarm() y saveAlarm() | Leen y guardan en la EEPROM la hora de la alarma y si está activada. |
| USE_DS3231 | Permite pasar del DS3231 al DS1307 cambiando una sola línea. |
Para disparar la alarma no miramos los segundos sino los minutos. Intentar atrapar el segundo 0 es arriesgado: si en ese segundo el loop está ocupado escribiendo en la pantalla, la alarma podría no sonar nunca. En cambio, la alarma arranca cuando coinciden la hora y el minuto, y guardamos la identidad de ese minuto en lastAlarmKey. Así, si la apagas dentro del mismo minuto, no vuelve a empezar. El tiempo de posponer se calcula con el unixtime que da el RTC (segundos desde 1970): si pospones 5 minutos a las 23:58, la alarma suena sin problema a las 00:03. La lógica de temporizar con millis() la encuentras en millis vs delay.
Melodía con buzzer y función posponer (snooze)
La melodía vive en un pequeño arreglo de pares frecuencia y duración: las notas de 1047 Hz (Do), 1319 Hz (Mi), 1568 Hz (Sol) y 2093 Hz (el Do una octava más arriba) suenan con pausas cortas, luego vienen 600 ms de silencio y el ciclo vuelve a empezar. Para un despertar más enérgico puedes acortar el silencio o agregar tus propias notas; una frecuencia 0 significa silencio. Si nadie apaga la alarma, se detiene sola a los 60 segundos y no molesta a los vecinos cuando no estás en casa. Al presionar más o menos la alarma se pospone 5 minutos y la pantalla muestra el tiempo restante; el botón MENU la apaga por ese día y al día siguiente vuelve a sonar a la misma hora.
Guardar la alarma en la EEPROM
El RTC conserva la hora, pero la hora de la alarma está en la RAM de Arduino y se borra cuando se va la luz. Para evitarlo, la guardamos en la EEPROM de 1 KB del Arduino Uno. Como cada celda aguanta unas 100 000 escrituras, usamos EEPROM.update(), que no escribe si el valor ya es el mismo. La marca 0xA5 del cuarto byte indica que la EEPROM ya fue escrita por este programa; así, en el primer arranque no se leen valores al azar ni la alarma queda en una hora absurda como 37:99. Más detalles en la guía de la EEPROM de Arduino.
| Dirección EEPROM | Contenido | Ejemplo |
|---|---|---|
| 0 | Hora de la alarma (0-23) | 7 |
| 1 | Minutos de la alarma (0-59) | 30 |
| 2 | ¿Alarma activada? (1 = sí, 0 = no) | 1 |
| 3 | Marca de validez | 0xA5 |
¿Por qué no se pierde la hora cuando se corta la luz?
Cuando se corta la luz, el chip RTC pasa solo a la pila CR2032 y se dedica únicamente a seguir contando. En ese modo el DS3231 consume unos pocos microamperios y el DS1307 todavía menos; en teoría una pila de botón de 220 mAh dura más de diez años, y en la práctica su vida la marca el propio envejecimiento de la pila. Cuando vuelve la luz, Arduino arranca de cero, lee la hora del RTC y la alarma de la EEPROM, y sigue como si nada. Lo único que falta es que la alarma no puede sonar durante el corte, porque el buzzer y Arduino no tienen batería. En casas donde los cortes son frecuentes, alimentar Arduino con una pila 18650, un módulo de carga y un elevador de voltaje también resuelve eso. Si la hora vuelve a la de compilación cada vez que reinicias, la pila del RTC está agotada o mal colocada.
Versión ESP32 con NTP: la hora desde internet sin módulo RTC
Como el ESP32 se conecta a Wi-Fi, puede tomar la hora de los servidores de tiempo de internet (NTP) en vez de un módulo RTC. La cadena de zona horaria que le pasas a configTzTime() incluye también los cambios de horario de verano, así que en España el cambio de marzo y octubre se hace solo, y en México, Argentina o Colombia simplemente se usa la hora fija. En el ESP32 se usa la librería Preferences en lugar de la EEPROM; guarda la hora de la alarma en la flash como pares clave-valor. En esta versión basta un solo pulsador: con la alarma sonando, una pulsación corta pospone 5 minutos y una de más de 1,5 segundos la apaga. Para programar la alarma escribe una hora como 07:30 en el Monitor Serie, y off para desactivarla. Los detalles de NTP están en reloj 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}| Región | Cadena TZ_INFO | Horario de verano |
|---|---|---|
| Turquía | <+03>-3 | No |
| España, Alemania, Francia, Italia | CET-1CEST,M3.5.0,M10.5.0/3 | Último domingo de marzo y de octubre |
| Reino Unido | GMT0BST,M3.5.0/1,M10.5.0 | Último domingo de marzo y de octubre |
| México (centro) | CST6 | No, desde 2022 |
| Argentina | <-03>3 | No |
| Colombia | <-05>5 | No |
| Este de EE. UU. | EST5EDT,M3.2.0,M11.1.0 | Segundo domingo de marzo, primero de noviembre |
El punto débil de la versión NTP es que, después de un corte de luz, no sabe la hora hasta que vuelve el Wi-Fi; si el módem tarda más en arrancar que el ESP32, la pantalla puede quedar vacía unos minutos. La solución más robusta es combinar ambos: conecta un DS3231 al ESP32, toma la hora de NTP una vez al día y escríbela en el RTC, y cuando no haya internet léela del RTC. Así el horario de verano se ajusta solo y tampoco pierdes la hora en un corte.
Ideas para mejorar tu despertador
- Alarma solo entre semana: con la función dayOfTheWeek() de DateTime haz que suene solo de lunes a viernes; guarda los días como una máscara de 7 bits en la EEPROM.
- Alarma amanecer: 15 minutos antes de la alarma, enciende poco a poco un anillo de LED WS2812B de rojo a blanco.
- Despertar con MP3: en lugar del buzzer, usa un DFPlayer Mini para tocar tu canción favorita desde una tarjeta SD.
- Termómetro: muestra en la segunda línea de la pantalla el valor de rtc.getTemperature() del DS3231.
- Brillo automático: con una LDR, apaga la luz de fondo de la LCD de noche y enciéndela de día.
- Números grandes: para leer la hora desde la cama, usa un TM1637 o un display de 7 segmentos en lugar de la LCD.
Errores comunes y cómo solucionarlos
- Error "'class LiquidCrystal_I2C' has no member named 'init'": tienes instaladas dos librerías LiquidCrystal_I2C distintas y el compilador elige la equivocada. Deja la de Frank de Brabander y borra la otra de la carpeta libraries.
- La LCD prende pero no muestra texto: ajusta el contraste con el potenciómetro azul de atrás del módulo; si no se arregla, la dirección no es 0x27 sino 0x3F.
- Aparece "RTC not found": SDA y SCL están invertidos o el VCC del RTC no está conectado. En el escáner I2C debe aparecer la dirección 0x68.
- La hora vuelve a la de compilación en cada encendido: la pila del RTC se agotó, está al revés o el módulo no tiene pila. Cámbiala y vuelve a ajustar la hora desde el menú.
- El buzzer solo hace clic o da un único tono: estás usando un buzzer activo. Para tocar melodías con tone() necesitas uno pasivo.
- Los botones se presionan solos: falta INPUT_PULLUP en pinMode o el pulsador está conectado a 5V en vez de a GND; un pin al aire lee valores al azar.
- El reloj se corre unos minutos: si usas un DS1307 es normal; pásate a un DS3231 o sincroniza la hora con NTP una vez al día usando la versión ESP32.
Este despertador reúne en un solo aparato útil los temas básicos de Arduino: RTC, I2C, EEPROM, lectura de pulsadores y buzzer. Si quieres probar paso a paso proyectos de relojes parecidos, en la app BlueGrays encontrarás el reloj LCD con RTC DS1302, el reloj digital con ESP32 y DS1307, el reloj por internet con ESP32 y NTP, el reloj digital con display de 7 segmentos de 4 dígitos y las melodías con buzzer, con su diagrama de conexión y su código listo.
Preguntas frecuentes
¿Cómo hacer un despertador con Arduino?
Un módulo RTC (DS3231 o DS1307) lleva la hora, una LCD I2C la muestra, con pulsadores se ajustan la hora y la alarma, y cuando llega la hora un buzzer pasivo toca una melodía. Si guardas la alarma en la EEPROM, tampoco se pierde después de un corte de luz.
¿Arduino puede llevar la hora sin módulo RTC?
Con millis() puede llevarla de forma aproximada, pero la hora se reinicia con cada reset o corte de luz y además puede correrse minutos por día. Para un reloj de verdad necesitas un módulo RTC o, si tienes Wi-Fi, un ESP32 con NTP.
¿Qué es mejor, el DS1307 o el DS3231?
El DS3231 es mucho más preciso: gracias a su cristal interno con compensación de temperatura se desvía alrededor de un minuto al año. El DS1307 puede correrse unos minutos al mes y necesita 5 V; para un despertador elige el DS3231.
¿Se borra la hora del Arduino cuando se corta la luz?
Si el módulo RTC tiene pila, no: el RTC sigue contando con la pila y, al volver la luz, Arduino lee la hora correcta. Como la alarma está guardada en la EEPROM, también conservas tu configuración; lo único es que la alarma no puede sonar durante el corte.
¿Qué buzzer necesito para un despertador con Arduino?
Para tocar una melodía necesitas un buzzer pasivo, que con la función tone() genera distintas frecuencias. Un buzzer activo solo da un tono fijo; si te alcanza con un pitido simple, también puedes usarlo con digitalWrite.
¿Cómo agregar la función posponer a una alarma con Arduino?
Cuando la alarma suena y se presiona un botón, sumas 300 segundos al unixtime de ese momento y lo guardas en una variable. El loop vuelve a disparar la alarma cuando la hora llega a ese valor; usar unixtime hace que funcione bien aunque el posponer pase la medianoche.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Uso del zumbador
¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

Configuración del módulo de reloj RTC DS1302
Pones en marcha un pequeño módulo de reloj que no olvida la hora aunque el Arduino se apague.

Reloj RTC DS1302 con pantalla LCD
Un pequeño reloj de mesa que no pierde la hora aunque se vaya la luz. El módulo de reloj DS1302 guarda la hora gracias a su propia pila diminuta; cada segundo el Arduino la lee y escribe la hora y la…

Reloj digital con ESP32 y RTC DS1307 (I2C + LCD)
En este proyecto, mostramos la hora y la fecha en una pantalla LCD I2C de 16x2 mediante el módulo de reloj en tiempo real (RTC) DS1307. El DS1307 es un RTC con batería de respaldo que conserva la hora incluso si el ESP32 se apaga. Ambos módulos comparten la misma línea I2C (SDA/SCL), por lo que aprendemos a controlar varios dispositivos con solo dos cables de señal. Con este proyecto conocerás el protocolo I2C, el funcionamiento de los módulos RTC y la visualización dinámica en pantallas LCD.

ESP32: hora real desde Internet con NTP
El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

Reloj digital con display de 7 segmentos de 4 dígitos
Un reloj digital luminoso de cuatro cifras, parecido al del horno de la cocina. El módulo de reloj DS1302 guarda la hora y cada segundo el Arduino lee las horas y los minutos y los muestra en el…

Reloj y calendario de matriz de puntos (MAX7219, DS1307)
Un panel luminoso para tu mesa o tu pared que muestra la hora y la fecha con texto en movimiento.

Uso de la pantalla LCD con I2C
Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

