Arduino NANO – Horloge temps réel

Fabrication d’une horloge temps réel

Le but de ce montage est de réaliser une horloge temps réel avec quatre composants. La lecture de l’heure et de la date se fera sur un écran LCD deux lignes 16 caractères. Avant toute chose, si vous n’êtes pas familiarisé avec le monde des « Arduino » je conseil la lecture des articles suivants :

http://www.robot-maker.com/ouvrages/tuto-arduino/introduction-outil-arduino/

http://www.robot-maker.com/ouvrages/tuto-arduino/choisir-carte-arduino-adaptee/

http://www.robot-maker.com/ouvrages/tuto-arduino/installer-configurer-ide-arduino/#


Matériels nécessaires :
Un Arduino NANO

Un Module RTC DS3231


Un Écran LCD 1602 avec interface I2C


Une carte Prototypage – Double face – Pas 2.54mm

Description du montage…

L’Arduino est capable de mesurer le temps, mais en cas de coupure de son alimentation les données sont remises à zéro. Il est possible de conserver celles-ci en reliant un module RTC (Real Time Clock) afin d’inclure la gestion de l’heure et de la date sauvegardée par une pile (2032) ce qui permet à l’horloge de fonctionner dans le module RTC lorsque l’Arduino est éteint.
Il existe de nombreux modèles de RTC mais le modèle DS3231 est très facile à utiliser car il communique avec l’Arduino par le bus I2C. La lecture de l’heure et de la date se fera sur un écran LCD 1602 (2 lignes de 16 caractères) également par le bus I2C.

Schéma de principe

En théorie le bus I2C est capable de relier jusqu’à 128 périphériques, à condition que chacun possède une adresse différente. Quatre fils sont nécessaires pour relier les modules.
VCC = + alimentation 5V
GND = – alimentation 5V
SDA = broche A4 de l’Arduino
SCL = broche A5 de l’Arduino

Nous retrouvons les même broches sur le module RTC et LCD.

Le montage se fera sur la plaque de prototypage au pas de 2.54 sur laquelle l’Arduino NANO et le module RTC seront soudés. Pas besoin de souder toutes les broches du NANO, seules les quatre extrémités et les broches A4 et A5 seront soudées et reliées par fils de couleurs différentes au module LCD et par straps  au module RTC.

Programmation de l’Arduino
NANO ou UNO

Deux programmes sont nécessaires pour cette horloge temps réel.

  • Le premier permet de mettre l’heure et la date dans le module RTC DS3231 qui sera équipé dune pile 2032.

Programme mise à l’heure du module DS3231

// Horloge_reglage_heure
// Appel de la bibliothèque
#include <Wire.h>
// Adresse I2C de l'horloge en temps réel
#define ADRESSE_I2C_RTC 0x68
// Indiquez ici l'heure et la date :
byte heure = 14; // 0 à 23
byte minute = 42; // 0 à 59
byte seconde = 0; // 0 à 59
byte numJourSemaine = 5; // dim = 1, sam = 7
byte numJourMois = 23; // 1 à 31
byte mois = 8; // 1 à 12
byte annee = 18; // 0 à 99
void setup(){
Wire.begin();
// Change l'heure et la date de l'horloge en temps réel
Wire.beginTransmission(ADRESSE_I2C_RTC);
Wire.write(0); // Positionner le pointeur de registre sur 00h
Wire.write(decToBcd(seconde));
Wire.write(decToBcd(minute));
Wire.write(decToBcd(heure));
Wire.write(decToBcd(numJourSemaine));
Wire.write(decToBcd(numJourMois));
Wire.write(decToBcd(mois));
Wire.write(decToBcd(annee));
Wire.endTransmission();
}
void loop(){
}
// Convertir les nombres décimaux normaux en décimaux codés binaires
byte decToBcd(byte val){return( (val/10*16) + (val%10));}
Horloge-reglage-heure.ino

Ouvrir l’IDE Arduino, puis nouvelle page. Faire un copier/coller du programme, puis faire une compilation, si compilation OK, sauvegarder, puis faire un téléversement du programme dans l’Arduino. Dans la section ‘// Indiquez ici l'heure et la date‘ modifier les données selon l’instant (heure et date) du programme de mise à jour du module RTC, ici l’heure saisie est l’heure GMT

  • Le deuxième permet la gestion de l’affichage de l’heure et de la date sur le LCD et le moniteur série.

Programme Horloge-temps-reel.ino

// Horloge_en_temps_reel
// Appel des bibliothèques
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#define ADRESSE_I2C_RTC 0x68
//Taille de l'afficheur LCD
const int COLONNES = 16;
const int LIGNES = 2;
const int ADRESSE_I2C_LCD = 0x27; // ou 0x27
// Création de l'objet lcd
LiquidCrystal_I2C lcd(ADRESSE_I2C_LCD,COLONNES,LIGNES);
// Déclaration des variables
byte seconde, minute, heure, numJourSemaine, numJourMois, mois, annee;
String jourDeLaSemaine[8] = {"","Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"};
void setup(){
Wire.begin();
Serial.begin(9600);
lcd.init();
lcd.backlight();
}
void loop(){
// Réception de l'heure et de la date
Wire.beginTransmission(ADRESSE_I2C_RTC);
Wire.write(0); // Positionner le pointeur de registre sur 00h
Wire.endTransmission();
Wire.requestFrom(ADRESSE_I2C_RTC, 7);
// Accède aux données de l'horloge (à partir du registre 00h)
seconde = bcdToDec(Wire.read() & 0x7f);
minute = bcdToDec(Wire.read());
heure = bcdToDec(Wire.read() & 0x3f);
numJourSemaine = bcdToDec(Wire.read());
numJourMois = bcdToDec(Wire.read());
mois = bcdToDec(Wire.read());
annee = bcdToDec(Wire.read());
// Affichage de l'heure (afficheur LCD)
lcd.setCursor(2,0);
if (heure<10){lcd.print("0");}
lcd.print(heure, DEC);
lcd.print(":");
if (minute<10){lcd.print("0");}
lcd.print(minute, DEC);
lcd.print(":");
if (seconde<10){lcd.print("0");}
lcd.print(seconde, DEC);
lcd.print(" GMT");
// Affichage de la date (afficheur LCD)
lcd.setCursor(2,1);
lcd.print(jourDeLaSemaine[numJourSemaine]);
lcd.print(" ");
if (numJourMois<10){lcd.print("0");}
lcd.print(numJourMois, DEC);
lcd.print('/');
if (mois<10){lcd.print("0");}
lcd.print(mois, DEC);
lcd.print('/');
lcd.print(annee, DEC);
// Affichage de l'heure (moniteur série)
if (heure<10){Serial.print("0");}
Serial.print(heure, DEC);
Serial.print(":");
if (minute<10){Serial.print("0");}
Serial.print(minute, DEC);
Serial.print(":");
if (seconde<10){Serial.print("0");}
Serial.println(seconde, DEC);
// Affichage de la date (moniteur série)
Serial.print(jourDeLaSemaine[numJourSemaine]);
Serial.print(" ");
if (numJourMois<10){Serial.print("0");}
Serial.print(numJourMois, DEC);
Serial.print("/");
if (mois<10){Serial.print("0");}
Serial.print(mois, DEC);
Serial.print("/");
Serial.println(annee, DEC);
delay(1000);
}
// Convertir les nombres décimaux codés binaires en décimaux normaux
byte bcdToDec(byte val){return( (val/16*10) + (val%16));}

J’ai pour ma part opté pour un affichage de l’heure GMT, bien entendu il est possible de modifier le programme en supprimant la ligne qui affiche le mot ‘GMT’ et en saisissant l’heure locale dans le premier programme. Attention le changement d’heure été/hiver devra se faire manuellement.

Ouvrir l’IDE Arduino, puis nouvelle page. Faire un copier/coller du programme, puis faire une compilation, si compilation OK, sauvegarder, faire un téléversement du programme dans l’Arduino. Après téléversement l’heure et la date s’affichent sur l’écran LCD et également dans le moniteur série.

Une mise en boite pourra compléter le montage.

Ce contenu a été publié dans Actualité du site, Arduino. Vous pouvez le mettre en favoris avec ce permalien.