Come fare un orologio digitale usando il modulo RTC e Arduino Uno
Cos'è il modulo RTC
Questo è il modulo di clock in tempo reale che salva i dati di tempo e data e lo visualizza anche nella schermata di visualizzazione connessa. Questo modulo mantiene aggiornati l'ora e la data e ha un oscillatore di cristalli che genera un segnale a una frequenza costante. Inoltre, il modulo RTC ha pin dedicati del sensore di temperatura sul lato posteriore e c'è un pin speciale che legge l'uscita del sensore.
Il modulo viene fornito anche con una batteria agli ioni di litio da 3 V che mantiene in funzione il modulo per un po 'di tempo se l'alimentazione principale è disconnessa.
Ci sono 7 pin del modulo in totale, ma sul lato opposto ha ottenuto gli stessi 5 pin in modo da poter saldare le intestazioni su uno dei lati entrambi se c'è una batteria posizionata sul retro del modulo e non T Vuoi utilizzare il pin Sq del modulo RTC. La tabella seguente mostra i pin del modulo RTC:
| Pin | Descrizione |
|---|---|
| 1- (SQ) | Pin per generare l'onda quadrata |
| 2- (DS) | PIN che legge l'uscita del sensore di temperatura (DS18B20) se installato su RTC |
| 2- (SCL) | Pin dell'orologio per l'Arduino |
| 4- (SDA) | Pin di dati per Arduino |
| 5- (VCC) | Pin per fornire la tensione al modulo |
| 6- (GND) | Pin per mettere a terra il modulo |
| 7- (BAT) | Pin per collegare la batteria esterna come backup |
Creare un orologio digitale usando RTC con Arduino Uno
Per progettare un orologio in tempo reale, richiederai i seguenti componenti:
- Arduino Uno
- Fili jumper
- Modulo orologio in tempo reale (DS 1307)
- LCD
- Potenziometro
- Breadboard
Di seguito è riportato lo schema del circuito per l'orologio digitale usando il modulo RTC . Qui nello schema abbiamo usato il chip integrato DS (1307) che è quasi simile al modulo DS3231.
Assemblaggio hardware dell'orologio digitale con RTC
Abbiamo anche implementato il circuito di clock digitale nell'hardware in modo tale che prima abbiamo inserito tutti i componenti nella breadboard. Successivamente abbiamo usato i fili di collegamento per l'interfaccia dei componenti con Arduino. Abbiamo pubblicato un'immagine del gruppo hardware del circuito in cui i fili blu sono i pin di dati del LCD collegato ad Arduino. Il filo giallo è collegato con un potenziometro per la regolazione del contrasto. Inoltre, i fili grigi sono l'orologio e i pin di dati del modulo RTC collegato con Arduino.
Installazione della libreria di RTC
Per interfacciarsi il modulo RTC con Arduino prima dobbiamo scaricare la libreria del modulo RTC. Per prima cosa devi aprire il gestore della biblioteca dell'IDE Arduino e successivamente scrivere la parola chiave rtclib Nella barra di ricerca del gestore della biblioteca. Successivamente devi trovare il RTCLIB di Adfruit e quindi fare clic sull'icona di installazione in blu per installare la libreria.
Quando facciamo clic sul pulsante "Installa", viene visualizzata una nuova finestra di dialogo per la conferma, quindi dobbiamo fare clic sull'icona "Installa tutto".
Codice Arduino per l'orologio digitale utilizzando RTC
Il codice per la creazione di un orologio in tempo reale usando Arduino è:
#include "rtclib.H "// Definizione della libreria per il modulo RTC
#include // Definizione della libreria per LCD
LiquidCrystal LCD (12, 11, 5, 4, 3, 2); // Assegnazione di pin Arduino per il LCD
RTC_DS3231 RTC; // Dichiarazione del modulo RTC
void Aggiornamentortc () // Funzione per l'aggiornamento di RTC per la prima volta
LCD.setCursor (0, 0); // Impostazione del luogo in cui i dati da visualizzare
LCD.stampa ("Aggiornamento ..."); // Visualizzazione dei dati
// chiedi all'utente di inserire una nuova data e ora
const char txt [6] [15] = "anno", "mese", "Day",
"Hour", "minuti", "secondi";
String str = ""; // Creazione di una stringa
Long rtc_array [6]; // Definizione di una variabile per archiviare i dati di input
mentre (seriale.disponibile())
Seriale.Leggere(); // Leggendo l'input seriale
per (int i = 0; i < 6; i++) // loop for taking 6 inputs form the user
Seriale.print ("corrente"); // Visualizzazione dei dati sul seriale
Seriale.print (txt [i]);
Seriale.stampa(": ");
Mentre (!Seriale.disponibile())
// Verifica se è in corso dall'utente
str = seriale.readString (); // Leggendo la stringa di input
Rtc_array [i] = str.toint (); // convertendo l'input dell'utente in numero e salvandolo in un array
Seriale.println (rtc_array [i]); // Stampa l'input dell'utente su seriale
// Aggiornamento di RTC mediante input dell'utente
RTC.Regola (DateTime (rtc_array [0], rtc_array [1], rtc_array [2], rtc_array [3], rtc_array [4], rtc_array [5]));
Seriale.println ("L'ora e la data è aggiornata");
void displayupdate () // funzione per l'aggiornamento della visualizzazione di LCD
// Creazione e array per convertire la cifra in parole a partire da 0 a 6
const char dayinwords [7] [4] = "sole", "mon", "mar", "mer", "thu", "ven", "sat";
// Convertendo i mesi delle cifre in parole a partire da 1 a 12
const char mensionwords [13] [4] = "", "jan", "febbraio", "mar", "apr", "maggio", "jun", "giul", "agosto", "set", "Ott", "Nov", "DEC";
// l'ora di lettura e la data e salvarli in variabili
DateTime RtCtime = RTC.Ora();
int sec = rtctime.secondo (); // secondi
int mins = rtctime.minuto (); // minuti
int hrs = rtctime.Twelvehour (); // ore
int day = rtctime.dayoftheweek (); // giorno in parola
int dd = rtctime.day (); // giorno in numero
int mth = rtctime.mese (); // mese
int yr = rtctime.anno (); // anno
LCD.setCursor (0, 0);/ *Impostazione del luogo per la visualizzazione della data e del giorno della settimana a parole */
// Visualizzazione della data in formato DD-MM-YYYY e giorni della settimana
if (dd < 10) lcd.print("0");
LCD.stampa (DD);
LCD.stampa("-");
LCD.stampa (MonthInwords [Mth]);
LCD.stampa("-");
LCD.stampa (anno);
LCD.stampa(" ");
LCD.stampa (DayInwords [Day]);
LCD.setCursor (0, 1);/ *Impostazione del luogo per la visualizzazione del tempo */
// Visualizzazione del tempo su LCD
if (HRS < 10) lcd.print("0");
LCD.stampa (HRS);
LCD.stampa(':');
Se (min < 10) lcd.print("0");
LCD.stampa (mins);
LCD.stampa(':');
Se (sec < 10) lcd.print("0");
LCD.stampa (sec);
if (rtctime.ispm ()) LCD.print ("pm"); // Visualizzazione di AM/PM
altrimenti LCD.print ("am");
void setup ()
Seriale.Inizia (9600); // Inizializzazione della comunicazione seriale
LCD.Inizia (16,2); // Inizializzazione del LCD
RTC.inizio(); // Inizializzazione del modulo RTC
void loop ()
DisplayUpdate (); // Chiama la funzione per l'aggiornamento del LCD
Se (seriale.Disponit ()) // Verifica se c'è qualche input dall'utente
char input = seriale.leggi (); // Leggendo l'input dall'utente
if (input == 'r') aggiornandortc (); // se r è la chiamata input data la funzione di aggiornamento per RTC
Il codice Arduino per fare un orologio viene compilato in modo tale che prima abbiamo definito la libreria per il modulo RTC. Dopo di che abbiamo definito la libreria per LCD e assegnato i pin di Arduino a LCD e abbiamo dichiarato che per utilizzare le funzioni di RTC utilizzeremo la parola chiave RTC.
Abbiamo creato due funzioni, una per l'aggiornamento del modulo RTC quando collegato per la prima volta e l'altra funzione per l'aggiornamento del LCD.
Nel Aggiornamentortc Prima della funzione Abbiamo dichiarato un carattere per la data e l'ora della settimana e creato una stringa vuota in cui verrà archiviato tutti gli input dell'utente. Poiché ci sono 6 input richiesti dall'utente per aggiornare l'ora e la data, abbiamo utilizzato un ciclo per ottenere l'input dall'utente utilizzando il monitor seriale di Arduino IDE.
Successivamente abbiamo usato il RTC.regolare() funzione per salvare la data e l'ora corrente nel modulo RTC.
Venendo al DisplayUpdate () funzione all'inizio abbiamo convertito l'input numerico per i giorni della settimana e il mese dell'anno in input dei caratteri e quindi abbiamo definito il formato per la data che è DD-MM-YYYY.
Successivamente abbiamo visualizzato la data e l'ora sul LCD utilizzando il LCD.stampa() funzione.
Nella funzione di configurazione dopo aver inizializzato la comunicazione seriale, entrambi i moduli RTC e LCD vengono inizializzati utilizzando la funzione iniziale.
Allo stesso modo, arrivando alla funzione Loop, il primo DisplayUpdate () La funzione è chiamata che visualizza la data e l'ora risparmiata corrente nel modulo RTC. Per aggiornare la data e l'ora che abbiamo usato e se la condizione quando il Il carattere R viene inserito come input seriale Quindi chiama la funzione aggiornamentortc e aggiorna la data e l'ora del modulo.
Ricorda che il modulo RTC consente di risparmiare l'ora e la data data la prima volta e continua ad aggiornare quella data e ora anche se la fornitura è disattivata perché ha una batteria integrata che mantiene il modulo in esecuzione. Quindi l'ingresso della data e dell'ora viene dato solo per la prima volta e mantiene il record di tempo fino a quando non viene modificato manualmente.
Implementazione hardware per l'orologio digitale utilizzando RTC con Arduino Uno
Per aggiornare l'ora e la data, dobbiamo inserire il carattere "R" nel monitor seriale premendo Ctrl+Enter e il codice Arduino richiederà i dati per la data e l'ora correnti. Abbiamo pubblicato l'immagine qui sotto in modo da poter essere un'immagine chiara degli ingressi richiesti:
Dopo aver inserito tutti i dati, il programma indicherà il modulo RTC viene aggiornato. Durante l'aggiornamento dell'ora e della data, l'LCD visualizzerà che RTC viene aggiornato:
Dopo aver aggiornato la data e il tempo verrà visualizzato su LCD:
Conclusione
La scheda Arduino UNO è una forma avanzata di un microcontrollore che ha reso facile l'interfaccia di dispositivi con microcontrollori. Usando Arduino Uno possiamo costruire diverse varietà di progetti. In questo articolo abbiamo progettato un orologio in tempo reale utilizzando il modulo RTC e la procedura viene brevemente spiegata con l'aiuto del codice Arduino e della simulazione.