Cómo hacer un reloj digital usando el módulo RTC y Arduino Uno
¿Qué es el módulo RTC?
Este es el módulo de reloj en tiempo real que guarda los datos de tiempo y fecha y también los muestra en la pantalla de visualización conectada. Este módulo mantiene la hora y la fecha actualizada y tiene un oscilador de cristal que genera una señal a una frecuencia constante. Además, el módulo RTC tiene pines dedicados del sensor de temperatura en su parte posterior y hay un pin especial que lee la salida del sensor.
El módulo también viene con una batería de iones de litio de 3V que mantiene el módulo en funcionamiento durante bastante tiempo si el suministro principal está desconectado.
Hay 7 pines del módulo en total, pero en el lado opuesto tiene los mismos 5 pines para que pueda soldar los encabezados en cualquiera de los ambos lados si hay batería colocada en la parte posterior del módulo y usted no se T quiere usar el pin SQ del módulo RTC. La siguiente tabla muestra los pines del módulo RTC:
| Patas | Descripción |
|---|---|
| 1- (SQ) | Pin para generar la onda cuadrada |
| 2- (DS) | Pin que lee la salida del sensor de temperatura (DS18B20) si se instala en el RTC |
| 2- (SCL) | Pin de reloj para el Arduino |
| 4- (SDA) | Pin de datos para el Arduino |
| 5- (VCC) | Pin para suministrar el voltaje al módulo |
| 6- (GND) | Pin para conectar el módulo |
| 7- (murciélago) | Pin para conectar la batería externa como respaldo |
Hacer un reloj digital usando RTC con Arduino Uno
Para diseñar reloj en tiempo real, requerirá los siguientes componentes:
- Arduino Uno
- Cables de jersey
- Módulo de reloj en tiempo real (DS 1307)
- Lcd
- Potenciómetro
- Tablero de circuitos
El esquema del circuito para el reloj digital utilizando el módulo RTC se proporciona a continuación . Aquí en el esquema hemos utilizado el chip integrado DS (1307) que es casi similar al módulo DS3231.
Ensamblaje de hardware del reloj digital con RTC
También hemos implementado el circuito de reloj digital en el hardware de tal manera que primero hemos colocado todos los componentes en la placa de pan. A continuación, hemos utilizado los cables de conexión para la interfaz de los componentes con el Arduino. Hemos publicado una imagen del conjunto de hardware del circuito en el que los cables azules son los pasadores de datos de la pantalla LCD conectada a Arduino. El cable amarillo está conectado con un potenciómetro para el ajuste de contraste. Además, los cables grises son los pasadores de reloj y datos del módulo RTC conectado con Arduino.
Instalación de la biblioteca de RTC
Para interactuar el módulo RTC con Arduino primero tenemos que descargar la biblioteca del módulo RTC. Primero debe abrir el gerente de la biblioteca del Arduino IDE y después de eso escribir la palabra clave rtclib en la barra de búsqueda del administrador de la biblioteca. A continuación tienes que encontrar el Rtclib por adfruit y luego haga clic en el icono de instalación en azul para instalar la biblioteca.
Cuando hacemos clic en el botón "Instalar", aparece un nuevo cuadro de diálogo para confirmación, por lo que tenemos que hacer clic en el icono "Instalar todo".
Código Arduino para reloj digital usando RTC
El código para crear un reloj en tiempo real usando Arduino es:
#include "rtclib.h "// Definición de la biblioteca para el módulo RTC
#Include // Definición de la biblioteca para la pantalla LCD
LiquidCrystal LCD (12, 11, 5, 4, 3, 2); // Asignación de pines Arduino para la LCD
RTC_DS3231 RTC; // Declarando el módulo RTC
Void actualingrtc () // función para actualizar el RTC por primera vez
lcd.setCursor (0, 0); // Establecer el lugar para que se muestren los datos
lcd.Imprimir ("Actualización ..."); // Mostrando los datos
// pedirle al usuario que ingrese a nuevas fecha y hora
const char txt [6] [15] = "año", "mes", "día",
"hora", "minutos", "segundos";
Cadena str = ""; // Creando una cadena
Long rtc_array [6]; // Definición de una variable para almacenar los datos de entrada
mientras (en serie.disponible())
De serie.leer(); // Lectura de la entrada en serie
para (int i = 0; i < 6; i++) // loop for taking 6 inputs form the user
De serie.imprimir ("actual"); // Mostrar los datos en la serie
De serie.imprimir (txt [i]);
De serie.imprimir(": ");
mientras (!De serie.disponible())
// verificar si hay información del usuario
str = serial.readString (); // leyendo la cadena de entrada
Rtc_array [i] = str.toint (); // Convertir la entrada del usuario al número y guardarla en una matriz
De serie.println (rtc_array [i]); // Impresión de la entrada del usuario en serie
// Actualización del RTC por la entrada del usuario
RTC.Ajustar (DateTime (RTC_Array [0], RTC_Array [1], RTC_Array [2], RTC_Array [3], RTC_Array [4], RTC_Array [5]));
De serie.println ("La hora y la fecha se actualizan");
Void displayUpdate () // función para actualizar la visualización de LCD
// Creación y matriz para convertir el dígito en palabras que comienzan de 0 a 6
const char dayinwords [7] [4] = "sol", "mon", "martes", "casado", "thu", "fri", "sat";
// Convertir los dígitos meses en palabras que comienzan de 1 a 12
const char messwords [13] [4] = "", "Jan", "feb", "mar", "abr", "mayer", "jun", "jul", "agu", "sep", "Oct", "Nov", "dec";
// Hora y fecha de lectura y guardándolos en variables
DateTime RTCTIME = RTC.ahora();
int sec = rtctime.segundo (); // segundos
int mins = rtctime.minuto (); // minutos
int hrs = rtctime.docehour (); // horas
int day = rtctime.dayoftheweek (); // día en palabra
int dd = rtctime.día (); // Día en número
int mth = rtctime.mes (); // mes
int Yr = rtctime.año (); // año
lcd.setCursor (0, 0);/ *Establecer el lugar para mostrar la fecha y el día de la semana con palabras */
// Mostrar la fecha en formato DD-MM-YYYY y días de semana
if (dd < 10) lcd.print("0");
lcd.imprimir (dd);
lcd.imprimir("-");
lcd.imprimir (MonthInwords [MTH]);
lcd.imprimir("-");
lcd.imprimir (año);
lcd.imprimir(" ");
lcd.imprimir (DayInwords [día]);
lcd.setCursor (0, 1);/ *Configuración del lugar para mostrar la hora */
// mostrando la hora en LCD
if (hrs < 10) lcd.print("0");
lcd.imprimir (hrs);
lcd.imprimir(':');
if (mins < 10) lcd.print("0");
lcd.imprimir (mins);
lcd.imprimir(':');
if (sec < 10) lcd.print("0");
lcd.imprimir (sec);
if (rtctime.ispm ()) lcd.imprimir ("pm"); // Mostrar AM/PM
else LCD.imprimir ("AM");
Configuración vacía ()
De serie.comenzar (9600); // Inicializar la comunicación en serie
lcd.comenzar (16,2); // Inicializando la pantalla LCD
RTC.comenzar(); // Inicializando el módulo RTC
bucle vacío ()
DisplayUpdate (); // llamando a la función para actualizar la LCD
if (serial.disponible ()) // Comprobación si hay alguna entrada del usuario
Entrada de char = serie.leer (); // Leer la entrada del usuario
if (input == 'r') updatingRtc (); // Si r es la entrada dada llamada la función de actualización para RTC
El código Arduino para hacer un reloj se compila de tal manera que primero hemos definido la biblioteca para el módulo RTC. Después de eso, definimos la biblioteca para la pantalla LCD y asignamos los pines de Arduino a LCD y declaramos que para usar funciones del RTC usaremos la palabra clave RTC.
Hemos creado dos funciones, una para actualizar el módulo RTC cuando está conectado por primera vez y la otra función para actualizar la LCD.
En el actualingrtc Función Primero hemos declarado un personaje para la fecha y hora de la semana y creamos una cadena vacía en la que se almacenará todas las entradas del usuario. Dado que se requieren 6 entradas del usuario para actualizar la hora y la fecha, hemos utilizado un bucle for para obtener la entrada del usuario utilizando el monitor serial de Arduino IDE.
A continuación hemos usado el RTC.ajustar() función para guardar la fecha y hora actuales en el módulo RTC.
Viniendo al DisplayUpdate () Función Al principio, hemos convertido la entrada de números para los días de la semana y el mes del año en la entrada del personaje y luego definimos el formato para la fecha que es DD-MM-YYYY.
A continuación, hemos mostrado la fecha y la hora en el LCD utilizando el lcd.imprimir() función.
En la función de configuración después de inicializar la comunicación en serie, los módulos RTC y LCD se inicializan utilizando la función BEGIN.
Del mismo modo, llegando a la función de bucle, la primera DisplayUpdate () Se llama función que muestra la fecha y hora guardadas actuales en el módulo RTC. Para actualizar la fecha y la hora que hemos usado y si se condiciona cuando el El carácter R se ingresa como una entrada en serie Luego llame a la función ActualatingRTC y actualice la fecha y hora del módulo.
Recuerde que el módulo RTC guarda la hora y la fecha dada la primera vez y sigue actualizando esa fecha y hora, incluso si el suministro se apaga porque tiene una batería incorporada que mantiene el módulo en funcionamiento. Por lo tanto, la entrada de fecha y hora se da solo por primera vez y mantiene el registro del tiempo hasta que se cambia manualmente.
Implementación de hardware para reloj digital utilizando RTC con Arduino Uno
Para actualizar la hora y la fecha, tenemos que ingresar al carácter "R" en el monitor en serie presionando CTRL+Ingrese y el código Arduino requerirá los datos para la fecha y hora actuales. Hemos publicado la imagen a continuación para que pueda ser una imagen clara de las entradas requeridas:
Después de haber ingresado todos los datos, el programa indicará que el módulo RTC está actualizado. Al actualizar la hora y la fecha en que la LCD mostrará que RTC se está actualizando:
Una vez que haya actualizado la fecha y la hora, se mostrará en LCD:
Conclusión
El tablero Arduino Uno es una forma avanzada de un microcontrolador que ha facilitado la interfaz de dispositivos con microcontroladores. Usando Arduino Uno podemos construir diferentes variedades de proyectos. En este artículo, hemos diseñado un reloj en tiempo real utilizando el módulo RTC y el procedimiento se explica brevemente con la ayuda del código Arduino y la simulación.