Comment faire une horloge numérique à l'aide du module RTC et Arduino Uno
Qu'est-ce que le module RTC
Il s'agit du module d'horloge en temps réel qui enregistre les données du temps et de la date et l'a également affiche sur l'écran d'affichage connecté. Ce module maintient le temps et la date à jour et a un oscillateur en cristal qui génère un signal à une fréquence constante. De plus, le module RTC a des broches dédiées du capteur de température à l'arrière et il y a une broche spéciale qui lit la sortie du capteur.
Le module est également livré avec une batterie lithium-ion 3V qui maintient le module en marche pendant un certain temps si l'alimentation principale est déconnectée.
Il y a 7 broches du module au total, mais du côté opposé, il a les 5 mêmes broches afin que vous puissiez souder les en-têtes sur l'un des deux côtés s'il y a une batterie placée à l'arrière du module et vous ne faites pas T Je souhaite utiliser la broche SQ du module RTC. Le tableau ci-dessous montre les broches du module RTC:
| Broches | Description |
|---|---|
| 1- (sq) | Broche pour générer l'onde carrée |
| 2- (ds) | PIN qui lit la sortie du capteur de température (DS18B20) si elle est installée sur le RTC |
| 2- (SCL) | Pin d'horloge pour l'Arduino |
| 4- (SDA) | Pin de données pour l'Arduino |
| 5- (VCC) | Broche pour fournir la tension au module |
| 6- (GND) | Pin pour la mise à la terre du module |
| 7- (chauve-souris) | Broche pour connecter la batterie externe comme sauvegarde |
Faire une horloge numérique en utilisant RTC avec Arduino Uno
Pour concevoir une horloge en temps réel, vous aurez besoin des composants suivants:
- Arduino Uno
- Fils de cavalier
- Module d'horloge en temps réel (DS 1307)
- LCD
- Potentiomètre
- Planche à pain
Le schéma du circuit pour l'horloge numérique à l'aide du module RTC est donné ci-dessous . Ici, dans le schéma, nous avons utilisé la puce intégrée DS (1307) qui est presque similaire au module DS3231.
Assemblage matériel de l'horloge numérique à l'aide de RTC
Nous avons également implémenté le circuit d'horloge numérique dans le matériel de telle manière que nous avons d'abord placé tous les composants de la planche à pain. Ensuite, nous avons utilisé les fils de connexion pour l'interfaçage des composants avec l'Arduino. Nous avons publié une image de l'assemblage matériel du circuit dans lequel les fils bleus sont les épingles de données de l'écran LCD connectées à Arduino. Le fil jaune est connecté à un potentiomètre pour le réglage du contraste. De plus, les fils gris sont les épingles d'horloge et de données du module RTC connectées à Arduino.
Installation de la bibliothèque de RTC
Pour interfacer le module RTC avec Arduino d'abord, nous devons télécharger la bibliothèque du module RTC. Vous devez d'abord ouvrir le directeur de bibliothèque de l'ide Arduino et après cela, écrivez le mot-clé rtclib Dans la barre de recherche du gestionnaire de bibliothèque. Ensuite, vous devez trouver le Rtclib par adfruit puis cliquez sur l'icône d'installation dans le bleu pour installer la bibliothèque.
Lorsque nous cliquons sur le bouton «Installer», une nouvelle boîte de dialogue apparaît pour la confirmation, nous devons donc cliquer sur l'icône «Installer All».
Code Arduino pour horloge numérique à l'aide de RTC
Le code pour la création d'une horloge en temps réel à l'aide d'Arduino est:
#include "rtclib.H "// Définition de la bibliothèque pour le module RTC
#include // Définition de la bibliothèque pour l'écran LCD
LCD LiquidCrystal (12, 11, 5, 4, 3, 2); // attribuant des broches Arduino pour l'écran LCD
RTC_DS3231 RTC; // Déclarant le module RTC
void updatedrtc () // fonction pour la mise à jour du RTC pour la première fois
LCD.setCursor (0, 0); // définir la place pour que les données soient affichées
LCD.imprimer ("mise à jour…"); // affichant les données
// demande à l'utilisateur de saisir la nouvelle date et l'heure
const char txt [6] [15] = "année", "mois", "jour",
"heure", "minutes", "secondes";
String str = ""; // Création d'une chaîne
long rtc_array [6]; // définir une variable pour stocker les données d'entrée
Pendant que (série.disponible())
En série.lire(); // Lire l'entrée en série
pour (int i = 0; i < 6; i++) // loop for taking 6 inputs form the user
En série.print ("actuel"); // affichant les données sur la série
En série.print (txt [i]);
En série.imprimer(": ");
alors que (!En série.disponible())
// Vérifiez s'il y a la contribution de l'utilisateur
str = série.readString (); // Lire la chaîne d'entrée
Rtc_array [i] = str.toint (); // Conversion de l'entrée de l'utilisateur en numéro et l'enregistrement dans un tableau
En série.println (rtc_array [i]); // Impression de l'entrée de l'utilisateur en série
// mise à jour du RTC par l'entrée de l'utilisateur
RTC.ajustement (datetime (rtc_array [0], rtc_array [1], rtc_array [2], rtc_array [3], rtc_array [4], rtc_array [5]));
En série.println ("l'heure et la date sont mises à jour");
void displayUpdate () // Fonction pour mettre à jour l'affichage de l'écran LCD
// Création et tableau pour convertir le chiffre en mots à partir de 0 à 6
const char dayinwords [7] [4] = "Sun", "Mon", "mar", "wed", "thu", "fri", "sat";
// Conversion des mois de chiffres en mots à partir de 1 à 12
const char MonthinWords [13] [4] = "", "jan", "février", "mar", "avr", "mai", "juin", "juil", "août", "sept", "Oct", "nov", "déc";
// l'heure et la date de lecture et les enregistrer en variables
DateTime rtctime = rtc.maintenant();
int sec = rtctime.deuxième (); // secondes
int mins = rtctime.minute (); // minutes
int hrs = rtctime.douzehour (); // heures
int day = rtctime.dayoftheweek (); // jour en mot
int dd = rtctime.day (); // jour en nombre
int mth = rtctime.mois (); // mois
int yr = rtctime.année (); // année
LCD.setCursor (0, 0); / * définir la place pour afficher la date et le jour de la semaine en mots * /
// Affichage de la date au format DD-MM-Yyyy et des jours de semaine
if (dd < 10) lcd.print("0");
LCD.print (dd);
LCD.imprimer("-");
LCD.print (MonthinWords [MTH]);
LCD.imprimer("-");
LCD.imprimer (an);
LCD.imprimer(" ");
LCD.imprimer (dayinwords [jour]);
LCD.setCursor (0, 1); / * définir la place pour afficher l'heure * /
// affichant l'heure sur l'écran LCD
if (hrs < 10) lcd.print("0");
LCD.Imprimer (HRS);
LCD.imprimer(':');
si (minutes < 10) lcd.print("0");
LCD.imprimer (min);
LCD.imprimer(':');
si (sec < 10) lcd.print("0");
LCD.imprimer (sec);
si (rtctime.ISPM ()) LCD.print ("pm"); // Affichage de l'AM / PM
Else LCD.print ("am");
void setup()
En série.commencer (9600); // initialisation de la communication série
LCD.commencer (16,2); // initialisation de l'écran LCD
RTC.commencer(); // initialisation du module RTC
VOID LOOP ()
DisplayUpdate (); // appelle la fonction pour mettre à jour le LCD
si (série.Disponible ()) // Vérification s'il y a une entrée de l'utilisateur
Entrée de charbon = série.read (); // lire l'entrée de l'utilisateur
if (input == 'r') updatingrtc (); // Si R est l'entrée donnée appelez la fonction de mise à jour pour RTC
Le code Arduino pour faire une horloge est compilé de telle manière que nous avons d'abord défini la bibliothèque du module RTC. Après cela, nous avons défini la bibliothèque de l'écran LCD et attribué les broches d'Arduino à l'écran LCD et déclaré que pour utiliser les fonctions du RTC, nous utiliserons le mot-clé RTC.
Nous avons créé deux fonctions, l'une pour mettre à jour le module RTC lorsqu'il est connecté pour la première fois et l'autre fonction pour mettre à jour le LCD.
Dans le Mise à jour fonction, nous avons d'abord déclaré un caractère pour la date et l'heure de la semaine et créé une chaîne vide dans laquelle toutes les entrées de l'utilisateur seront stockées. Puisqu'il y a 6 entrées requises de l'utilisateur pour mettre à jour l'heure et la date, nous avons utilisé une boucle pour obtenir les commentaires de l'utilisateur à l'aide du moniteur en série d'Arduino IDE.
Ensuite, nous avons utilisé le RTC.ajuster() Fonction pour enregistrer la date et l'heure actuelles du module RTC.
Venir au DisplayUpdate () Fonction Au début, nous avons converti l'entrée du nombre pour les jours de semaine et le mois de l'année en entrée de caractère, puis avons défini le format pour la date qui est DD-MM-Yyyy.
Ensuite, nous avons affiché la date et l'heure sur l'écran LCD en utilisant le LCD.imprimer() fonction.
Dans la fonction de configuration après initialisation de la communication série, les modules RTC et LCD sont initialisés à l'aide de la fonction de début.
De même, en venant à la fonction de boucle, le premier DisplayUpdate () La fonction est appelée qui affiche la date et l'heure enregistrées actuelles du module RTC. Pour mettre à jour la date et l'heure que nous avons utilisées et si la condition Le caractère r est entré comme une entrée en série Ensuite, appelez la fonction UpdatingRTC et mettez à jour la date et l'heure du module.
N'oubliez pas que le module RTC gagne l'heure et la date étant donné la première fois et continue de mettre à jour cette date et cette heure même si l'alimentation est désactivée car elle a une batterie intégrée qui fait fonctionner le module. Par conséquent, l'entrée de date et d'heure n'est donnée que pour la première fois et il garde les traces de temps jusqu'à ce qu'il soit modifié manuellement.
Implémentation du matériel pour l'horloge numérique à l'aide de RTC avec Arduino Uno
Pour mettre à jour l'heure et la date, nous devons entrer le caractère «R» dans le moniteur série en appuyant sur Ctrl + Entrée et le code Arduino nécessitera les données pour la date et l'heure actuelles. Nous avons publié l'image ci-dessous afin que vous puissiez être une image claire des entrées requises:
Après avoir entré toutes les données, le programme indiquera au module RTC mis à jour. Lors de la mise à jour de l'heure et de la date, l'écran LCD affiche que RTC est mis à jour:
Une fois que vous avez mis à jour la date et l'heure, elle sera affichée sur l'écran LCD:
Conclusion
La carte Arduino Uno est une forme avancée d'un microcontrôleur qui a facilité l'interfaçage des appareils avec des microcontrôleurs. En utilisant Arduino Uno, nous pouvons construire différentes variétés de projets. Dans cet article, nous avons conçu une horloge en temps réel en utilisant le module RTC et la procédure est brièvement expliquée à l'aide du code et de la simulation Arduino.