Construa um Relógio Despertador Confiável com RTC DS1302 e Arduino UNO

Componentes e Materiais

Sobre o Projeto

Olá a todos! Neste projeto, vamos construir um relógio despertador simples usando uma placa Arduino UNO. Este projeto combina vários módulos que utilizei anteriormente; se tiver dificuldades em alguma etapa, consulte os tutoriais individuais de cada módulo no site, pois costumo trabalhar assim: testo cada parte separadamente e depois as integro.

Bibliotecas Necessárias

• Biblioteca LCD I2C (pode usar a sugerida ou outra de sua preferência)
• Biblioteca Keypad (disponível no Gerenciador de Bibliotecas da IDE Arduino)
• Biblioteca RTC DS1302 virtuabotix

Ligação (Wiring)

Siga o diagrama esquemático abaixo para conectar todos os componentes. O RTC DS1302 utiliza os pinos CLK, DAT e RST (conectados aos pinos 2, 3 e 4 do Arduino, respectivamente). O teclado matricial usa os pinos 9 a 12 (linhas) e 5 a 8 (colunas). O buzzer fica no pino 13. O display LCD I2C conecta-se via I2C (A4/SDA, A5/SCL).

Funcionamento do Código

Após a ligação, o LCD mostrará a data e hora padrão ou a última configurada. Pressione "*" para ajustar a data e hora no RTC DS1302. O display exibirá o dia e a hora atuais. Para configurar o alarme, pressione "A" e defina hora e minuto. O alarme pode ser desativado pressionando "B" antes da hora programada ou qualquer tecla enquanto estiver tocando.

Código Fonte

O código completo está disponível para download. Abaixo, apresentamos o sketch principal com comentários explicativos.

// Relógio despertador com DS1302 RTC + Teclado 4x4 + LCD I2C + Arduino + Buzzer
// Após a ligação, o LCD mostra a data/hora padrão ou a configurada anteriormente
// Objetivo: configurar o RTC pelo teclado, armazenar permanentemente, exibir na tela e configurar alarme.
// Referência: Surtrtech.com ou canal SurtrTech no YouTube

#include <Keypad.h>
#include <Wire.h>
#include <virtuabotixRTC.h>
#include <LiquidCrystal_I2C.h>

#define I2C_ADDR 0x27
#define BACKLIGHT_PIN 3
#define En_pin 2
#define Rw_pin 1
#define Rs_pin 0
#define D4_pin 4
#define D5_pin 5
#define D6_pin 6
#define D7_pin 7

LiquidCrystal_I2C lcd(I2C_ADDR, En_pin, Rw_pin, Rs_pin, D4_pin, D5_pin, D6_pin, D7_pin);
virtuabotixRTC myRTC(2, 3, 4); // CLK, DAT, RST

const byte numRows = 4;
const byte numCols = 4;
char keymap[numRows][numCols] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[numRows] = {12, 11, 10, 9};
byte colPins[numCols] = {8, 7, 6, 5};

int i1,i2,i3,i4;
char c1,c2,c3,c4;
char keypressed, keypressedx;
int A_hour = -1;
int A_minute = -1;
int AlarmIsActive = 0;
int buzzer = 13;

Keypad myKeypad = Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.setBacklightPin(BACKLIGHT_PIN, POSITIVE);
  lcd.setBacklight(HIGH);
  lcd.home();
}

void loop() {
  while (keypressed == NO_KEY) {
    keypressed = myKeypad.getKey();
    lcd.clear();
    myRTC.updateTime();

    // Verifica alarme
    if (myRTC.hours == A_hour && myRTC.minutes == A_minute && AlarmIsActive == 1 && myRTC.seconds >= 0 && myRTC.seconds <= 2) {
      while (keypressedx == NO_KEY) {
        tone(buzzer, 1000);
        delay(100);
        tone(buzzer, 2000);
        delay(100);
        lcd.clear();
        lcd.print("Hora de acordar!");
        keypressedx = myKeypad.getKey();
      }
    }
    keypressedx = NO_KEY;
    noTone(buzzer);

    // Exibe data e hora
    lcd.setCursor(0, 0);
    lcd.print(myRTC.dayofmonth);
    lcd.print("/");
    lcd.print(myRTC.month);
    lcd.print("/");
    lcd.print(myRTC.year);
    lcd.setCursor(0, 1);
    lcd.print(myRTC.hours);
    lcd.print(":");
    lcd.print(myRTC.minutes);
    lcd.print(":");
    lcd.print(myRTC.seconds);
    delay(100);
  }

  // Configuração de data/hora (tecla *)
  if (keypressed == '*') {
    lcd.clear();
    lcd.print(" Configuracao");
    delay(1000);
    lcd.clear();
    // Ano (4 dígitos)
    lcd.print("Ano (4 digitos)");
    char keypressed2 = myKeypad.waitForKey();
    if (isDigit(keypressed2)) { c1 = keypressed2; lcd.setCursor(0,1); lcd.print(c1); }
    char keypressed3 = myKeypad.waitForKey();
    if (isDigit(keypressed3)) { c2 = keypressed3; lcd.setCursor(1,1); lcd.print(c2); }
    char keypressed4 = myKeypad.waitForKey();
    if (isDigit(keypressed4)) { c3 = keypressed4; lcd.setCursor(2,1); lcd.print(c3); }
    char keypressed5 = myKeypad.waitForKey();
    if (isDigit(keypressed5)) { c4 = keypressed5; lcd.setCursor(3,1); lcd.print(c4); }
    i1 = (c1 - '0') * 1000;
    i2 = (c2 - '0') * 100;
    i3 = (c3 - '0') * 10;
    i4 = c4 - '0';
    int N_year = i1 + i2 + i3 + i4;
    delay(500);
    lcd.clear();

    // Mês (2 dígitos)
    lcd.print("Mes (2 digitos)");
    char keypressed6 = myKeypad.waitForKey();
    if (isDigit(keypressed6)) { c1 = keypressed6; lcd.setCursor(0,1); lcd.print(c1); }
    char keypressed7 = myKeypad.waitForKey();
    if (isDigit(keypressed7)) { c2 = keypressed7; lcd.setCursor(1,1); lcd.print(c2); }
    i1 = (c1 - '0') * 10;
    i2 = c2 - '0';
    int N_month = i1 + i2;
    delay(500);
    lcd.clear();

    // Dia (2 dígitos)
    lcd.print("Dia (2 digitos)");
    char keypressed8 = myKeypad.waitForKey();
    if (isDigit(keypressed8)) { c1 = keypressed8; lcd.setCursor(0,1); lcd.print(c1); }
    char keypressed9 = myKeypad.waitForKey();
    if (isDigit(keypressed9)) { c2 = keypressed9; lcd.setCursor(1,1); lcd.print(c2); }
    i1 = (c1 - '0') * 10;
    i2 = c2 - '0';
    int N_day = i1 + i2;
    delay(500);
    lcd.clear();

    // Hora (2 dígitos)
    lcd.print("Hora (2 digitos)");
    char keypressed10 = myKeypad.waitForKey();
    if (isDigit(keypressed10)) { c1 = keypressed10; lcd.setCursor(0,1); lcd.print(c1); }
    char keypressed11 = myKeypad.waitForKey();
    if (isDigit(keypressed11)) { c2 = keypressed11; lcd.setCursor(1,1); lcd.print(c2); }
    i1 = (c1 - '0') * 10;
    i2 = c2 - '0';
    int N_hour = i1 + i2;
    delay(500);
    lcd.clear();

    // Minutos (2 dígitos)
    lcd.print("Minutos (2 digitos)");
    char keypressed12 = myKeypad.waitForKey();
    if (isDigit(keypressed12)) { c1 = keypressed12; lcd.setCursor(0,1); lcd.print(c1); }
    char keypressed13 = myKeypad.waitForKey();
    if (isDigit(keypressed13)) { c2 = keypressed13; lcd.setCursor(1,1); lcd.print(c2); }
    i1 = (c1 - '0') * 10;
    i2 = c2 - '0';
    int N_minutes = i1 + i2;
    delay(500);
    lcd.clear();

    // Grava no RTC (segundos fixos em 0, dia da semana = 1)
    myRTC.setDS1302Time(0, N_minutes, N_hour, 1, N_day, N_month, N_year);
    keypressed = NO_KEY;
  }

  // Configuração do alarme (tecla A)
  if (keypressed == 'A') {
    lcd.clear();
    lcd.print(" Config Alarme");
    delay(1000);
    lcd.clear();
    lcd.print("Hora alarme (2 dig)");
    char keypressed14 = myKeypad.waitForKey();
    if (isDigit(keypressed14)) { c1 = keypressed14; lcd.setCursor(0,1); lcd.print(c1); }
    char keypressed15 = myKeypad.waitForKey();
    if (isDigit(keypressed15)) { c2 = keypressed15; lcd.setCursor(1,1); lcd.print(c2); }
    i1 = (c1 - '0') * 10;
    i2 = c2 - '0';
    A_hour = i1 + i2;
    delay(500);
    lcd.clear();
    lcd.print("Min alarme (2 dig)");
    char keypressed16 = myKeypad.waitForKey();
    if (isDigit(keypressed16)) { c1 = keypressed16; lcd.setCursor(0,1); lcd.print(c1); }
    char keypressed17 = myKeypad.waitForKey();
    if (isDigit(keypressed17)) { c2 = keypressed17; lcd.setCursor(1,1); lcd.print(c2); }
    i1 = (c1 - '0') * 10;
    i2 = c2 - '0';
    A_minute = i1 + i2;
    delay(500);
    lcd.clear();
    AlarmIsActive = 1;
    keypressed = NO_KEY;
  }

  // Desativar alarme (tecla B)
  if (keypressed == 'B') {
    lcd.clear();
    lcd.print("Alarme desativado");
    AlarmIsActive = 0;
    keypressed = NO_KEY;
    delay(500);
  } else {
    myRTC.updateTime();
    keypressed = NO_KEY;
  }
}

Esquemático

Espero que gostem! Qualquer dúvida, entre em contato.