Reloj digital en tiempo real

ChronoDot RTC v2.1

En el proyecto de hoy vamos a trabajar con un reloj digital en tiempo real, más conocido como RTC por sus siglas en inglés (Real Time Clock).

Lo primero es comentar que utilizaré el reloj ChronoDot RTC v2.1 de Macetech, basado en el integrado DS3231 del mismo fabricante. ¿Por qué este modelo y no otro? Bueno, pues por diversos motivos:

  • Es pequeño.
  • Se puede conectar fácilmente a una protoboard gracias a sus pines diseñados a tal efecto.
  • Incluye un conector para una pila CR1632, que le ofrece una autonomía de hasta 8 años.
  • La interfaz I2C que utiliza es compatible con las versiones anteriores del circuito (como la DS1307), por lo que podemos reutilizar código sin modificarlo.
  • El chip DS3231 tiene un sistema de compensación de temperatura que lo convierte en un reloj de alta precisión.
  • Y por último y no menos importante. Porque no tenía ningún motivo para desechar este modelo. Hace lo que quiero y lo hace perfectamente.

¿Por qué decimos que es un reloj en “tiempo real”?. Para entender dicho concepto debemos saber como funciona internamente nuestro reloj. Básicamente, el funcionamiento del DS3231 se basa en un cristal interno y una serie de condensadores. Midiendo de manera continua la temperatura del cristal, los condensadores se ajustan para que la frecuencia generada sea estable. Es por ello que hablamos de tiempo real, porque la señal en la que nos basamos para contar la hora, es generada y ajustada de forma constante. Si alguien quiere conocer en profundidad el funcionamiento y las especificaciones técnicas del DS3231, aquí encontrará el datasheet correspondiente.

Chronodot v2.1 - Vista inferior

Montando el circuito

Como a este ChronoDot no hay que realizarle ninguna modificación ni ninguna soldadura, podemos conectarlo directamente a nuestro Arduino. Solo debemos tener en cuenta una cosa. La pila que le pongamos a nuestro reloj podrá mantener la hora siempre y cuando la interfaz I2C tenga alimentación al ser utilizada. O lo que es lo mismo, si al ejecutar el proyecto no le proporcionamos alimentación al ChronoDot mediante el pin Vcc, el reloj utilizará la de la pila, por lo que esta se agotará rápidamente. Dicho esto, pasemos a la acción.

Chronodot v2.1 - Vista superior

Para montar el circuito de este proyecto necesitaremos los siguientes componentes:

  • 1 ChronoDot.
  • 1 Arduino UNO R3.
  • Cables.
  • 1 Protoboard.

Una vez tenemos los componentes necesarios, debemos seguir los pasos siguientes:

1 – Conectamos la alimentación y la tierra a la protoboard.

2 – Llevamos 5v al pin Vcc del ChronoDot y la tierra al pin marcado como GND.

3 – A continuación, unimos el pin SDA del reloj al A4 de nuestro Arduino.

4 – Y por último, conectamos el pin SCL al A5 del Arduino.

Terminado de montar el circuito, deberíamos de tener algo parecido a lo mostrado en la siguiente figura.

Reloj digital en tiempo real - Diseño de protoboard

El esquema eléctrico correspondiente sería:

Reloj digital en tiempo real - Esquema de conexiones

El código

Comencemos por comentar paso a paso el código fuente que hará funcionar nuestro proyecto.

Antes de empezar a introducir código, debemos descargar la librería RTClib desde GitHub, la cual nos facilitará mucho el manejo de nuestro ChronoDot. Ha sido escrita por mizraith y está actualizada para ser compatible con el DS3231 y el ChronoDot de Macetech.

Una vez descargadas las librerías e incluidas en nuestro IDE de Arduino, las importamos y creamos una instancia del reloj.

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

//Instancia del reloj.
RTC_DS3231 RTC;

Dentro de la función setup(), empezaremos estableciendo la velocidad de la comunicación y abriendo las conexiones con el reloj.

void setup()  {
  
  Serial.begin(9600);
  
  //--------RTC SETUP ------------
  Wire.begin();
  RTC.begin();

A continuación, comprobamos que el ChronoDot esté funcionando. De estarlo, cogemos como fecha y hora aquella en la que el programa fue compilado. Si no le hemos puesto una pila a nuestro ChronoDot, tendremos que compilar el programa y cargarlo en nuestro Arduino cada vez que queramos hacerlo funcionar. Ya que de lo contrario, nos aparecerá la hora y la fecha en la que se ejecutó por última vez.

  if (! RTC.isrunning()) {
  Serial.println("El RTC no esta funcionando!");
  //Cogemos como fecha y hora aquella en la que el programa fue compilado.
  RTC.adjust(DateTime(__DATE__, __TIME__));
  }

Lo que haremos a continuación será coger la fecha y la hora actual de nuestro reloj y compararla con la correspondiente a la compilación del programa, de esta manera comprobaremos que nuestro reloj tiene una fecha más reciente. De no ser así, actualizaremos la hora de nuestro ChronoDot.

  //Cogemos la fecha y la hora del reloj.
  DateTime now = RTC.now();  
  
  //Cogemos la hora en que compilamos el programa.
  DateTime compiled = DateTime(__DATE__, __TIME__);
  
  if (now.unixtime() < compiled.unixtime()) {
    Serial.println("La hora del RTC es mas antigua que la compilacion!  Actualizando...");
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }
           
}//Fin de la funcion setup.

Ahora el siguiente paso es crear la función loop().

Dentro de esta función lo primero que vamos a hacer es coger la fecha y la hora actual de nuestro reloj.

void loop()
{

  DateTime now = RTC.now();

A continuación, mostramos los datos recogidos en un formato más agradable y legible para nosotros. Yo he optado por el típico de barras y puntos, pero aquí cada uno (como todo en la vida) es libre de adaptarlo a sus necesidades y gustos.

  Serial.print(now.day());
  Serial.print('/');
  Serial.print(now.month());
  Serial.print('/');
  Serial.print(now.year());
  Serial.print(' ');
  
  Serial.print(now.hour());
  Serial.print(':');
  Serial.print(now.minute());
  Serial.print(':');
  Serial.print(now.second());
  Serial.println();

Ya por último dejamos pasar cinco segundos entre línea y línea de datos. Igual que en el caso anterior, va a gustos y necesidades.

  Serial.println();
  delay(5000);
    
}//Fin de la funcion loop.

Puesta en marcha

Poner en marcha el circuito es muy sencillo. Una vez hechas las conexiones, compilamos el programa, lo cargamos en nuestro Arduino y observamos en el monitor serie los datos que nos muestra. La siguiente imagen muestra el resultado obtenido.

Salida de datos por el monitor serie.

Conclusión

Con este proyecto hemos aprendido que es y como funciona un ChronoDot. El programa escrito en este artículo es una versión sencilla, una forma simple pero eficaz para un primer contacto con un reloj en tiempo real. Se ha utilizado la versión DS3231 de Macetech, pero en el mercado hay muchos otros modelos a escoger.

No hemos utilizado todas las funcionalidades del reloj ni de las librerías. Pero para el que quiera profundizar, puede ir a la documentación de Macetech disponible aquí, y/o a las librerías escritas por mizraith que están disponibles en GitHub.

Ver la hora y la fecha en el terminal serie no está mal, pero tampoco es que sea muy bonito, así que… ¿y si mostramos la hora en dos matrices de leds? Podríamos aprovechar lo que aprendimos en el artículo de las matrices y así crear un reloj digital con un poco de cara y ojos. ¿Quién se anima?

 

Espero que os haya gustado.

Un saludo y muchas gracias por leer este artículo.  ^_^

 

Referencias

  • Documentación del ChronoDot v2.0 de Macetech aquí.
  • Librería RTClib de mizraith aquí.
  • Las fotografías del ChronoDot son cortesía de Adafruit.com

Descargas

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s