Scribd
Cargar
65 vistas

TUTORIAL RTC DS3231 Con Arduino

Este documento presenta un tutorial sobre cómo configurar y usar alarmas con un módulo RTC DS1307 en Arduino. Explica cómo configurar la hora del RTC usando dos bibliotecas diferentes, RTClib y DS1307RTC. Luego, muestra cómo programar alarmas específicas usando la biblioteca TimeAlarms, a pesar de que el módulo DS1307 no tiene alarmas integradas. El código de ejemplo establece varias alarmas que imprimen mensajes a horas determinadas para demostrar su funcionamiento.

Cargado por

Pier Donne
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
65 vistas

TUTORIAL RTC DS3231 Con Arduino

Este documento presenta un tutorial sobre cómo configurar y usar alarmas con un módulo RTC DS1307 en Arduino. Explica cómo configurar la hora del RTC usando dos bibliotecas diferentes, RTClib y DS1307RTC. Luego, muestra cómo programar alarmas específicas usando la biblioteca TimeAlarms, a pesar de que el módulo DS1307 no tiene alarmas integradas. El código de ejemplo establece varias alarmas que imprimen mensajes a horas determinadas para demostrar su funcionamiento.

Cargado por

Pier Donne
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 8

Tutorial 

RTC: Parte I –


Configurar con RTClib
Parece algo sencillo e inconsecuente pero muchas veces necesitaremos tomar el tiempo o ejecutar tareas
basadas en el tiempo “real”.  Esto se refiere a la hora verdadera usada por la humanidad y no en base a un
timer que iniciamos arbitrariamente hace tantos minutos o segundos.  Para esto usamos un modulo RTC.

Requisitos:

1. Computadora (mac)
2. Arduino UNO
3. Modulo RTC DS1307
4. Breadboard
5. Arduino IDE (https://www.arduino.cc/en/Main/Software)
El modulo DS1307 RTC es este:

Arduino Tutorial Real Time Clock RTC DS1307


Este modulo debe ser programado para asignar la hora “real” humana.  Una vez se hace esto, mientras
tenga la batería CR2032 que trae atras, el modulo mantendrá la hora.

Primero lo que vamos a hacer es configurar el RTC para que obtenga la hora correcta. En este caso
obtendrá la hora de nuestra computadora.

Las conexiones son:

SDA(rtc) – Pin Analogo 4 Uno

SCL(rtc) – Pin Analogo 5 Uno

VCC(rtc) – 5V Uno

GND(rtc) – GND Uno

Al final debería verse así:

Arduino Tutorial Real Time Clock RTC


El código:
// Fecha y hora para DS1307 RTC conectado via I2C & Wire lib
#include <Wire.h>
#include "RTClib.h"
#if defined(ARDUINO_ARCH_SAMD) // para la Zero
#define Serial SerialUSB
#endif

RTC_DS1307 rtc;

void setup ()
{
while (!Serial); // para Leonardo/Micro/Zero

Serial.begin(57600);

Wire.begin();
rtc.begin();

if (! rtc.isrunning())
{
Serial.println("RTC no esta configurada!");
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

// O si prefiere configurar una hora y fecha específica:


// Enero 21, 2014 a 3am:
// rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}
}// FIN SETUP //

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

Serial.print(now.year(), DEC);
Serial.print('/');

Serial.print(now.month(), DEC);
Serial.print('/');

Serial.print(now.day(), DEC);
Serial.print(' ');

Serial.print(now.hour(), DEC);
Serial.print(':');

Serial.print(now.minute(), DEC);
Serial.print(':');

Serial.print(now.second(), DEC);
Serial.println();

Serial.print(" desde medianoche 1/1/1970 = ");

Serial.print(now.unixtime());
Serial.print("s = ");

Serial.print(now.unixtime() / 86400L);
Serial.println("d");

// calcular una ida 7 días y 30 segundos en el futuro


DateTime future (now.unixtime() + 7 * 86400L + 30);
Serial.print(" now + 7d + 30s: ");
Serial.print(future.year(), DEC);
Serial.print('/');

Serial.print(future.month(), DEC);
Serial.print('/');

Serial.print(future.day(), DEC);
Serial.print(' ');
Serial.print(future.hour(), DEC);
Serial.print(':');

Serial.print(future.minute(), DEC);
Serial.print(':');

Serial.print(future.second(), DEC);

Serial.println();
Serial.println();

delay(3000);
}

Ese proyecto se puede ver aquí:

Arduino Tutorial RTC


 Para mayor información sobre este modulo, podemos estudiar esta referencia:

http://www.elecrow.com/wiki/index.php?title=Tiny_RTC
Veamos que utilidad le podemos dar a esto.  En la siguiente parte analizamos el uso de las alarmas!

Parte II – Configurar con DS1307RTC


En esta parte utilizamos una librería distinta, la DS1307RTC en lugar de la RTClib.  Primero haremos lo
mismo, configurar la hora en nuestro modulo RTC.

Requisitos:

Computadora (mac)

1. Arduino UNO
2. Modulo RTC DS1307
3. Breadboard
4. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Arduino Tutorial Real Time Clock RTC DS1307


El código:

#include <Wire.h>
#include <Time.h>
#include <DS1307RTC.h>
 
const char *monthName[12] = {
 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
 
tmElements_t tm;
 
void setup()
{
 Serial.begin(9600);

 bool parse=false;
 bool config=false;
 
 // obtener fecha de computadora
 
if (getDate(__DATE__) &amp;&amp; getTime(__TIME__))
{
 parse = true;

 // configurar la fecha y hora al rtc


 if (RTC.write(tm))
{
 config = true;
  }
 }
 
 Serial.begin(9600);

 while (!Serial) ; // Esperar al Arduino Serial Monitor


 delay(200);

 if (parse &amp;&amp; config)


{
 Serial.print("DS1307 Hora configurada=");
 Serial.print(__TIME__);
 Serial.print(", Fecha=");
 Serial.println(__DATE__);
 }
else if (parse)
{
 Serial.println("DS1307 Error de Comunicacion:-{");
 Serial.println("Por favor revisar sus conexiones");
  }
else
{
 Serial.print("No se pudo interpretar info del compilador, Hora=\"");
 Serial.print(__TIME__);
 Serial.print("\", Fecha=\"");
 Serial.print(__DATE__);
 Serial.println("\"");
 }
}
 
void loop()
{
}
 
bool getTime(const char *str)
{
 int Hour, Min, Sec;
 
 if (sscanf(str, "%d:%d:%d", &amp;Hour, &amp;Min, &amp;Sec) != 3) return false;

 tm.Hour = Hour;
 tm.Minute = Min;
 tm.Second = Sec;

 return true;
}
 
bool getDate(const char *str)
{
 char Month[12];
 int Day, Year;

 uint8_t monthIndex;
 
 if (sscanf(str, "%s %d %d", Month, &amp;Day, &amp;Year) != 3) return false;

 for (monthIndex = 0; monthIndex &lt; 12; monthIndex++)


{
  if (strcmp(Month, monthName[monthIndex]) == 0) break;
 }

  if (monthIndex &gt;= 12) return false;

 tm.Day = Day;
 tm.Month = monthIndex + 1;
 tm.Year = CalendarYrToTm(Year);

 return true;
}

Ya tenemos a nuestra disposición 2 distintas librerías para lograr lo mismo.  Recordemos que las librerías
son archivos de código que toman las instrucciones de nivel mas bajo que utilizan los modelos y sensores
y los convierten en funciones y valores fáciles de entender a los humanos.

Es decir, recordemos que nuestros sensores lo único que interpretan son corrientes y los distintos tipos.
Estas corrientes se traducen a bits y bytes que producen senales binarias de 0 y 1, que son interpretadas
por los distintos chips.  Las librerías hacen un interfaz a este nivel mas bajo y funcionan como traductor.
Las librerías toman los comandos que nosotros queremos enviar (medir intensidad de luz, medir gas CO,
almacenar datos en SD, cual es la hora actual) y convierten esos comandos en lenguaje binario y
corrientes que los electrónicos pueden entender.  Así mismo cuando los electrónicos contestan con
corrientes, las convierten en lenguaje binario y luego en funciones con resultados que nosotros podamos
entender.

Ok, podemos almacenar la hora en un modulo operado por su propia batería.  Esto es lo mismo que hace
una computadora para almacenar la hora que siempre tiene aunque nosotros apaguemos la computadora al
final del dia.

Veamos el uso que podemos darle a tener esta hora referencia para usar alarmas.

Tutorial RTC: Parte III – Alarmas


En esta parte utilizamos un DS1307 para disparar alarmas.  Las alarmas son muy útiles para realizar
tareas en momentos específicos.  Algunos módulos de RTC traen alarmas incorporadas como el DS3231
y otros.  Pero el modulo DS1307 no trae alarmas incorporadas.  Es decir que solo puede llevar la hora
pero no configurar y disparar alarmas cuando se le programe.  Para eso usaremos ayuda de las librerías
Time y TimeAlarms.

Requisitos:

Computadora (mac)

1. Arduino UNO
2. Modulo RTC DS1307
3. Breadboard
4. Arduino IDE (https://www.arduino.cc/en/Main/Software)
5.
Arduino Tutorial Real Time Clock RTC DS1307

El código:

1 /** RTC Alarms without DS3231 without powering down */


#include <Wire.h>
2
#include "RTClib.h"
3 #include <Time.h>
4 #include <TimeAlarms.h>
5 RTC_DS1307 rtc;
6  
7 void setup(){
 Serial.begin(9600);
8  Wire.begin();
9  rtc.begin();
10  if (! rtc.isrunning()) {
11  Serial.println("RTC is NOT running!");
 //rtc.adjust(DateTime(__DATE__, __TIME__));
12  Serial.print("time set auto");
13  }
14   
15   
16  //setTime(8,29,0,1,1,11); // Fecha Saturday 8:29:00am Jan 1 2011
17  DateTime now = rtc.now();
18  setTime(now.hour(), now.minute(), now.second(), now.month(), now.day(), now.year());
 // create the alarms
19  // Crear alarmas
20  Alarm.alarmRepeat(16,35,0, MorningAlarm); // 8:00am every day
21  Alarm.alarmRepeat(16,50,0,EveningAlarm); // 4:00pm every day
22  Alarm.alarmRepeat(17,05,0,EveningAlarm); // 1:00am every day
23  //Alarm.alarmRepeat(dowSaturday,8,30,30,WeeklyAlarm); // 8:30:30 every Saturday
 //Alarm.timerRepeat(15, Repeats); // timer for every 15 seconds
24  //Alarm.timerOnce(10, OnceOnly); // called once after 10 seconds
25  Serial.print("Alarms listas!");
26 }
27  
28 void loop(){
29  digitalClockDisplay();
 Alarm.delay(1000); // esperar 1 segundo entre displays
30 }
31  
32 // Funciones de Alarma:
33 void MorningAlarm(){
34  Serial.println("Alarm: - read CO/V & post to web");
}
35
36  
void EveningAlarm(){
37  Serial.println("Alarm: - read CO/V & post to web");
38 }
39  
40 void DawnAlarm(){
41  Serial.println("Alarm: - read CO/V & post to web");
}
42
 
43 void WeeklyAlarm(){
44  Serial.println("Alarm: - its Monday Morning");
45 }
46  
47 void ExplicitAlarm(){
 Serial.println("Alarm: - this triggers only at the given date and time");
48
}
49
 
50 void Repeats(){
51  Serial.println("15 second timer");
52 }
53  
54 void OnceOnly(){
 Serial.println("This timer only triggers once");
55 }
56  
57 void digitalClockDisplay()
58 {
59  // digital clock display of the time
60  Serial.print(hour());
 printDigits(minute());
61  printDigits(second());
62  Serial.println();
63 }
64  
65 void printDigits(int digits)
66 {
 Serial.print(":");
67  if(digits < 10)
68  Serial.print('0');
69  Serial.print(digits);
}

Veamos este proyecto.  Estamos usando las librerías de Time & TimeAlarms para crear alarmas y
forrajear fechas y hora.

Primero, tenemos la opción de programar una hora específica al modulo en lugar de leer la del
computador.  La linea para asignar la hora del computador como vimos anteriormente, esta comentada.

Segundo, creamos 5 alarmas.  Una es para las 8:30am y otra para las 5:45pm todos los días.  La otra es
una alarma solo para los días Sábados a las 8:30am.  Las ultimas dos son timers donde uno se repite cada
15 segundos y el otro se dispara a los 10 segundos una única vez.

Finalemente los últimos 2 métodos solo imprimen la hora actual (en base a la referencia creada) en el
Monitor Serial.

Las alarmas son útiles para realizar ciertas tareas en cierto tiempo.  Si, también se puede usar una alarma
como una función integra de un proyecto Arduino tipo Reloj despertador”.  Pero aun mas util es usarlas
para hacer que nuestro proyecto utilice menos energía.  Como veremos en el uso del modulo DS3231, se
puede hacer dormir la UNO completa y hacer que el RTC DS3231 guarde su hora y según la alarma
deseada, mande un pulso a la UNO para que aquella despierte a cierta hora todos los días y tome
muestras.  Esto hace que el consumo energético de nuestro proyecto sea mucho menor y así
incrementamos su autonomía.

Si quisiéramos ahorrar energía tendríamos que apagar la Arduino lo cual se puede lograr con el Internal
WatchDog Timer (WDT) o usando la librería LowPower.  Aprenderemos a hacer esto en el siguiente
tutorial.

También podría gustarte