Arduino : Mettre à l'heure un module RTC

Premier article sur l'Arduino !

Lorsqu'on utilise un module RTC (Real Time Clock : DS1307 ou autre) connecté à un Arduino la première difficulté que j'ai rencontré (en dehors des branchements initiaux) est d'arriver à mettre à l'heure l'horloge !

Voici 2 programmes pour y arriver aisément :

• Le premier à téléverser dans l'Arduino auquel est branché l'horloge
• Le second pour le PC qui fournira l'heure 

Ça fait quoi ces programmes ?
Le programme Arduino se connecte au module RTC et transmet régulièrement via le port série, l'heure du module. il est aussi capable, via ce même port série, si on transmet une chaîne représentant une date et heure, de mettre à jour le module RTC, qui grâce à sa pile pourra ainsi la conserver.
De plus, si on appuie une fois sur le bouton, il peut demander au programme PC de lui transmettre la date et heure. Un appuie long sur le bouton arrête le programme PC qui sinon tourne en boucle indéfiniment.

Le programme PC, une application console, se connecte à l'Arduino via le port série, il affiche ce qui arrive de l'Arduino, et analyse les commandes :

• Adjust dans ce cas, il envoie la date et l'heure.
• Quit dans ce cas il se termine en fermant comme il faut le port série

Comment faut faire ?

1. Récupérer les codes source sur Git HUB
2. Brancher le module RTC et le bouton sur l'Arduino (6 fils : voir schéma ci-dessous)
3. Connecter l'Arduino au PC : (Vérifier le port série utilisé et ajuster dans le code si besoin)
4. Téléverser le programme dans l'Arduino
5. Dans Visual Studio Code charger le programme PC (Nécessite .NET CORE 3.1 SDK) et vérifier aussi que le port série est le bon
6. Exécuter le programme compilé (commande dans la console : Donet Run ou Donet Build et lancer l'exécutable généré dans le dossier Bin)
7. A ce stade les informations de l'horloge doivent défiler sur la console (1 par seconde si le module RTC est déjà initialisé, sinon message d'erreur)
8. Appuyer sur le bouton câblé sur l'Arduino ==> Le module RTC est à l'heure (du PC) !
9. Appuyer et maintenir le bouton ==> le programme PC s'arrête proprement.
10. Enjoy !!

Explications et branchements : Arduino
Un module RTC DS1307 se connecte via le bus I2C de l'Arduino, Je vous fais pas de détail y a pleins de bons tutoriels pour cela. Le module est connecté comme suit :

• SDL sur la PIN A4
• SDA sur le PIN A5 
• GND sur GND
• VCC sur 5V

L'adresse de ma carte RTC sur le bus I2C est 0x68 cette valeur est ajustable dans le code (par une constante) en fonction du module utilisé.
En plus du module RTC il faut un bouton poussoir branché sur une sortie digitale de l'Arduino (PIN 2).

Le programme à téléverser dans l'Arduino est composé de 3 fichiers :

• Horloge.h : Fichier d'entête de la librairie simplifiant les accès au module RTC DS1307
• Horloge.cpp : Le code de la librairie
• MAJ_Horloge.ino : Le programme détaillé ci-dessous.

Le programme fait aussi appel à 2 librairies de communication "classique" pour l'Arduino : SPI.h et Adafruit_SSD1306.h.

On retrouve dans les déclaration (#define) successivement :

• La déclaration de l'adresse du module RTC (ici 0x68)
• La déclaration de la pin du bouton poussoir (ici PIN 2)
• La déclaration du temps "d'appui long" sur le bouton au dela duquel on stoppe le programme PC (ici 3000 = 3 secondes)

Ensuite les variables dont myhorloge qui est une instance de la classe permettant de manipuler le module RTC (Obtenir l'heure,l'ajuster et pouvoir l'afficher simplement).
Je ne détaille pas les autres variables les commentaires s'en charge pour moi.

La suite : la fonction Setup() :

• Positionne le bouton sur la bonne pin et en mode INPUT_PULLUP, 
• Initialise le port série, 
• Initialise la communication avec le module RTC
• Donne quelques instructions sommaires à l'utilisateur sur le port série.

La fonction loop() :
Gère quand le bouton bouton est enfoncé :

En mode INPUT_PULLUP c'est quand l'état du bouton est à LOW que le bouton est enfoncé, dans ce cas on regarde si ce n'est pas la première fois que l'on passe dans la boucle et le temps depuis le premier appui sur le bouton : s'il dépasse le temps prévu (DELAY_QUIT) on envoie la commande quit sur le port série pour forcer le programme PC à s'arrêter proprement.
Si c'est le premier appui sur le bouton, on mémorise le temps pour commencer à compter.

La suite : quand le bouton n'est pas appuyé

Si le bouton est relâche, s'il a été appuyé au moins une fois on envoie la commande adjust sur le port série pour demander au programme PC de nous transmettre l'heure (le traitement de la réception des données se fait plus bas).
Le reste du loop permet de demander l'heure au module RTC et de l'afficher à intervalle régulier. (Gère aussi le cas ou le module n'est pas correctement initialisé)

Le traitement des caractère reçus par l'Arduino se fait dans le gestionnaire d’événements du port série serialEvent().

La fonction lit les caractères reçus et les concatène jusqu'à la réception d'un retour chariot (\n).
A la réception d'un retour chariot, la fonction demande à la méthode stringValide() si la chaîne reçue est une chaîne valide représentant une date et heure au format dd/MM/yyyy HH:mm:ss. Si oui, la date reçue est utilisée pour mettre à jour le module RTC via la méthode myhorloge.adjust();

Comme avec un port série il y a souvent des parasites, une boucle est faite pour traiter toutes les chaînes reçues d'au moins 19 caractères (La longueur du template dd/MM/yyyy HH:mm:ss) en supprimant au fur et a mesure le premier caractère.


Il reste deux fonctions dans le programme : stringValide()et isValidNumber().
Ces deux fonctions ont pour but l'analyse de la chaîne reçue et renvoie True si c'est OK : Tous les contrôles possibles sont fait :

• Les caractères  doivent être des chiffres aux bons emplacements 
• Les séparateurs sont aussi contrôlés
• Les valeurs des chiffres aussi (Jours de 1 à 31, mois de 1 à 12, ...)
• Les mois à 28, 29 ou 30 jours sont aussi contrôles (avec détection des années bissextiles).

Voir le détail de ces fonctions (un peu longue) dans le code source.



Explications : Programme PC
Le programme PC est écrit en C#,
Il nécessite le téléchargement du SDK .NET CORE (accessible à l'adresse suivante : https://dotnet.microsoft.com/download)
Il est compilé avec Visual Studio Code (Éditeur simple pour faire cela téléchargeable à l'adresse : https://code.visualstudio.com/download)

Le dossier de la solution contient un seul projet application console composé d'un seul fichier de code source Program.cs.

Le programme utilise un Package : System.IO.Ports téléchargé via la commande la la console de Visual Studio Code > donet add package System.IO.ports

Le programme déclare deux constantes

PORTNAME : Le nom du port série à utiliser pour parler avec l'Arduino.
BAUDRATE : la vitesse de dialogue.

Une amélioration certaine de l'application serait de pouvoir fournir cela sur la ligne de commande de l'exécutable (TODO !-).

La méthode Main() traite l'intégralité du programme qui consiste en 3 étapes :

Ouvrir le port série, lire les lignes de caractères recues et les traiter des trois manières suivantes :

• Soit c'est la commande quit dans ce cas la boucle While se termine, le programme aussi
• Soit c'est la commande adjust qui est reçue dans se cas le programme envoie la date et l'heure sur le port série.
• Pour toute autre chaîne reçue elle est affiché dans la Console.

A noter : 
le try... finally garantit que le port série sera toujours proprement fermé, même si l'application plantait.
le using(var myport = new SerialPort(...)) { ... } qui englobe le contenu garantit aussi que les ressources associées au port série seront nettoyées proprement par le système lors de l'arrêt du programme.


Voila voila !