En este proyecto, diseñamos un reloj en tiempo real basado en Arduino con alarma. Un reloj de tiempo real o RTC es un reloj a batería que mide el tiempo incluso cuando no hay energía externa o el microcontrolador está reprogramado.

Un RTC muestra el reloj y el calendario con todas las funciones de indicación de la hora. La batería, que está conectada al RTC, es independiente y no está relacionada ni conectada a la fuente de alimentación principal.

Cuando se restablece la energía, el RTC muestra el tiempo real independientemente de la duración de la desconexión. Estos relojes de tiempo real se encuentran comúnmente en las computadoras y, a menudo, se denominan simplemente CMOS (semiconductor de óxido de metal complementario).

La mayoría de los microcontroladores y microprocesadores tienen temporizadores integrados para mantener el tiempo. Pero solo funcionan cuando el microcontrolador está conectado a la fuente de alimentación.

Cuando se enciende la alimentación, los temporizadores internos se restablecen a 0. Por lo tanto, se incluye un chip RTC separado en aplicaciones como los registradores de datos, por ejemplo, que no se restablece a 0 cuando se apaga o se restablece la alimentación.

Los relojes de tiempo real a menudo son útiles en aplicaciones de registro de datos, marcas de tiempo, alarmas, temporizadores, compilaciones de reloj, etc. En este proyecto, se diseña un reloj de tiempo real, que muestra la hora y la fecha precisas junto con una función de alarma.

Uno de los circuitos integrados RTC DS1307 de uso frecuente se utiliza en este proyecto junto con Arduino. El circuito, el diseño y el funcionamiento se explican en las siguientes secciones.

Diagrama de circuito

Componentes requeridos

• Arduino UNO
• Módulo DS 1307 RTC
• Botones pulsadores
• Pantalla LCD 16X2
• Zumbador
• 10 KΩ – 2
• BOTE DE 10 KΩ
• Protoboard

Diseño de circuito

La comunicación entre el microcontrolador y el RTC IC DS1307 es un bus bidireccional I2C en serie. El protocolo I2C es un método de comunicación entre un dispositivo más rápido (Microcontrolador o Arduino en este caso) en modo maestro y un dispositivo más lento (RTC) en modo esclavo.

Hay dos pines en Arduino para la comunicación I2C. Los pines analógicos 4 y 5 actuarán como SDA (datos en serie) y SCL (reloj en serie).

Estos están conectados a los respectivos pines SDA y SCL de RTC. Ambos pines de RTC se elevan usando resistencias de 10KΩ.

Se utiliza una pantalla LCD para mostrar el reloj. Se deben conectar 6 pines de LCD a Arduino. RS, E, D4, D5, D6 y D7 (pines 4, 6, 11, 12, 13 y 14) de la pantalla LCD están conectados a los pines 2, 3, 4, 5, 6 y 7 de Arduino.

Se utilizan tres botones para configurar la alarma. Estos botones están conectados a los pines 8, 9 y 10 de Arduino. Un zumbador está conectado al pin 11 de Arduino que actúa como alarma.

Código

#include <Wire.h>
#include <EEPROM.h>
#include <RTClib.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd (2, 3, 4, 5, 6, 7); 
RTC_DS1307 RTC;
int tmp, Inc, hor, mIn, add = 11; 
int conjunto = 8;  
int cge = 9;   
int mod = 10; 
int off = 0;
#define buz 11 
int Hor, Min, Sec; 
/////////////////////////////////////// Función para ajustar la hora ////// //////////////////////////////
tiempo vacío ()                             
{
    int tmp = 1, minutos = 0, horas = 0, segundos = 0;
    mientras (tmp == 1)
    {
     apagado = 0;
     si (digitalRead (cge) == 0)
     {
      Hor ++;
      si (Hor == 24)
      {
       Hor = 0;
      }
     }
     lcd.clear ();
     lcd.setCursor (0,0);
     lcd.print ("Establecer hora de alarma");

    lcd.setCursor (0,1);
    si (Hor <= 9)
    lcd.print ("0");
    lcd.print (Hor);
    lcd.print (":");
    lcd.print (Min);
    lcd.print (":");
    lcd.print (seg.);
    retraso (200);
    lcd.setCursor (0,1);
    lcd.print ("");
    lcd.print (":");
    lcd.print (Min);
    lcd.print (":");
    lcd.print (seg.);
    retraso (200);
    si (digitalRead (conjunto) == 0)
    {
      hor = Hor;
      EEPROM.write (agregar ++, hor);
     tmp = 2;
     while (digitalRead (conjunto) == 0);
    }
    }
    
    mientras (tmp == 2)
    {
     si (digitalRead (cge) == 0)
     {
      Min ++;
      si (Min == 60)
      {Mín = 0;}
     }
    lcd.setCursor (0,1);
    lcd.print (Hor);
    lcd.print (":");
     si (Min <= 9)
    lcd.print ("0");
    lcd.print (Min);
    lcd.print (":");
    lcd.print (seg.);
    lcd.print ("");
    retraso (200);
     lcd.setCursor (0,1);
    lcd.print (Hor);
    lcd.print (":");
    lcd.print ("");
    lcd.print (":");
    lcd.print (seg.);
    lcd.print ("");
    retraso (200);
      si (digitalRead (conjunto) == 0)
      {
       mIn = Min;
       EEPROM.write (agregar ++, mIn);
       tmp = 0;
       while (digitalRead (conjunto) == 0);
      }
    }
    apagado = 1;
    retraso (10);
}
/////////////////////////////////////////// función para hacer sonar el zumbador // ////////////////////////////////////
vacío Buz ()
{
  si (digitalRead (conjunto) == 0)
  apagado = 0;
  si (apagado == 1)
  {
   digitalWrite (buz, ALTO);
   retraso (500);
  
   digitalWrite (buz, BAJO);
   retraso (500);
  }
}
////////////////////////////////////////// Función para comparar la hora de la alarma con la actual Hora RTC ////////////////////
void TimeCheck ()
{
  int tem [17];
  para (int i = 11; i <17; i ++)
  {
    tem [i] = EEPROM.read (i);
  }
  if (Hor == tem [11] && Min == tem [12] && off == 1) 
  {
   sumar = 11;
   Buz ();
   Buz ();
   lcd.clear ();
   lcd.print ("alarma ...........");
   lcd.setCursor (0,1);
   lcd.print ("........... alarma");
   Buz ();
   Buz ();
    }
}
//////////////////////////////////////////////////// //////////preparar///////////////////////////
configuración vacía ()
{
 Wire.begin ();
 RTC.begin ();
 lcd.begin (16,2);
 pinMode (cge, ENTRADA);
 pinMode (conjunto, ENTRADA);
 pinMode (mod, ENTRADA);
 pinMode (buz, SALIDA);
 digitalWrite (establecido, ALTO);
 digitalWrite (mod, ALTA);
 escritura digital (cge, ALTA);
 
   lcd.setCursor (0,0);
   lcd.print ("CENTRO ELECTRÓNICO");
   lcd.setCursor (0,1);
   lcd.print ("Reloj despertador");
   retraso (2000);
    
 if (! RTC.isrunning ())
 {
 RTC.adjust (DateTime (__ DATE __, __ TIME__));
 }
}
//////////////////////////////////////////////////// //////////lazo/////////////////////////////////////
bucle vacío ()
{
   DateTime ahora = RTC.now ();
   si (digitalRead (mod) == 0)      
   { 
    Actual();
    hora();
    retraso (1000);
    lcd.clear ();
    lcd.setCursor (0,0);
    lcd.print ("Alarma activada");
    retraso (2000);
   }
 lcd.clear ();
 lcd.setCursor (0,0);
 lcd.print ("Hora:");
 lcd.setCursor (6,0);
 Hor = ahora.hora (), DEC; 
 si (Hor <= 9)
 {
  lcd.print ("0");
  lcd.print (Hor = ahora.hora (), DEC);
 }
 más
 lcd.print (Hor = ahora.hora (), DEC);
 lcd.print (":");
 Min = ahora.minuto (), DEC;
 si (Min <= 9)
 {
 lcd.print ("0");
 lcd.print (Min = ahora.minuto (), DEC);
 }
 más
 lcd.print (Min = ahora.minuto (), DEC);
 
 lcd.print (":");
 Sec = ahora.segundo (), DEC;
 si (Sec <= 9)
 {
  lcd.print ("0");
  lcd.print (Sec = ahora.segundo (), DEC);
 }
 más
 lcd.print (Sec = ahora.segundo (), DEC);
 lcd.setCursor (0,1);
 lcd.print ("Fecha:");
 lcd.print (ahora.día (), DEC);
 lcd.print ("/");
 lcd.print (ahora.mes (), DEC);
 lcd.print ("/");
 lcd.print (ahora.año (), DEC);
 Chequeo de tiempo();
 retraso (200);
}
//////////////////////////////////////////////////// ///// función para obtener el tiempo RTC actual ////////////////////////////////
corriente nula ()
{
  lcd.setCursor (0,1);
  lcd.print (Hor);
  lcd.print (":");
  lcd.print (Min);
  lcd.print (":");
  lcd.print (seg.);
}