Guias · 11 min de leitura

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.

Módulo de relógio RTC DS1307 com suporte para bateria CR2032
Módulo RTC DS1307: pinos GND, 5V, SDA, SCL e SQW; a bateria CR2032 na parte de trás mantém o relógio funcionando quando a energia cai.

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çaFunçãoObservação
Arduino Uno ou NanoO cérebroO Nano usa os mesmos pinos (A4/A5)
Módulo RTC DS3231 ou DS1307Guarda a horaOs dois são I2C, endereço 0x68
LCD I2C 16x2Mostra hora, data e alarmeO endereço costuma ser 0x27 ou 0x3F
3 botõesMENU, mais (+) e menos (-)Sem resistores (INPUT_PULLUP)
Buzzer passivoToca a melodiaUm buzzer ativo só emite um tom
Bateria CR2032Alimenta o RTC nas quedas de energiaAtenção ao circuito de carga do módulo
Protoboard e jumpersConexõesPlaca 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ísticaDS1307DS3231
PrecisãoDepende do cristal, pode desviar de 1 a 5 minutos por mês±2 ppm, cerca de 1 minuto por ano
Compensação de temperaturaNãoSim (TCXO)
Alimentação4,5-5,5 V2,3-5,5 V (também funciona em 3,3 V com um ESP32)
Alarme internoNão2 alarmes e uma saída INT/SQW
Sensor de temperaturaNãoSim (±3 °C)
Endereço I2C0x680x68
Classe da RTClibRTC_DS1307RTC_DS3231

Ligação do despertador com Arduino

ConexãoArduino UnoESP32 (versão NTP)
SDA do LCD e do RTCA4GPIO 21 (só o LCD)
SCL do LCD e do RTCA5GPIO 22 (só o LCD)
VCC do LCD5VVIN (5V)
VCC do RTC5VNão precisa
Botão MENUD2-
Botão mais (+)D3-
Botão menos (-) / sonecaD4GPIO 27 (botão único)
Buzzer passivo (+)D8GPIO 25
Todos os GNDsGNDGND
A maioria dos módulos DS3231 baratos (ZS-042) tem um resistor e um diodo que tentam carregar a bateria. Esse circuito foi pensado para uma LIR2032 recarregável; se você colocar nele uma CR2032 comum, a bateria pode estufar com o tempo. Se for usar uma CR2032, dessolde da placa o resistor de 200 Ω ou o diodo, ou então use uma bateria LIR2032.

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

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)MENUMais (+)Menos (-)
Tela do relógioEntra no ajuste da horaLiga / desliga o alarmeCancela a soneca
SET TIME: horaPassa para os minutosHora +1Hora -1
SET TIME: minutoGrava a hora no RTC e passa para o ajuste do alarmeMinuto +1Minuto -1
SET ALARM: horaPassa para os minutosAumenta a hora do alarmeDiminui a hora do alarme
SET ALARM: minutoSalva na EEPROM, liga o alarme e volta ao relógioAumenta o minutoDiminui o minuto
WAKE UP! (alarme tocando)Para o alarmeSoneca de 5 minutosSoneca de 5 minutos
Nos modos de ajuste, se você mantiver pressionado o botão mais ou menos, depois de 0,6 segundo o valor dispara e avança cerca de 7 passos por segundo. Assim você não precisa apertar 45 vezes para levar os minutos de 0 a 45. Na tela do relógio essa repetição fica desativada; caso contrário, segurar o botão ligaria e desligaria o alarme sem parar.

Bibliotecas e primeira configuração

  1. No Gerenciador de Bibliotecas, instale a RTClib (da Adafruit) e deixe que ele instale a Adafruit BusIO como dependência.
  2. Para o LCD, instale a LiquidCrystal I2C (de Frank de Brabander). As bibliotecas EEPROM e Wire já vêm com o Arduino.
  3. 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.
  4. Se estiver usando um DS1307, defina USE_DS3231 como 0 no código.
  5. 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.
  6. 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.

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}

Como o código funciona?

ParteO 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 switchTratam 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.
snoozeAtGuarda 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_DS3231Alterna 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 EEPROMConteúdoExemplo
0Hora do alarme (0-23)7
1Minuto do alarme (0-59)30
2Alarme ligado? (1 = ligado, 0 = desligado)1
3Marcador de validade0xA5

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.

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}
RegiãoString TZ_INFOHorário de verão
Turquia<+03>-3Não tem
Espanha, Alemanha, França, ItáliaCET-1CEST,M3.5.0,M10.5.0/3Último domingo de março e de outubro
Reino UnidoGMT0BST,M3.5.0/1,M10.5.0Último domingo de março e de outubro
México (centro)CST6Não tem desde 2022
Argentina<-03>3Não tem
Colômbia<-05>5Não tem
Costa Leste dos EUAEST5EDT,M3.2.0,M11.1.0Segundo 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.
A hora da compilação fica alguns segundos atrás do momento do carregamento. Se você quer a hora exata até o segundo, ajuste os minutos olhando o relógio do celular e pressione MENU bem na virada do minuto; como o código grava os segundos como 0, seu relógio vai bater exatamente com aquele instante.

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.

Ver todos os projetos
Uso do buzzer
AR-13Iniciante

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.

4.7(92)
170
Configuração do módulo de relógio RTC DS1302
AR-45Iniciante

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.

4.5(23)
31
Relógio RTC DS1302 com display LCD
AR-46Intermediário
Premium

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…

4.7(41)
51
Relógio digital com ESP32 e RTC DS1307 (I2C + LCD)
ES-18Intermediário
Premium

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.

4.6(26)
40
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

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.

4.5(13)
22
Relógio digital com display de 7 segmentos de 4 dígitos
AR-48Intermediário
Premium

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.

4.8(56)
73
Relógio e calendário de matriz de LEDs (MAX7219, DS1307)
AR-84Intermediário
Premium

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.

5.0(37)
59
Uso do display LCD com I2C
AR-32Iniciante
Premium

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…

4.8(53)
70