Despertador com Arduino: RTC DS3231, LCD, buzzer e soneca
Monte um despertador com Arduino: RTC DS3231 ou DS1307, LCD I2C, 3 botões para ajustar hora e alarme, melodia no buzzer, soneca, alarme salvo na EEPROM e uma versão com ESP32 e NTP.
Montar um despertador com Arduino reúne um módulo RTC, um LCD, botões e um buzzer em um único projeto: você aprende bastante e ainda fica com algo que vai usar de verdade todas as manhãs. Neste guia vamos usar um módulo RTC DS3231 (ou DS1307), um LCD I2C 16x2, três botões e um buzzer passivo para montar um despertador em que a hora e o alarme são ajustados pelos botões, que toca uma melodia, tem função soneca de 5 minutos e não perde a hora nem quando a energia cai.
Você vai encontrar a ligação passo a passo, uma tabela de fluxo que mostra como o menu de botões funciona, como tocar uma melodia sem delay, como salvar o horário do alarme na EEPROM e o código completo, já compilado. Na última parte, vamos rodar o mesmo relógio sem módulo RTC, com um ESP32 que pega a hora da internet (NTP) e muda sozinho para o horário de verão.

Como funciona um despertador com Arduino?
O relógio interno do Arduino (millis) só conta enquanto a placa está alimentada e volta a zero a cada reinício; além disso, placas com ressonador cerâmico, como o Uno, podem adiantar ou atrasar minutos por dia. Por isso quem guarda a hora é um módulo RTC (relógio de tempo real): essa plaquinha, com cristal e bateria próprios, continua contando mesmo com o Arduino desligado. A cada volta do loop, o Arduino lê a hora no RTC, escreve no LCD, verifica os botões e, quando a hora bate com o horário do alarme, aciona o buzzer. Todo o comportamento é comandado por uma pequena máquina de estados, com os modos mostrar a hora, ajustar a hora, ajustar o alarme e alarme tocando.
| Peça | Função | Observação |
|---|---|---|
| Arduino Uno ou Nano | O cérebro | O Nano usa os mesmos pinos (A4/A5) |
| Módulo RTC DS3231 ou DS1307 | Guarda a hora | Os dois são I2C, endereço 0x68 |
| LCD I2C 16x2 | Mostra hora, data e alarme | O endereço costuma ser 0x27 ou 0x3F |
| 3 botões | MENU, mais (+) e menos (-) | Sem resistores (INPUT_PULLUP) |
| Buzzer passivo | Toca a melodia | Um buzzer ativo só emite um tom |
| Bateria CR2032 | Alimenta o RTC nas quedas de energia | Atenção ao circuito de carga do módulo |
| Protoboard e jumpers | Conexões | Placa perfurada para um relógio definitivo |
DS1307 ou DS3231?
Os dois módulos usam o mesmo endereço I2C e funcionam com quase o mesmo código graças à biblioteca RTClib, mas a precisão deles é muito diferente. O DS1307 depende de um cristal externo de 32,768 kHz e desvia conforme a temperatura ambiente muda; em módulos baratos, um desvio de alguns minutos por mês é normal. O DS3231 tem o cristal dentro do chip e o corrige de acordo com a temperatura, por isso desvia cerca de um minuto por ano. Para um relógio que vai acordar você todas as manhãs, o DS3231 é de longe a melhor escolha; se você já tem um DS1307, o código também funciona com ele.
| Característica | DS1307 | DS3231 |
|---|---|---|
| Precisão | Depende do cristal, pode desviar de 1 a 5 minutos por mês | ±2 ppm, cerca de 1 minuto por ano |
| Compensação de temperatura | Não | Sim (TCXO) |
| Alimentação | 4,5-5,5 V | 2,3-5,5 V (também funciona em 3,3 V com um ESP32) |
| Alarme interno | Não | 2 alarmes e uma saída INT/SQW |
| Sensor de temperatura | Não | Sim (±3 °C) |
| Endereço I2C | 0x68 | 0x68 |
| Classe da RTClib | RTC_DS1307 | RTC_DS3231 |
Ligação do despertador com Arduino
| Conexão | Arduino Uno | ESP32 (versão NTP) |
|---|---|---|
| SDA do LCD e do RTC | A4 | GPIO 21 (só o LCD) |
| SCL do LCD e do RTC | A5 | GPIO 22 (só o LCD) |
| VCC do LCD | 5V | VIN (5V) |
| VCC do RTC | 5V | Não precisa |
| Botão MENU | D2 | - |
| Botão mais (+) | D3 | - |
| Botão menos (-) / soneca | D4 | GPIO 27 (botão único) |
| Buzzer passivo (+) | D8 | GPIO 25 |
| Todos os GNDs | GND | GND |
O LCD e o RTC compartilham o mesmo barramento I2C: os pinos SDA dos dois módulos vão para A4 e os pinos SCL para A5; como os endereços são diferentes, eles não entram em conflito. Nos botões, basta ligar um terminal ao pino e o terminal oposto ao GND; como o código usa INPUT_PULLUP, não é preciso resistor externo e o pino lê LOW quando o botão é pressionado (detalhes em como ligar um botão). O terminal positivo do buzzer vai para D8 e o negativo para GND. Como a melodia usa a função tone(), você precisa de um buzzer passivo; explicamos a diferença em O que é um buzzer?.
Menu de botões: ajustando a hora e o alarme com três botões
Para fazer todos os ajustes com apenas três botões, cada botão faz um trabalho diferente conforme o modo. O botão MENU avança para o próximo passo, e os botões mais e menos alteram o valor que estiver selecionado. Essa estrutura se chama máquina de estados e permite escrever cada modo em seu próprio case, em vez de aninhar um monte de blocos if. A tabela abaixo mostra o menu inteiro; deixe-a ao lado enquanto lê o código e você vai entender na hora o que cada linha faz.
| Modo (no display) | MENU | Mais (+) | Menos (-) |
|---|---|---|---|
| Tela do relógio | Entra no ajuste da hora | Liga / desliga o alarme | Cancela a soneca |
| SET TIME: hora | Passa para os minutos | Hora +1 | Hora -1 |
| SET TIME: minuto | Grava a hora no RTC e passa para o ajuste do alarme | Minuto +1 | Minuto -1 |
| SET ALARM: hora | Passa para os minutos | Aumenta a hora do alarme | Diminui a hora do alarme |
| SET ALARM: minuto | Salva na EEPROM, liga o alarme e volta ao relógio | Aumenta o minuto | Diminui o minuto |
| WAKE UP! (alarme tocando) | Para o alarme | Soneca de 5 minutos | Soneca de 5 minutos |
Bibliotecas e primeira configuração
- No Gerenciador de Bibliotecas, instale a RTClib (da Adafruit) e deixe que ele instale a Adafruit BusIO como dependência.
- Para o LCD, instale a LiquidCrystal I2C (de Frank de Brabander). As bibliotecas EEPROM e Wire já vêm com o Arduino.
- Se não tiver certeza do endereço do LCD, rode o sketch de varredura do guia do LCD I2C e coloque no código o endereço encontrado no lugar de 0x27.
- Se estiver usando um DS1307, defina USE_DS3231 como 0 no código.
- Carregue o código. Se o RTC estiver ligando pela primeira vez ou se a bateria dele tiver acabado, o relógio é ajustado para o momento em que o código foi compilado e um aviso rápido de bateria aparece no display.
- Pressione MENU para entrar no ajuste da hora, acerte a hora exata e depois ajuste o alarme.
Código do despertador com Arduino
Aqui está o código completo. Não há nenhum delay longo no loop: os botões, a melodia e o display são todos temporizados com millis(), então os botões respondem na hora mesmo com o alarme tocando. O display só é redesenhado quando o segundo muda ou quando um botão é pressionado, o que evita que o LCD fique piscando.
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}Como o código funciona?
| Parte | O que faz |
|---|---|
| pressed() | Lê um botão com um filtro de debounce de 30 ms; retorna true a cada novo toque e repete enquanto o botão fica pressionado nos modos de ajuste. |
| enum Mode e switch | Tratam separadamente os modos relógio, ajuste da hora, ajuste do alarme e alarme tocando. |
| key (dia × 1440 + minuto) | Impede que o alarme toque duas vezes no mesmo minuto. |
| snoozeAt | Guarda o instante em que a soneca termina como unixtime; funciona certo mesmo quando passa da meia-noite. |
| playMelody() | Toca as notas uma após a outra com millis(), sem delay. |
| draw() e printLine() | Escrevem no display só quando necessário e limpam o fim de cada linha com espaços. |
| loadAlarm() e saveAlarm() | Leem e salvam na EEPROM o horário do alarme e o estado ligado/desligado. |
| USE_DS3231 | Alterna entre o DS3231 e o DS1307 com uma única linha. |
Para disparar o alarme, olhamos os minutos, não os segundos. Tentar pegar o segundo 0 é arriscado: se o loop estiver ocupado atualizando o display justamente nesse segundo, o alarme pode nunca tocar. Em vez disso, o alarme começa quando a hora e o minuto coincidem, e guardamos a identidade desse minuto em lastAlarmKey. Assim, se você parar o alarme dentro do mesmo minuto, ele não recomeça. O horário da soneca é calculado a partir do unixtime que o RTC fornece (segundos desde 1970); adie por 5 minutos às 23:58 e o alarme toca às 00:03 sem nenhum problema. A lógica de temporizar com millis() está em millis ou delay.
Melodia do buzzer e soneca
A melodia fica em um pequeno array de pares de frequência e duração: as notas 1047 Hz (C6), 1319 Hz (E6), 1568 Hz (G6) e 2093 Hz (C7) tocam com intervalos curtos, depois vêm 600 ms de silêncio e o ciclo recomeça. Para um despertar mais insistente, você pode encurtar o silêncio ou acrescentar suas próprias notas; frequência 0 significa pausa. Se ninguém parar o alarme, ele se cala sozinho depois de 60 segundos, para não incomodar os vizinhos enquanto você está fora. Apertar mais ou menos adia o alarme por 5 minutos e mostra o tempo restante no display; o botão MENU silencia o alarme de vez naquele dia, e ele volta a tocar no mesmo horário no dia seguinte.
Salvando o alarme na EEPROM
O RTC guarda a hora, mas o horário do alarme fica na RAM do Arduino e é apagado quando a energia cai. Para evitar isso, gravamos o alarme na EEPROM de 1 KB do Arduino Uno. Como cada célula aguenta cerca de 100.000 gravações, usamos EEPROM.update(), que pula a gravação se a célula já tiver o mesmo valor. O marcador 0xA5 no quarto byte indica que a EEPROM já foi gravada por este programa; ele impede que valores aleatórios sejam lidos na primeiríssima inicialização e que o alarme acabe em um horário sem sentido, como 37:99. Para mais detalhes, veja o guia EEPROM do Arduino.
| Endereço da EEPROM | Conteúdo | Exemplo |
|---|---|---|
| 0 | Hora do alarme (0-23) | 7 |
| 1 | Minuto do alarme (0-59) | 30 |
| 2 | Alarme ligado? (1 = ligado, 0 = desligado) | 1 |
| 3 | Marcador de validade | 0xA5 |
Por que o relógio não perde a hora quando a energia cai?
Quando a energia cai, o chip RTC passa sozinho para a bateria CR2032 e não faz nada além de continuar contando. Nesse modo o DS3231 consome alguns microampères e o DS1307 ainda menos; no papel, uma bateria tipo moeda de 220 mAh dura mais de dez anos e, na prática, a vida útil dela é limitada pela própria validade da bateria. Quando a energia volta, o Arduino começa do zero, lê a hora no RTC e o alarme na EEPROM e continua de onde parou. A única lacuna é que o alarme não consegue tocar durante a queda, porque o buzzer e o Arduino não são alimentados por bateria. Em uma casa com quedas frequentes, alimentar o Arduino com uma bateria 18650, um módulo carregador e um conversor boost resolve isso também. Se o relógio volta para a hora da compilação a cada reset, a bateria do RTC acabou ou está mal encaixada.
Versão ESP32 com NTP: hora da internet sem módulo RTC
Como o ESP32 se conecta ao Wi-Fi, ele pode pegar a hora em servidores de tempo da internet (NTP) em vez de usar um módulo RTC. A string de fuso horário que você passa para configTzTime() também contém as regras do horário de verão, então a mudança de hora em março e outubro (ou em março e novembro nos EUA) acontece automaticamente. No ESP32, usa-se a biblioteca Preferences no lugar da EEPROM; ela guarda o horário do alarme na flash como pares chave-valor. Esta versão precisa de um único botão: com o alarme tocando, um toque curto adia por 5 minutos e um toque de mais de 1,5 segundo o interrompe. Para ajustar o alarme, digite um horário como 07:30 no Monitor Serial, e digite off para desativá-lo. O NTP é explicado em detalhes em Relógio NTP com 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ão | String TZ_INFO | Horário de verão |
|---|---|---|
| Turquia | <+03>-3 | Não tem |
| Espanha, Alemanha, França, Itália | CET-1CEST,M3.5.0,M10.5.0/3 | Último domingo de março e de outubro |
| Reino Unido | GMT0BST,M3.5.0/1,M10.5.0 | Último domingo de março e de outubro |
| México (centro) | CST6 | Não tem desde 2022 |
| Argentina | <-03>3 | Não tem |
| Colômbia | <-05>5 | Não tem |
| Costa Leste dos EUA | EST5EDT,M3.2.0,M11.1.0 | Segundo domingo de março, primeiro domingo de novembro |
O ponto fraco da versão NTP é que, depois de uma queda de energia, ela não sabe a hora até o Wi-Fi voltar; se o seu roteador demora mais para iniciar do que o ESP32, o display pode ficar em branco por alguns minutos. A solução mais robusta é combinar os dois: ligue um DS3231 ao ESP32, busque a hora no NTP uma vez por dia e grave-a no RTC, e leia do RTC sempre que não houver internet. Assim o horário de verão é tratado automaticamente e você também não perde a hora em uma queda de energia.
Ideias para turbinar seu despertador
- Alarme só em dias úteis: use dayOfTheWeek() de DateTime para tocar apenas de segunda a sexta; guarde os dias na EEPROM como uma máscara de 7 bits.
- Alarme nascer do sol: 15 minutos antes do alarme, vá passando aos poucos um anel de LEDs WS2812B do vermelho ao branco.
- Acordar com MP3: no lugar do buzzer, use um DFPlayer Mini para tocar sua música favorita a partir de um cartão SD.
- Temperatura no display: mostre a leitura de rtc.getTemperature() do DS3231 na segunda linha do display.
- Brilho automático: use um LDR para apagar a luz de fundo do LCD à noite e acendê-la de manhã.
- Dígitos grandes: para ler a hora do outro lado do quarto, use um TM1637 ou um display de 7 segmentos no lugar do LCD.
Erros comuns e como resolver
- Erro “'class LiquidCrystal_I2C' has no member named 'init'”: você tem duas bibliotecas LiquidCrystal_I2C diferentes instaladas e o compilador está escolhendo a errada. Fique com a biblioteca de Frank de Brabander e remova a outra da sua pasta de bibliotecas.
- O LCD acende, mas não mostra texto: ajuste o contraste no trimpot azul na parte de trás do módulo; se não resolver, o endereço é 0x3F, e não 0x27.
- Aparece “RTC not found”: SDA e SCL estão trocados ou o VCC do RTC não está ligado. O scanner I2C deve mostrar o endereço 0x68.
- O relógio volta para a hora da compilação toda vez que é ligado: a bateria do RTC acabou, foi colocada ao contrário ou está faltando. Troque-a e acerte a hora de novo pelo menu.
- O buzzer só dá estalos ou toca um único tom: você está usando um buzzer ativo. Tocar melodias com tone() exige um passivo.
- Os botões são acionados sozinhos: falta o INPUT_PULLUP no pinMode, ou o botão está ligado ao 5V em vez do GND; um pino flutuante lê valores aleatórios.
- O relógio desvia alguns minutos: isso é normal no DS1307; troque por um DS3231 ou use a versão com ESP32 para sincronizar a hora pelo NTP todos os dias.
Este despertador reúne os temas centrais do Arduino (RTC, I2C, EEPROM, leitura de botões e buzzers) em um aparelho realmente útil. Se quiser experimentar projetos de relógio parecidos passo a passo, o app BlueGrays tem um relógio com LCD e RTC DS1302, um relógio digital com ESP32 e DS1307, um relógio de internet com ESP32 e NTP, um relógio digital com display de 7 segmentos de 4 dígitos e projetos de melodia com buzzer, cada um com esquema do circuito e código pronto para usar.
Perguntas frequentes
Como fazer um despertador com Arduino?
Um módulo RTC (DS3231 ou DS1307) guarda a hora, um LCD I2C a exibe, botões ajustam a hora e o alarme e, quando chega o horário do alarme, um buzzer passivo toca uma melodia. Se você salvar o horário do alarme na EEPROM, ele também sobrevive às quedas de energia.
O Arduino consegue marcar a hora sem um módulo RTC?
Ele consegue marcar a hora de forma aproximada com millis(), mas a hora zera a cada reinício ou queda de energia e pode desviar minutos por dia. Para um relógio de verdade você precisa de um módulo RTC ou, se tiver Wi-Fi, de um ESP32 com NTP.
Qual é melhor: DS1307 ou DS3231?
O DS3231 é muito mais preciso: graças ao cristal interno com compensação de temperatura, ele desvia cerca de um minuto por ano. O DS1307 pode desviar alguns minutos por mês e precisa de 5 V, então escolha o DS3231 para um despertador.
O relógio com Arduino zera quando a energia cai?
Não, desde que o módulo RTC tenha bateria: o RTC continua contando com a bateria e o Arduino lê a hora certa quando é ligado. Como o horário do alarme fica na EEPROM, seus ajustes também são mantidos; o alarme só não consegue tocar durante a queda.
De que buzzer eu preciso para um despertador com Arduino?
Para tocar uma melodia você precisa de um buzzer passivo, que consegue produzir frequências diferentes com a função tone(). Um buzzer ativo só emite um tom fixo; se um bipe simples for suficiente, dá para acioná-lo com digitalWrite.
Como adiciono a soneca a um alarme com Arduino?
Quando um botão for pressionado com o alarme tocando, some 300 segundos ao unixtime atual e guarde o resultado em uma variável. O loop principal reinicia o alarme quando a hora chega a esse valor; usar unixtime mantém tudo certo mesmo quando a soneca atravessa a meia-noite.
Projetos para montar depois desta leitura
Ver todos os projetos
Uso do buzzer
Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

Configuração do módulo de relógio RTC DS1302
Coloque em funcionamento um pequeno módulo de relógio que mantém a hora mesmo quando o Arduino é desligado.

Relógio RTC DS1302 com display LCD
Um pequeno relógio de mesa que mantém a hora mesmo quando falta energia. O módulo de relógio DS1302 mantém a hora graças à sua própria pilha; a cada segundo, o Arduino lê essa informação e exibe a…

Relógio digital com ESP32 e RTC DS1307 (I2C + LCD)
Neste projeto, exibimos a hora e a data em um display LCD I2C 16x2 usando o módulo de relógio de tempo real (RTC) DS1307. O DS1307 é um RTC com bateria de reserva que mantém a hora mesmo quando o ESP32 é desligado. Os dois módulos compartilham o mesmo barramento I2C (SDA/SCL), permitindo aprender a controlar vários dispositivos com apenas dois fios de sinal. Você aprenderá na prática o protocolo de comunicação I2C, o funcionamento dos módulos RTC e a exibição de dados dinâmicos em um LCD.

Hora exata pela internet com ESP32 e NTP
O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.

Relógio digital com display de 7 segmentos de 4 dígitos
Um relógio digital luminoso de quatro dígitos, parecido com o de um forno de cozinha.

Relógio e calendário de matriz de LEDs (MAX7219, DS1307)
Um painel luminoso para a mesa ou a parede que mostra a hora e a data em texto deslizante.

Uso do display LCD com I2C
Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

