Como criar um despertador com Arduino e módulo RTC DS3231

Projetos que dependem de horários programados exigem um componente capaz de manter a data e a hora corretamente, já que o Arduino não possui um relógio interno capaz de continuar contando o tempo quando está desligado. Para isso, utilizaremos o módulo RTC DS3231 (Real Time Clock), conhecido por sua alta precisão e facilidade de integração com o Arduino.

Neste projeto, você aprenderá a desenvolver um dispertador utilizando um Arduino Uno e um módulo RTC DS3231. Quando o horário configurado for atingido, um LED e um buzzer serão acionados automaticamente. O sistema também contará com um botão para desligar o alarme, tornando o projeto uma excelente base para despertadores, lembretes e sistemas de automação.

Nível do projeto: Intermediário

Como o projeto funciona?

O DS3231 mantém a data e a hora atualizadas graças à sua bateria de backup, mesmo quando o Arduino está desligado. Durante a execução do programa, o Arduino consulta continuamente o horário armazenado no módulo e o compara com o horário configurado para o alarme.

Quando ambos coincidem, o LED e o buzzer são acionados em um padrão sonoro e luminoso. O alarme permanecerá ativo até que o botão conectado ao pino D2 seja pressionado.

Acompanhe abaixo a logica do sistema ⬇

Conhecendo o módulo RTC DS3231

O DS3231 é um módulo RTC (Real Time Clock) responsável por armazenar a data e a hora com alta precisão. Sua principal vantagem é possuir um cristal compensado por temperatura (TCXO), oferecendo uma precisão superior quando comparado a outros módulos RTC.

Além disso, ele conta com um suporte para bateria CR2032 de 3V, permitindo que continue contando o tempo mesmo quando o Arduino estiver desligado.

Em uma das laterais do módulo encontramos seis pinos:

• 32K: saída de um sinal de 32,768 kHz, utilizada em aplicações que necessitam de uma referência precisa de frequência.
• SQW: saída de onda quadrada programável, podendo gerar sinais em diferentes frequências para projetos mais avançados.
• SCL: linha de clock da comunicação I²C.
• SDA: linha de dados da comunicação I²C.
• VCC: alimentação do módulo com 5V
• GND: terra (referência elétrica).

Embora o módulo possua seis pinos, neste projeto utilizaremos apenas VCC, GND, SDA e SCL, responsáveis pela alimentação e comunicação entre o DS3231 e o Arduino.

Componentes utilizados

Para montar este projeto serão necessários os seguintes componentes:

• 1x Placa Uno R3 + Cabo Usb para Arduino
• 1x Real Time Clock RTC DS3231
• 1x LED 5mm (qualquer cor)
• 1x Resistor 330Ω
• 1x Buzzer Ativo 5v
• 1x Push Button (Chave Táctil) 6x6x7mm
• 1x Protoboard 400 Pontos
• 6x Jumpers – Macho/Macho

Montagem do circuito

A montagem do circuito é bastante simples, já que o módulo DS3231 utiliza o protocolo de comunicação I²C, necessitando de apenas dois fios para transmissão de dados, além da alimentação.

Ligações do módulo DS3231

Ligações dos demais componentes

Neste projeto, o LED e o buzzer compartilham o mesmo pino digital (D8), sendo acionados simultaneamente quando o alarme é disparado. Já o botão utiliza o resistor de pull-up interno do Arduino, dispensando a necessidade de um resistor externo e simplificando a montagem.

Observação: No esquemático acima foi utilizado o módulo RTC DS1307, pois o software utilizado para elaborar o circuito não possui o modelo DS3231. Entretanto, as conexões entre ambos são idênticas, permitindo seguir a montagem normalmente sem qualquer alteração nas ligações.

Configurando o módulo RTC DS3231

Com o circuito montado, chegou o momento de configurar o módulo RTC DS3231 e programar o Arduino. Nesta etapa, o Arduino será responsável por consultar continuamente a data e a hora armazenadas no módulo e comparar essas informações com o horário configurado para o alarme.

Quando ambos coincidirem, o LED e o buzzer serão acionados automaticamente até que o botão seja pressionado.

Instalando a biblioteca RTClib

Antes de carregar o código para o Arduino, é necessário instalar a biblioteca RTClib, desenvolvida pela Adafruit.

Para isso:

1. Abra a Arduino IDE.
2. Clique em Sketch → Incluir Biblioteca → Gerenciar Bibliotecas…
3. Pesquise por RTClib.
4. Instale a biblioteca desenvolvida pela Adafruit.

Após a instalação, a biblioteca já estará pronta para ser utilizada em seus projetos.

Configurando a data e a hora do DS3231

Como o módulo RTC possui memória própria e uma bateria de backup, basta ajustar a data e a hora uma única vez.

No início do código existe a seguinte configuração:

#define AJUSTAR_RTC false

Sempre que essa constante estiver definida como true, o Arduino gravará no módulo RTC a data e a hora especificadas nas linhas abaixo:

const int ANO = 2026;
const int MES = 7;
const int DIA = 12;
const int HORA = 20;
const int MIN  = 46;
const int SEG  = 0;

Altere esses valores de acordo com a data e a hora atuais.

Em seguida, altere a constante para:

#define AJUSTAR_RTC true

Faça o upload do código para o Arduino. Assim que a gravação terminar, a data e a hora serão armazenadas no módulo DS3231.

Importante: Após gravar a data e a hora no módulo DS3231, altere novamente a constante AJUSTAR_RTC para false e envie o código para o Arduino mais uma vez.

Caso essa etapa não seja realizada, toda vez que o Arduino for desligado e ligado novamente, ele gravará no RTC a mesma data e hora definidas no código, fazendo com que o relógio “volte no tempo” a cada reinicialização.

Ao enviar o código novamente com AJUSTAR_RTC definido como false, o Arduino apenas fará a leitura da data e da hora armazenadas no módulo, permitindo que o DS3231 continue mantendo o horário atualizado normalmente, mesmo após desligamentos ou quedas de energia.

Dica: Para sincronizar o RTC com mais precisão, verifique quanto tempo o Arduino leva para gravar o código. Se o upload demorar cerca de 10 segundos e o horário atual for 06:31, configure o relógio para 06:32. Quando o relógio marcar 06:31:50, envie o código. Assim, o DS3231 ficará sincronizado com apenas um ou dois segundos de diferença.

Configurando o horário do alarme

O horário de acionamento do alarme também pode ser alterado facilmente no início do programa, Basta colocar quando o alarme deve tocar

const int ALARME_HORA = 23;
const int ALARME_MIN  = 25;

Observação: Neste exemplo, o alarme deve ser configurado para um horário que ainda ocorrerá no mesmo dia. Por exemplo, se o relógio estiver marcando 14:00, você pode programar o alarme para 14:30 ou 18:00. Caso configure um horário que já passou, como 08:00, será necessário aguardar até o dia seguinte para que o alarme seja acionado novamente.

A variável ALARME_HORA aceita valores entre 0 e 23, seguindo o formato de 24 horas, utilizando a mesma regra apresentada anteriormente para a configuração da data e da hora do módulo RTC. Portanto, não é necessário adicionar um zero à esquerda para horários menores que 10.

Por exemplo:

• 07:30 → ALARME_HORA = 7
• 14:15 → ALARME_HORA = 14
• 23:45 → ALARME_HORA = 23

A variável ALARME_MIN segue a mesma regra, podendo assumir valores entre 0 e 59.

Sempre que o horário atual do módulo RTC coincidir com esses valores, o alarme será acionado automaticamente.

Código completo

Após realizar todas as configurações, carregue o código abaixo no Arduino.

#include <Wire.h>
#include <RTClib.h>

RTC_DS3231 rtc;

/**************************************************
 CONFIGURAÇÕES DO USUÁRIO
*************************************************/
// ========= Ajuste do relógio =========
// Coloque "true" para gravar
// a data e hora no DS3231.
// Depois de enviar o código, volte para false., e pra evitar de quando ligar o arduino, ele resetar a data e hora, mande codigo novamente em false

#define AJUSTAR_RTC false

// Data e hora que serão gravadas no RTC
const int ANO = 2026;
const int MES = 7;
const int DIA = 12;
const int HORA = 2;
const int MIN = 46;
const int SEG = 0;

// ========= Configuração do alarme =========
// Aceita qualquer hora de 0 a 23 (Ex: 2 para 02:45 da madrugada)
const int ALARME_HORA = 23;
const int ALARME_MIN = 25;

// ========= Pinos =========
const byte PINO_LED = 8;
const byte PINO_BUZZER = 8;
const byte PINO_BOTAO = 2;

// Controle do estado do alarme
bool alarmeAtivo = false;

void setup() {
  Serial.begin(9600);

  if (!rtc.begin()) {
    Serial.println("RTC nao encontrado!");
    while (1);
  }

  if (AJUSTAR_RTC) {
    rtc.adjust(DateTime(ANO, MES, DIA, HORA, MIN, SEG));
  }

  pinMode(PINO_LED, OUTPUT);
  pinMode(PINO_BUZZER, OUTPUT);
  pinMode(PINO_BOTAO, INPUT_PULLUP); 
}

void loop() {
  DateTime agora = rtc.now();

  // Exibe a hora atual formatada no Monitor Serial
  if(agora.hour() < 10) Serial.print("0");
  Serial.print(agora.hour());
  Serial.print(":");
  if(agora.minute() < 10) Serial.print("0");
  Serial.print(agora.minute());
  Serial.print(":");
  if(agora.second() < 10) Serial.print("0");
  Serial.println(agora.second());

  // Ativa o alarme exatamente no minuto configurado
  if (agora.hour() == ALARME_HORA && agora.minute() == ALARME_MIN && agora.second() == 0) {
    alarmeAtivo = true;
  }

  // Executa o padrão de BIP se o alarme estiver ativo
  if (alarmeAtivo) {
    // Primeiro bip do segundo
    digitalWrite(PINO_LED, HIGH);
    digitalWrite(PINO_BUZZER, HIGH);
    delay(150);
    digitalWrite(PINO_LED, LOW);
    digitalWrite(PINO_BUZZER, LOW);
    delay(150);

    // Segundo bip do segundo (padrão duplo rápido)
    digitalWrite(PINO_LED, HIGH);
    digitalWrite(PINO_BUZZER, HIGH);
    delay(150);
    digitalWrite(PINO_LED, LOW);
    digitalWrite(PINO_BUZZER, LOW);
    
    // Pequena pausa antes de ler o botão e repetir no próximo ciclo do loop
    delay(550); 
  } else {
    // Se o alarme não estiver ativo, espera 1 segundo normalmente
    delay(1000);
  }

  // Desliga o alarme ao pressionar o botão
  if (digitalRead(PINO_BOTAO) == LOW) {
    alarmeAtivo = false;
    digitalWrite(PINO_LED, LOW);
    digitalWrite(PINO_BUZZER, LOW);
  }
}

Código desenvolvido pelo autor, com uso livre para estudos e projetos.

Entendendo o funcionamento do código

Embora o programa seja compacto, ele está dividido em etapas bem definidas, facilitando sua compreensão.

Inclusão das bibliotecas

Logo no início são incluídas as bibliotecas responsáveis pela comunicação I²C e pelo controle do módulo RTC.

#include <Wire.h>
#include <RTClib.h>

A biblioteca Wire implementa o protocolo I²C, enquanto a RTClib fornece funções prontas para acessar o DS3231.

Inicialização do sistema

Dentro da função setup(), o Arduino inicializa a comunicação serial, verifica se o módulo RTC foi encontrado e configura os pinos utilizados pelo LED, buzzer e botão.

Caso o módulo DS3231 não seja detectado, uma mensagem é exibida no Monitor Serial e a execução do programa é interrompida.

Quando AJUSTAR_RTC estiver definido como true, a função rtc.adjust() grava a nova data e hora no módulo.

Leitura do relógio

No início de cada execução do loop(), o Arduino consulta o horário atual utilizando:

DateTime agora = rtc.now();

Essa linha cria um objeto contendo todas as informações de data e hora armazenadas pelo DS3231, como ano, mês, dia, hora, minuto e segundo.

Em seguida, essas informações são exibidas no Monitor Serial, permitindo acompanhar o funcionamento do relógio em tempo real.

Verificação do alarme

O Arduino compara continuamente o horário atual com o horário configurado.

Quando a hora, o minuto e o segundo correspondem exatamente aos valores programados, a variável alarmeAtivo passa a valer true, indicando que o alarme deve ser iniciado.

Acionamento do LED e do buzzer

Enquanto alarmeAtivo permanecer verdadeiro, o Arduino executa um padrão de dois bipes rápidos, acionando simultaneamente o LED e o buzzer conectados ao pino digital D8.

Esse padrão se repete continuamente até que o botão seja pressionado.

Desligando o alarme

O botão está conectado ao pino digital D2 utilizando o resistor de pull-up interno do Arduino.

Quando o botão é pressionado, seu estado lógico passa para LOW, fazendo com que o programa desative o alarme e desligue imediatamente o LED e o buzzer.

Testando o projeto

Após montar o circuito e carregar o código, abra o Monitor Serial da Arduino IDE configurado para 9600 baud. O horário armazenado no módulo RTC será exibido continuamente, permitindo verificar se a configuração foi realizada corretamente.

Para testar o funcionamento do alarme, programe um horário com poucos minutos de diferença em relação ao horário atual. Quando esse horário for atingido, o LED e o buzzer serão acionados automaticamente em um padrão de dois bipes rápidos.

Em seguida, pressione o botão conectado ao pino D2. O LED e o buzzer deverão ser desligados imediatamente, indicando que o alarme foi encerrado com sucesso.

Caso o alarme não seja acionado, verifique os seguintes itens:

• Se a biblioteca RTClib foi instalada corretamente.
• Se as conexões do módulo DS3231 estão corretas.
• Se a data e a hora foram configuradas corretamente.
• Se AJUSTAR_RTC foi retornado para false após a sincronização do relógio.

Se tudo der certo, seu projeto funcionará asim:

Possíveis melhorias

Este projeto pode servir como base para diversas aplicações. Algumas melhorias que podem ser implementadas são:

• Adicionar múltiplos horários de alarme.
• Exibir a data e a hora em um display LCD ou OLED.
• Permitir configurar o horário por meio de botões.
• Acionar relés para controlar cargas externas.
• Criar uma agenda semanal utilizando os dias da semana.

Conclusão

Neste artigo, desenvolvemos um alarme utilizando o módulo RTC DS3231 e o Arduino Uno, explorando desde a montagem do circuito até a configuração do relógio e do horário do alarme.

Além de aprender a utilizar a comunicação I²C e a biblioteca RTClib, você conheceu uma forma simples de criar sistemas baseados em tempo real, que podem ser adaptados para diversas aplicações de automação.

Agora que o projeto está funcionando, experimente adicionar novas funcionalidades e adaptá-lo às suas necessidades. Pequenas modificações podem transformar este circuito em um despertador, uma campainha automatizada ou até mesmo um sistema de controle de horários.

Obrigado por acompanhar este projeto! Espero que este artigo tenha contribuído para o seu aprendizado e servido de inspiração para novos projetos com Arduino.

Referências

• Documentação da biblioteca RTClib.
• Datasheet do DS3231.
• Código desenvolvido pelo autor e disponibilizado livremente para estudos e adaptações.