43
Rapport projet Master 1 AII Année 2015/2016 Projet collaboratif : Réalisation d'un poulailler autonome Module 3 : Étude et réalisation d'une horloge temps réel programmable Étudiant : Thomas Zorninger Enseignant tuteur : Gilles Hermann Collaborateurs : Narcisse Kapdjou Loïc Metzger Abhinav Kant

Real Time clock

Embed Size (px)

DESCRIPTION

The project uses a real time clock and a keypad to allow user to define various parameter for the project

Citation preview

Page 1: Real Time clock

Rapport projetMaster 1 AII

Année 2015/2016

Projet collaboratif : Réalisation d'un poulailler autonome

Module 3 : Étude et réalisationd'une horloge temps réel

programmable

Étudiant : Thomas ZorningerEnseignant tuteur : Gilles Hermann

Collaborateurs : Narcisse Kapdjou Loïc Metzger Abhinav Kant

Page 2: Real Time clock

Thomas Zorninger - Remerciements Année 2015/201628/04/2023

REMERCIEMENTSJe tiens à remercier, en premier lieu, mon enseignant tuteur Monsieur Gilles

HERMANN. Ses conseils et son soutien m’ont été importants dans l’avancement et la mise au point de mon projet, merci pour son aide et le suivi qu’il m’a apporté.

Mes remerciements vont également à mes collègues Narcisse Kapdjou, Loic Metzger et Abhinav Kant avec lesquels j’ai mené à bien ce projet collaboratif.

Je remercie également mes collègues de formation pour leurs idées et leur aide.Enfin, je remercie les enseignants de ma formation pour les connaissances qu’ils

nous ont inculquées tout au long de l’année.

Page 3: Real Time clock

Thomas Zorninger - Table des Illustrations

Année 2015/201628/04/2023

SOMMAIREREMERCIEMENTS............................................................................................................................................2

SOMMAIRE..........................................................................................................................................................3

TABLE DES ILLUSTRATIONS........................................................................................................................4

1. INTRODUCTION..........................................................................................................................................5

2. LE PROJET....................................................................................................................................................6

2.1 Définition générale du projet.....................................................................................................................62.2 Fonctionnement envisagé..........................................................................................................................62.3 Cahier des charges.....................................................................................................................................6

3. EQUIPEMENT...............................................................................................................................................7

3.1 Horloge temps réel DS1307.............................................................................................................................7 3.2 Clavier matriciel 3x4.......................................................................................................................................7 3.3 Ecran LCD rétro éclairé 16x2..........................................................................................................................8 3.4 Arduino8

3.4.1 Arduino Mega........................................................................................................................................................................93.4.2 IDE Arduino........................................................................................................................................................................10

4. ETUDE ET IMPLÉMENTATION.............................................................................................................11

4.1 Communication I2C.......................................................................................................................................11 4.2 Horloge temps réel DS1307...........................................................................................................................12 4.3 Acquisition appui clavier...............................................................................................................................15

4.3.1 Utilisation des touches.................................................................................................................................................................15 4.4 Ecran LCD rétro éclairé.................................................................................................................................16 4.5 Gestion ouverture/fermeture..........................................................................................................................20 4.6 Gestion de la batterie.....................................................................................................................................22

RÉSUMÉ ANGLAIS..........................................................................................................................................23

BILAN ET PERSPECTIVES............................................................................................................................24

CONCLUSION...................................................................................................................................................25

BIBLIOGRAPHIE ET WEBOGRAPHIE.......................................................................................................26

LEXIQUE............................................................................................................................................................27

ANNEXE..............................................................................................................................................................29

1.1 Brochage DS1307..........................................................................................................................................29 1.2 Code de scrutation de l’appui clavier............................................................................................................29 1.3 Code d’action après appui clavier..................................................................................................................30 1.4 Script python..................................................................................................................................................32 1.5 Fonction de synchronisation..........................................................................................................................33

Poulailler autonome – Horloge temps réel Page 3 / 33

Page 4: Real Time clock

Thomas Zorninger - Table des Illustrations

Année 2015/201628/04/2023

TABLE DES ILLUSTRATIONSFigure 1 : Image DS1307....................................................................................................7Figure 2 : Image clavier......................................................................................................7Figure 3 : Image écran LCD................................................................................................8Figure 4 : Image Arduino Méga...........................................................................................9Figure 5 : Tableau caractéristiques Arduino Méga..............................................................9Figure 6 : Capture écran IDE Arduino...............................................................................10Figure 7 : Codage NRZ pour bus I2C.................................................................................11Figure 8 : Schéma de principe communication Arduino / DS1307....................................12Figure 9 : Organisation mémoire DS1307.........................................................................13Figure 10 : Interfaçage Arduino/Clavier............................................................................15Figure 11 : Schéma de principe communication Arduino / Ecran LCD..............................16Figure 12 : Photo Affichage par défaut.............................................................................17Figure 13 : Photo Appui touche *......................................................................................17Figure 14 : Photo Appui sur 1 après touche *...................................................................17Figure 15 : Photo Appui sur 2 après touche *...................................................................17Figure 16 : Photo Appui sur autre alarme configurer après touche *................................17Figure 17 : Photo Appui touche 0.....................................................................................18Figure 18 : Photo entrez heure.........................................................................................18Figure 19 : Photo entrez minutes.....................................................................................18Figure 20 : Photo menu gestion système.........................................................................19Figure 21 : Photo état porte.............................................................................................19Figure 22 : Photo état alarmes.........................................................................................19Figure 23 : Photo niveau batterie.....................................................................................19Figure 24 : Photo ouverture/fermeture.............................................................................19Figure 25 : Photo nombre poules......................................................................................19

Poulailler autonome – Horloge temps réel Page 4 / 33

Page 5: Real Time clock

Thomas Zorninger - Introduction Année 2015/201628/04/2023

1. INTRODUCTION

Lorsque l’on souhaite réaliser un système autonome, il est nécessaire de faire en sorte que celui-ci soit assez « intelligent » pour gérer, de manière automatique et sans interventions extérieures, certaines tâches ou certains travaux que l’on souhaite lui confier.Un système dit « autonome » est habituellement composé de deux parties :

- Une partie commande : C’est cette partie qui donne les ordres et reçoit des informations de l’extérieur (d’un autre système par exemple) ou de la partie opérative (voir ci-dessous). La partie commande est généralement articulée autour d’un microprocesseur ou d’une ordinateur.

- Une partie opérative : C’est cette partie qui va effectuer les tâches. Elle reçoit les ordres de la partie commande et les exécutent. La partie opérative contient généralement les capteurs et les actionneurs.

Il est néanmoins important de faire la distinction entre un système autonome et un système intelligent. Un système intelligent est un système qui est capable de prendre des décisions tout seul, bénéficiant d’une capacité d’apprentissage et réalisant des tâches en conséquence. Un système intelligent est autonome mais un système autonome n’est pas forcément intelligent. Un système autonome tel qu’étudier et réaliser dans ce projet n’est pas intelligent. C’est-à-dire qu’il n’aura aucune capacité d’apprentissage. Il pourra néanmoins prendre certaines décisions programmées en fonction de l’état des différentes parties du système.Le système étudié dans ce projet est un poulailler autonome. Il aura pour but la mise en place de plusieurs sous-systèmes permettant le fonctionnement efficace de l’ensemble. On peut citer notamment la mise en place d’une alimentation solaire, d’une porte automatique ou encore la réalisation d’un compteur de poules. Dans ce rapport, nous verrons la partie « Etude et réalisation d’une horloge temps réel programmable ».

Page 6: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

2. LE PROJET

2.1 Définition générale du projetCe projet porte sur l’étude et la réalisation d’un poulailler autonome. Pour

ce faire, le poulailler comportera plusieurs parties réalisées par chaque membre du projet.C’est pour cela qu’il est essentiel que chaque partie ne soit pas complètement indépendante. Par exemple, l’alimentation solaire permettra d’alimenter chaque sous système.

2.2 Fonctionnement envisagéLe fonctionnement final envisagé devra permettre la gestion autonome

d’un poulailler. C’est-à-dire qu’il ne doit pas y avoir la nécessité d’une action extérieure pour assuré un bon fonctionnement. On verra cependant qu’un utilisateur pourra superviser l’ensemble du système. Il pourra notamment visualiser l’état des différentes parties (niveau de batterie par exemple) ainsi que les alarmes (heure d’ouverture et de fermeture de la porte par exemple). Le but final sera également l’articulation de tous les sous systèmes autour d’un seul Arduino Méga. Celui-ci servira donc de partie commande du système global.Pour la partie horloge temps réel, le projet se basera sur une horloge DS1307 permettant l’enregistrement de la date et l’heure. L’interface avec l’utilisateur se fera à l’aide d’un clavier 3x4 ainsi qu’un écran LCD rétro éclairé.

2.3 Cahier des chargesLa gestion de la date et l’heure s’articulera autour d’une horloge temps réel

DS1307. Elle doit permettre notamment en cas de coupure d’alimentation de garder en mémoire la date et l’heure courante (pile lithium incluse permettant le basculement sur alimentation secondaire).L’interface avec l’utilisateur se fera à l’aide d’un clavier 3x4 et d’un écran LCD 16x2. L’affichage devra permettre la visualisation de la date et l’heure, l’état des différentes parties du système (porte, niveau batterie, nombre de poules), la gestion des alarmes (heure d’ouverture et fermeture de la porte et autres). Cette interface devra être intuitive et concise puisque l’écran 16x2 limite le nombre d’éléments affichés à l’écran.Bien évidemment, toutes ces parties seront gérées par un Arduino Méga.

Poulailler autonome – Horloge temps réel Page 6 / 33

Page 7: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

3. EQUIPEMENT

Pour la gestion de la date et l’heure, on utilisera une horloge temps réel DS1307.

Figure 1 : Image DS1307

Cette horloge possède l’avantage de sa facilité d’utilisation grâce au bus I2C. Vous trouverez le brochage du composant en Annexe 1.1.Elle possède également une RAM non utilisée par le composant qui va nous permettre d’enregistrer certains états ou variables « critiques » en cas de coupure d’alimentation principale.

L’utilisateur pourra interagir avec le système grâce à un clavier 3x4.

Figure 2 : Image clavier

Ce clavier 3 colonnes, 4 lignes va nous permettre l’interfaçage avec l’utilisateur.Grâce à celui-ci, l’utilisateur sera capable de gérer le système global (visualisation des états, gestions des heures et alarmes, …).Comme on peut le remarquer sur l’image ci-contre, le clavier possède 13 pins de sortie. Chaque pin correspond à une touche et un pin servira de point commun.On verra, dans la partie étude, l’association touche/pin. On élaborera également l’interfaçage avec l’Arduino. En effet, on aura la nécessité d’utiliser 12 entrées numériques de l’Arduino.

Poulailler autonome – Horloge temps réel Page 7 / 33

3.1 Horloge temps réel DS1307

On remarque également la présence d’une pile lithium 3.6V servant d’alimentation secondaire en cas de coupure de l’alimentation principale.On verra dans la partie étude comment communiquer avec le composant et on analysera également le format des données enregistrées.

3.2 Clavier matriciel 3x4

Page 8: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

L’utilisateur aura la possibilité de visualiser certaines informations du système grâce à un écran LCD rétro éclairé.

Figure 3 : Image écran LCD

Cet écran LCD rétro éclairé permettra à l’utilisateur de visualiser de manière simple et efficace les informations importantes concernant le système.L’écran affichera par défaut la date et l’heure.

Celui-ci possède l’avantage d’intégrer un module I2C pour sa communication. Deux fils suffiront donc à sa commande (plus l’alimentation). Nous verrons dans la partie étude le principe de la communication I2C. On mettra également en évidence les informations utiles à afficher sur cet écran pour que l’utilisateur puisse bénéficier d’une interface claire et ergonomique.

Arduino est une plate-forme de prototypage électronique open-source créée par une équipe de développeurs, composée de six personnes : Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, David Mellis et Nicholas Zambetti.Cette équipe a créé le « système Arduino ». C’est un outil qui permet aux débutants, amateurs ou professionnels de créer des systèmes électroniques plus ou moins complexes.

Poulailler autonome – Horloge temps réel Page 8 / 33

3.3 Ecran LCD rétro éclairé 16x2

3.4 Arduino

Page 9: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

3.4.1 Arduino Mega

Figure 4 : Image Arduino Méga

Figure 5 : Tableau caractéristiques Arduino Méga

L’Arduino Méga est une carte basée sur un microcontrôleur ATmega2560.La carte possède 56 entrées/sorties numériques (dont 15 pouvant être utilisées en PWM), 16 entrées analogiques (chacune connectée à un convertisseur analogique/numérique sur 10 bits), un quartz cadencé à 16 Mhz, une connexion USB, une alimentation « jack » et un bouton reset (réinitialisation).L’Arduino Méga 2560 est une mise à jour de l’Arduino Méga.Sa tension de fonctionnement est 5V et elle supporte une alimentation continue de 20V maximum. Elle possède une mémoire flash de 256Ko (dont 8 Ko utilisés par le boot loader) une SRAM de 8Ko et une EEPROM de 4Ko.

Poulailler autonome – Horloge temps réel Page 9 / 33

Page 10: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

3.4.2 IDE Arduino

Figure 6 : Capture écran IDE Arduino

L’IDE Arduino (Integrated Development Environment) est un environnement de développement open-source écrit en Java.C’est ce logiciel qui va nous permettre la programmation de notre microcontrôleur.La création de librairie ce fait en langage C++ et la programmation en langage C.Il est nécessaire d’aller dans Outils → Type de carte puis de choisir la carte que l’on souhaite utiliser.

Poulailler autonome – Horloge temps réel Page 10 / 33

Page 11: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

4. ETUDE ET IMPLÉMENTATION

4.1 Communication I2CLe bus I2C est un bus de données synchrone.Plusieurs équipements, soit maîtres, soit esclaves, peuvent être connectés au bus.Il comprend trois fils :

- Un signal de données (appelé SDA),- Un signal d’horloge (appelé SCL, permettant le cadençage de l’envoi des

données),- Un signal de référence électrique (masse).

Le codage des bits est de type NRZ (non retour à 0).Voici la représentation du codage des bits :

Figure 7 : Codage NRZ pour bus I2C

Le niveau « haut » ou « bas » de la ligne SDA doit être maintenu stable pendant le niveau « haut » sur la ligne SCL pour la lecture du bit.Les équipements connectés au bus le sont par des sorties de type drain ouvert (ou collecteur ouvert) sur les 2 lignes SDA et SCL.Les équipements sont donc câblés sur le bus par le principe de « ET câblé », ce qui veut dire qu’en cas d’émission simultanée de 2 équipements, la valeur 0 écrase la valeur 1.On dit donc :

- Que l’état logique « 0 » ou « Low » est l’état « dominant ».- Que l’état logique « 1 » ou « High » est l’état « récessif ».

Lorsque le bus n’est pas utilisé, il est au niveau haut (à travers une ou des résistance(s) de pull-up).

Poulailler autonome – Horloge temps réel Page 11 / 33

Page 12: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

4.2 Horloge temps réel DS1307

ArduinoMéga

DS1307

+5V

SDA

SCL

+5V

R R

Figure 8 : Schéma de principe communication Arduino / DS1307

Comme nous l’avons vu précédemment, l’horloge temps réel DS1307 possède un module I2C nous permettant la communication avec celle-ci via une bibliothèque disponible sur l’Arduino.Dans le schéma de principe ci-contre, on admet que l’Arduino Méga sera le maître et le DS1307 l’esclave.Les deux résistances R sont des résistances de pull-up de valeur 1KΩ.Pour la communication entre les équipements, chaque esclave est défini par une adresse.

Le DS1307 est défini par l’adresse 0x68. Cette adresse permettra au maître de communiquer avec un esclave spécifique. Par exemple, on verra que l’écran LCD que nous utiliserons aussi en I2C aura l’adresse 0x20.Le module DS1307 contient 63 octets de RAM. Sur ces 63 octets, 7 contiennent la date et l’heure (incrémentés automatiquement), plus un 8ème octet pour la configuration du DS1307. Les 56 octets restants sont un « bonus » où on pourra y stocker des données d’usage (variables et états importants par exemple).

Poulailler autonome – Horloge temps réel Page 12 / 33

Page 13: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

Voici un extrait de la documentation constructeur détaillant l’organisation interne de la ram du DS1307 :

Figure 9 : Organisation mémoire DS1307On remarque que les informations sur la date et l’heure sont contenues entre l’adresse 00H et 07H (7 octets). La valeur de ces adresses est importante puisqu’elle nous permettra de communiquer avec l’horloge.La bibliothèque qui nous permettra de gérer cette communication I2C est Wire. On verra que pour nous faciliter la tâche, la communication avec l’écran LCD se fera avec la bibliothèque LiquidCrystal_I2C.La particularité du DS1307 est que les informations sur la date et l’heure sont enregistrés dans un format BCD.Le BCD (décimal codé binaire) : Prenons en exemple le nombre 63. En binaire on obtiendrait 0011 1111 car on convertit la valeur sur 8 bits directement. En BCD, on code les chiffres indépendamment, 63 donnera donc 6(0110) et 3(0011) 0110 0011.Il va donc falloir convertir cette valeur BCD en décimal pour la lecture et convertir une valeur décimale en BCD pour l’écriture.Pour cela on utilisera les deux fonctions suivantes (Source : Skyduino) :

byte bcd2dec(byte bcd) return ((bcd / 16 * 10) + (bcd % 16)); byte dec2bcd(byte dec) return ((dec / 10 * 16) + (dec % 10));

On extrait tout simplement les deux chiffres puis on les assemble avant de retourner la valeur décimale. On réalise l’opération inverse pour la conversion décimale/BCD.

Poulailler autonome – Horloge temps réel Page 13 / 33

Page 14: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

Elle va nos permettre l’enregistrement de la date et l’heure retournée par l’horloge.On l’utilisera également pour enregistrer certaines alarmes comme l’heure d’ouverture et de fermeture.

Pour stocker les valeurs que l’on récupérera du DS1307, on utilisera une structure définie comme suit :Une particularité à prendre en compte est qu’il est impossible de définir une structure en la déclarant dans un sketch. Il faut au préalable la placer dans un fichier d’en-tête que l’on placera dans le même dossier que le programme principal.Grâce à cela on peut maintenant définir deux fonctions d’écriture et de lecture de la ram de l’horloge :

Afin d’enregistrer initialement la date et l’heure, on utilisera un script python communiquant avec l’Arduino via le port série. Ce script permettra de lire l’heure et le date sur l’ordinateur afin de la transmettre à l’Arduino qui se chargera de l’enregistrer dans l’horloge temps réel. Vous trouverez en Annexe 1.4 le code python correspondant.L’Arduino utilisera une fonction de synchronisation pour l’enregistrement. Vous trouverez le code de cette fonction en Annexe 1.5.

Poulailler autonome – Horloge temps réel Page 14 / 33

Page 15: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

4.3 Acquisition appui clavier

ArduinoMéga

...

...GND

GND D2 D13

* 3

Figure 10 : Interfaçage Arduino/Clavier

Le clavier que l’on utilisera est un clavier utilisant 13 pins. Un pin de point commun (GND) et 12 pins reliés chacun à une touche du clavier.Cette particularité implique l’utilisation de 12 entrées numériques de l’Arduino afin de détecter un appui sur chaque touche.Grâce à l’Arduino méga, on bénéficie d’un grand nombre d’entrées et pour notre application il ne sera pas nécessaire d’utiliser un autre procédé de détection d’appui.En effet il aurait été éventuellement possible de sérialisé l’interface ou bien plus simplement de ne pas utiliser certaines touches du clavier.

Certains claviers matriciels présentent l’avantage d’utiliser moins de broches.Le clavier que l’on utilisera sera donc une simple association de boutons poussoirs. On utilisera une fonction de scrutation afin de détecter un appui éventuel de l’utilisateur. Vous trouverez le code de cette fonction en Annexe 1.2. L’Arduino ne bénéficie pas d’assez d’entrées d’interruption pour utiliser le clavier en interruption.

4.3.1 Utilisation des touchesOn se place dans le cas ou l’affichage est en mode par défaut (voir Partie écran LCD rétro éclairé pour la définition du mode).La touche # : Grâce à cette touche, l’utilisateur peut activer ou désactivé le rétro éclairage de l’écran LCD. En effet, l’écran consomme beaucoup plus lorsque le rétro éclairage est activé.La touche * : Cette touche permet à l’utilisateur de rentrer dans la visualisation des alarmes qui ont été configurées. Une fois dans ce mode, l’utilisateur peut utiliser les chiffres du clavier pour accéder à l’alarme correspondante. Les chiffres 1 et 2 correspondent respectivement à l’ouverture et à la fermeture. Le reste peut être configuré selon les besoins de l’utilisateur. Un appui sur * annule toute action ou modification en cours et ramène l’affichage à l’état par défaut.

Poulailler autonome – Horloge temps réel Page 15 / 33

Page 16: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

La touche 0 : Cette touche permet à l’utilisateur de rentrer dans la configuration des alarmes. Une fois dans ce mode, l’utilisateur peut utiliser les chiffres du clavier pour accéder à l’alarme qu’il souhaite modifier. Les chiffres 1et 2 correspondent respectivement à l’ouverture et à la fermeture. L’utilisateur pourra modifier l’heure d’ouverture ou de fermeture grâce au clavier. Il pourra indiquer la date et l’heure d’autres alarmes éventuelles. Un appui sur * annule toute action ou modification en cours et ramène l’affichage à l’état par défaut.La touche 1 : Cette touche permet de revenir à l’affichage par défaut.La touche 2 : Cette touche permet d’accéder au menu de visualisation de l’état du système. Dans ce mode, la touche 1 permet d’accéder à l’état de la porte (ouverte ou fermée), la touche 2 permet de visualiser l’état des alarmes (ouverture, fermeture ou autres). Un appui sur * annule toute action ou modification en cours et ramène l’affichage à l’état par défaut.La touche 3 : Cette touche permet d’accéder à l’état de la batterie. Un appui sur * annule toute action ou modification en cours et ramène l’affichage à l’état par défaut.La touche 4 : Cette touche permet à l’utilisateur d’accéder à la gestion de la porte. Un appui sur la touche 1 permet l’ouverture de la porte sauf si celle-ci est déjà ouverte. Un appui sur la touche 2 permet la fermeture de la porte sauf si celle-ci est déjà fermée.Vous trouverez le code d’action après l’appui sur le clavier en Annexe 1.3.

4.4 Ecran LCD rétro éclairé

ArduinoMéga

Ecran LCD

+5V

SDA

SCL

+5V

R R

Figure 11 : Schéma de principe communication Arduino / Ecran LCD

Comme nous l’avons vu précédemment, l’écran LCD rétro éclairé est piloté par un module I2C.Dans le schéma de principe ci-contre, on admet que l’Arduino Méga sera le maître et l’écran LCD l’esclave.Les deux résistances R sont des résistances de pull-up de valeur 1KΩ.Pour la communication entre les équipements, chaque esclave est défini par une adresse.L’écran LCD est défini par l’adresse 0x20. Cette adresse nous permettra de communiquer avec l’écran.

Il est maintenant nécessaire de se poser la question suivante : Quelles informations va-t-on afficher sur l’écran ?En effet, l’espace disponible pour l’affichage par défaut est limité et il est nécessaire d’afficher les informations utiles en priorité.

Poulailler autonome – Horloge temps réel Page 16 / 33

Page 17: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

J’ai choisi d’afficher par défaut les informations suivantes :

Jour Date Batterie

Heure PorteFigure 12 : Photo Affichage par défaut

Ecran LCD

- En haut à gauche : Jour + Date- En haut à droite : Etat de la

batterie- En bas à gauche : Heure- En bas à droite : Etat de la porte

On a grâce à cet affichage une information globale sur le système.

Nous allons maintenant voir les différents menus que l’utilisateur peut ouvrir à partir de l’affichage par défaut grâce aux touches du clavier définies précédemment.

Figure 13 : Photo Appui touche *

Figure 14 : Photo Appui sur 1 après touche *

Figure 15 : Photo Appui sur 2 après touche *

Figure 16 : Photo Appui sur autre alarme configurer après touche *

Lorsque l’on se trouve dans le mode « affichage par défaut », on peut entrer dans le menu de visualisation des alarmes en appuyant sur la touche * du clavier. On visualise ensuite l’écran ci-contre (figure 13).Une fois dans ce menu, un appui sur la touche 1 permet la visualisation de l’heure d’ouverture de la porte (figure 14).

Un appui sur la touche 2 permet la visualisation de l’heure de fermeture de la porte (figure 15).

Un appui sur un autre chiffre (3 à 9 configuré avec une alarme) permet la visualisation de la date et l’heure de l’alarme correspondante (figure 16).

Poulailler autonome – Horloge temps réel Page 17 / 33

Page 18: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

Figure 17 : Photo Appui touche 0

Figure 18 : Photo entrez heure

Figure 19 : Photo entrez minutes

Lorsque l’on se trouve dans le mode « affichage par défaut », on peut entrer dans le menu de configuration des alarmes en appuyant sur la touche 0 du clavier. On visualise ensuite l’écran ci-contre (figure 17).Une fois dans ce menu, un appui sur la touche 1 permet la configuration de l’heure d’ouverture de la porte (figure 18).Cette figure présente le moment ou l’utilisateur doit entrer l’heure.La figure 19 ci-contre présente le moment ou l’utilisateur doit entrer les minutes.Le même procédé est suivi pur la modification de l’heure de fermeture.

Si l’utilisateur souhaite modifier une alarme qui n’est pas l’heure d’ouverture ou de fermeture, il devra entrer dans un premier temps, la date.Un des problèmes rencontré pendant la mise en place du code gérant les entrées de l’utilisateur est le fait de devoir rentrer des dates et heures cohérentes. En effet, L’heure doit être comprise entre 00h00 et 23h59. L’utilisateur ne pourra pas entrer 24h78 par exemple.Au niveau des dates, j’ai fait le choix de ne pas pouvoir entrer une année antérieure à 2016 (année en cours). Bien évidemment, de la même manière que l’heure, les dates doivent restées cohérentes. Impossible, par exemple, de configurer une date pour le 56/80/2010.J’ai également fait le choix de ne pas laisser à l’utilisateur la possibilité de gérer les secondes. Dans notre application, la gestion du temps à la seconde près n’est pas nécessaire.

Poulailler autonome – Horloge temps réel Page 18 / 33

Page 19: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

Figure 20 : Photo menu gestion système

Figure 21 : Photo état porte

Figure 22 : Photo état alarmes

Lorsque l’on se trouve dans le mode « affichage par défaut », on peut entrer dans le menu de visualisation de l’état du système en appuyant sur la touche 2 du clavier. On visualise ensuite l’écran ci-contre (figure 20).Une fois dans ce menu, un appui sur la touche 1 permet la visualisation de l’état de la porte (figure 21).

Un appui sur la touche 2 permet la visualisation de l’état des alarmes (figure 22).

Figure 23 : Photo niveau batterie

Lorsque l’on se trouve dans le mode « affichage par défaut », on peut entrer dans le menu de visualisation de l’état de la batterie en appuyant sur la touche 3 du clavier. On visualise ensuite l’écran ci-contre (figure 23).

Le niveau de batterie ci-dessus, n’est pas représentatif. Cette valeur est une valeur aléatoire mesurée sur une entrée analogique de l’Arduino. La vraie valeur du niveau de la batterie sera visualisable lorsque celle-ci sera implémentée dans le système.

Figure 24 : Photo ouverture/fermeture

Lorsque l’on se trouve dans le mode « affichage par défaut », on peut entrer dans le menu de gestion la porte en appuyant sur la touche 4 du clavier. On visualise ensuite l’écran ci-contre (figure 24).

Ceci permet à l’utilisateur de gérer « manuellement » la porte.

Figure 25 : Photo nombre poules

Lorsque l’on se trouve dans le mode « affichage par défaut », on peut entrer dans la visualisation du nombre de poule total et à l’intérieur du poulailler. On visualise l’écran ci-contre (figure 25).

La partie gestion du nombre de poule est gérée par mon collègue Loïc Metzger.

Poulailler autonome – Horloge temps réel Page 19 / 33

Page 20: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

4.5 Gestion ouverture/fermetureAfin de gérer l’ouverture et la fermeture de la porte il est intéressant de pouvoir enregistrer les heures de manières « sécurisé ». J’ai donc réfléchie à un moyen d’éviter de perdre les heures enregistrées pour l’ouverture et la fermeture en cas de coupure d’alimentation principale. Comme précisé dans la partie équipement, j’ai remarqué la disponibilité d’une mémoire ram non utilisée par l’horloge DS1307. Celle ci possède 56 octets de ram que j’ai pu utiliser pour enregistrer les deux alarmes. Ceci est intéressant puisqu’en cas de coupure de l’alimentation principale, l’horloge bascule sur l’alimentation par la pile lithium. Les données contenues dans la ram ne sont donc pas effacées sauf si la pile est vide (son autonomie étant néanmoins très grande, surtout que son utilisation devrait arriver très rarement).Ces 56 octets de ram sont contenus entre l’adresse 08H et 3FH (voir figure 9).Afin de gérer cette fonctionnalité, j’ai choisi d’utiliser 4 fonctions me permettant l’enregistrement et la lecture de la ram. J’ai choisi d’enregistrer l’heure d’ouverture sur les 6 premiers octets de la ram disponible et l’heure d’ouverture sur les 6 octets suivants.Voici les deux fonctions permettant d’écrire dans la ram. La fonction EcrireRam1 permet l’enregistrement de l’heure d’ouverture et la fonction EcrireRam2 l’heure de fermeture.void EcrireRam1(Date * alarme1) Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x08); Wire.write(dec2bcd(alarme1->jour)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x09); Wire.write(dec2bcd(alarme1->mois)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x0A); Wire.write(dec2bcd(alarme1->annee)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x0B); Wire.write(dec2bcd(alarme1->heures)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS);

void EcrireRam2(Date * alarme2) Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x0E); Wire.write(dec2bcd(alarme2->jour)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x0F); Wire.write(dec2bcd(alarme2->mois)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x10); Wire.write(dec2bcd(alarme2->annee)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x11); Wire.write(dec2bcd(alarme2->heures)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS);Poulailler autonome – Horloge temps réel Page 20 / 33

Page 21: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

Wire.write(0x0C); Wire.write(dec2bcd(alarme1->minutes)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x0D); Wire.write(dec2bcd(alarme1->secondes)); Wire.endTransmission();

Wire.write(0x12); Wire.write(dec2bcd(alarme2->minutes)); Wire.endTransmission();

Wire.beginTransmission(DS1307_ADDRESS); Wire.write(0x13); Wire.write(dec2bcd(alarme2->secondes)); Wire.endTransmission();

J’ai choisi d’enregistrer également la date même si celle-ci n’est pas importante pour l’ouverture et la fermeture. Cependant par soucis de compatibilité avec la structure Date, j’ai opté pour cette façon de faire.Les fonctions de lecture sont basées sur le même procédé. Vous pouvez les retrouver en annexe. A chaque fois que l’utilisateur à rentrer une nouvelle heure pour l’ouverture ou la fermeture, celle-ci est enregistrée dans la ram. Les données sont lues dans la ram à chaque démarrage de l’Arduino.Afin de savoir s’il est l’heure pour une ouverture ou une fermeture, l’Arduino effectue une comparaison en boucle de l’heure actuelle et de l’heure enregistrée. Etant donné que la comparaison se fait à la minute près, il est nécessaire de mettre en place un flag afin d’éviter que l’action ne s’effectue pendant une minute. Le flag est simplement passé à 1 lors de l’opération afin de la faire une seule fois.Lorsqu’une opération d’ouverture est effectuée, le flag pour la fermeture est remis à 0 (on autorise une fermeture si l’heure est arrivée), et vice-versa.Voici les deux fonctions d’ouverture et de fermeture :

void ouverture() if(OUV == 1) lcd.clear(); lcd.setCursor(0,0); lcd.print("Ouverture porte"); Verr.write(20); // tell servo to go to position in variable 'pos' delay(2000); Porte.write(20); // tell servo to go to position in variable 'pos' unsigned long temps = millis(); while(!digitalRead(16)) if(millis() - temps > 10000) Serial.println("Problème ouverture"); lcd.clear(); lcd.setCursor(0,0); lcd.print("Probleme"); lcd.setCursor(0,1); lcd.print("ouverture !"); delay(3000); //Porte.write(-50); delay(2000); //Verr.write(-50); OUV = 0; FER = 1;

void fermeture() if(FER == 1) lcd.clear(); lcd.setCursor(0,0); lcd.print("Fermeture porte"); Porte.write(125); // tell servo to go to position in variable 'pos' delay(200); unsigned long temps = millis(); while(!digitalRead(17)) if(millis() - temps > 10000) Serial.println("Problème fermeture"); lcd.clear(); lcd.setCursor(0,0); lcd.print("Probleme"); lcd.setCursor(0,1); lcd.print("fermeture !"); delay(3000); //Porte.write(50); delay(2000); FER = 0; OUV = 1; // fermer = 1; //ouvert = 0; lcd.clear();

Poulailler autonome – Horloge temps réel Page 21 / 33

Page 22: Real Time clock

Thomas Zorninger - Etude et implémentation

Année 2015/201628/04/2023

// ouvert = 1; // fermer = 0; lcd.clear(); return; Serial.println("Pas fin course 1"); delay(200); Serial.println("Fin de course 1"); OUV = 0; FER = 1; ouvert = 1; fermer = 0; lcd.clear();

return; Serial.println("Pas Fin de course"); Verr.write(-50); // tell servo to go to position in variable 'pos' Serial.println("Fin de course"); delay(2000); FER = 0; OUV = 1; fermer = 1; ouvert = 0; lcd.clear();

Les deux fonctions ont bien évidemment été réalisées en collaboration avec mon collègue Narcisse Kapdjou qui s’est occupé de la gestion de l’ouverture et de la fermeture de la porte. Les opérations Porte.write et Verr.write permettent la gestion des servomoteurs qui ont été choisis pour la gestion de la porte.Les affichages sur le port série nous ont permis de visualiser les opérations en cours d’exécution. Nous avons également implémenté la gestion de deux capteurs de fin de course tout ou rien nous permettant de détecter la fin d’ouverture et de fermeture de la porte.Nous avons également fait le choix d’attendre 10 secondes pendant l’ouverture et la fermeture avant de générer un message d’erreur si aucun capteur n’est activé.

4.6 Gestion de la batterieLa partie alimentation et gestion de la batterie a été réalisé par mon collègue Abhinav Kant. J’ai simplement implémenté le code qu’il ma fournit dans le programme principal.Voici le code mesurant le niveau de tension de la batterie :sensorValue = analogRead(A0); voltage = sensorValue * (5.20 / 1023.00) * 3; // print out the value you read: Serial.println(voltage); lcd.setCursor(12,0); lcd.print(voltage,1);

La tension de la batterie est ramenée à une tension mesurable par l’Arduino.

Poulailler autonome – Horloge temps réel Page 22 / 33

Page 23: Real Time clock

Thomas Zorninger - Résumé anglais Année 2015/201628/04/2023

RÉSUMÉ ANGLAIS

During the first year of the Master program Automatique Informatique Industrial (AII), I worked on a project to design and implement a solar energy based autonomous system for a henhouse. It was a collaborative project and I was a part of a team comprising of four students. With the help and support of my three colleagues Narcisse Kapdjou, Loic Metzger and Abhinav Kant, we were able to realize this project.My task was to make a programmable real time clock. The entire project was designed around an Arduino Méga and I used the DS1307 Clock for the management of time in our system.I established a user interface to allow the user to program the clock. The priority of the work strategy that I adopted was to make the whole system easy to use.Using this interface, the authorized users can define various parameters and set points for the system according to their needs. The users can manage, create and add some alarms for adequate monitoring of the system.The user can also define the conditions for opening and the closing of the door and visualize the battery level.

Page 24: Real Time clock

Thomas Zorninger - Bilan et perspectives

Année 2015/201628/04/2023

BILAN ET PERSPECTIVES

Il a été très important dans un premier temps d’étudier assez précisément le fonctionnement de l’horloge temps réel DS1307. En effet, le composant était la partie principale du projet.J’ai notamment appris qu’il stockait ses informations en BCD et que je pouvais utiliser une partie de sa mémoire afin d’enregistrer certaines données.L’utilisation d’un bus I2C a rendu les communications beaucoup plus faciles. En effet, il n’y avait besoin que de deux fils pour communiquer avec l’horloge et l’écran LCD. L’Arduino étant très utilisé et documenté par la communauté j’ai pu réutiliser et réadapter certains principes utilisés par des personnes partageant leur expérience afin de rendre la tâche plus facile.Il ne s’agit néanmoins pas de reprendre bêtement ce que quelqu’un a fait mais bien de l’adapter et surtout de comprendre ce que l’on fait et ce qu’on utilise.Une partie m’ayant un petit peu déranger est la gestion du clavier. En effet, j’ai mis en place un système de scrutation sur l’Arduino mais cela me semble très lourd à gérer et j’aurai sans doute pu gagner en efficacité en sérialisant par exemple l’interface avec le clavier. J’ai également rencontré des problèmes de rebond avec les touches du clavier que j’ai choisi de résoudre à l’aide d’un anti-rebond logiciel. Néanmoins cela ralentit également beaucoup le système.

On pourrait imaginer, pour améliorer le système, de réaliser une interface par page Web présentant le même principe que la supervision avec le clavier et l’écran mais bénéficiant de la gestion déportée du système. On peut également penser à une amélioration du système à clavier comme dit précédemment en sérialisant l’interface pour éviter un code lourd. Un système anti-rebond matériel peut aussi être envisagé pour éviter l’ajout de temporisation dans le code source.

Page 25: Real Time clock

Thomas Zorninger - Annexe Année 2015/201628/04/2023

CONCLUSION

La mise en place d’un projet collaboratif comme celui-ci est une bonne façon de mettre en œuvre toutes les compétences acquises pendant mes années de formation. La rigueur que représente un travail en équipe m’a permis d’utiliser au mieux mes acquis afin de répondre au cahier des charges.L’organisation de son temps et de son travail est une chose primordiale pour mener à bien un projet dans un temps imparti. J’ai trouvé très intéressant l’entraide qu’il y a pu y avoir entre les collaborateurs.La communication entre composants et microcontrôleur à l’aide d’un bus de données à été la pierre angulaire de mon projet. Cela implique une liaison directe avec le thème de ma formation. L’étude de la documentation de l’horloge temps réel DS1307 à également été très importante. La connaissance d’un anglais technique de base est toujours appréciable dans ces cas là.Au final, ce projet m’a permis d’acquérir des compétences en informatique industrielle, et dans la rigueur qu’un travail en équipe demande.

Poulailler autonome – Horloge temps réel Page 25 / 33

Page 26: Real Time clock

Thomas Zorninger - Annexe Année 2015/201628/04/2023

BIBLIOGRAPHIE ET WEBOGRAPHIE

DocumentationDS1307 : http://datasheets.maximintegrated.com/en/ds/DS1307.pdf

Sites internetDS1307 + LCD : https://skyduino.wordpress.com/2012/01/07/tutoriel-arduino-horloge-rtc-ds1307-librairie-liquidcryst

DS1307 :http://electroniqueamateur.blogspot.fr/2013/06/une-horloge-pour-votre-arduino-real.html

Clavier :http://playground.arduino.cc/Main/KeypadTutorialhttp://playground.arduino.cc/Main/KeypadTutorial

Arduino Méga : https://www.arduino.cc/en/Main/arduinoBoardMega2560

Poulailler autonome – Horloge temps réel Page 26 / 33

Page 27: Real Time clock

Thomas Zorninger - Annexe Année 2015/201628/04/2023

LEXIQUEBit : C'est l'unité binaire de quantité d'information qui peut représenter deux valeurs distinctes : 0 ou 1.Boot Loader : Un boot loader est un programme qui charge et démarre les tâches et processus de démarrage d’un système. Il permet de charger le système opératif dans la mémoire lors du démarrage.Bus I2C : Le bus I2C (inter-Integrated Circuit) est un bus informatique conçu par Philips pour les applications de domotique et d’électronique domestique.EEPROM : La mémoire EEPROM (Electrically-Erasable Programmable Read-Only Memory) est un type de mémoire morte. Les données dans cette mémoire ne sont donc pas effacées à la coupure de l’alimentation.Flag : En informatique, un drapeau ou flag est une valeur binaire (vraie ou fausse) indiquant le résultat d’une opération ou le statut d’un objet.Horloge temps réel : Une horloge temps réel HTR ou RTC en anglais, est une horloge permettant un décompte très précis du temps pour un système électronique, en vue de dater ou déclencher des événements selon l’heure.LCD rétro éclairé : Un écran LCD (Liquid Crystal Display) rétro éclairé est un écran utilisant une technique d’éclairage par l’arrière permettant aux écrans d’améliorer le contraste de l’affichage et d’assurer une bonne lisibilité.Mémoire flash : Une mémoire flash possède les caractéristiques d’une mémoire vive mais les données ne disparaissent pas lors de la coupure de l’alimentation.Open-source : Open source s’applique aux logiciels dont la licence est établie sur des critères de l’Open Source Initiative, c’est-à-dire incorporant les possibilités de libre redistribution, d’accès au code source et de création de travaux dérivés.Pin : Un pin désigne une patte ou broche d’un circuit intégré ou d’un composant électronique.Pull-up : Une résistance de pull-up (ou tirage) est une résistance placée entre l’alimentation et une ligne et qui amène cette ligne délibérément à l’état haut.PWM : La modulation de largeur d’impulsions (MLI) permet de générer un signal dont on va jouer sur le rapport cyclique afin de modifier la valeur moyenne de celui-ci. On peut notamment l’utiliser pour modifier la vitesse d’un moteur à courant continu.RAM : La mémoire vive est une mémoire rapide permettant d’enregistrer des données lors de leur traitement. C’est une mémoire volatile, toutes les données sont effacées à la coupure de l’alimentation.SCL : Serial CLock Line, ligne d’horloge de synchronisation bidirectionnelle du bus i2cSDA : Serial Data Line, ligne de données bidirectionnelle du bus i2cSRAM : Static Random Access Memory, est une mémoire vive statique. Elle possède les caractéristiques de la mémoire vive (perte des données à la coupure de l’alimentation) mais possède la particularité de ne pas nécessité de rafraichissement périodique de son contenu.

Poulailler autonome – Horloge temps réel Page 27 / 33

Page 28: Real Time clock

Thomas Zorninger - Annexe Année 2015/201628/04/2023

USB : L’Universal Serial Bus est une norme relative à un bus informatique en transmission série qui sert à connecter des périphériques informatiques à une ordinateur ou à tout autre appareil supportant la connexion.

Poulailler autonome – Horloge temps réel Page 28 / 33

Page 29: Real Time clock

Thomas Zorninger - Annexe Année 2015/201628/04/2023

ANNEXE

1.1 Brochage DS1307

1.2 Code de scrutation de l’appui claviervoid testappuiclavier() if(!digitalRead(14)) clavier = 10; if(!digitalRead(15)) clavier = 1; if(!digitalRead(4)) clavier = 4; if(!digitalRead(5)) clavier = 1; if(!digitalRead(6)) clavier = 0; if(!digitalRead(7)) clavier = 1; if(!digitalRead(8)) clavier = 5;

if(!digitalRead(9)) clavier = 2; app2 = 1; if(!digitalRead(10)) clavier = 11; if(!digitalRead(11)) clavier = 1; if(!digitalRead(12)) clavier = 1; if(!digitalRead(13))

clavier = 3;

Poulailler autonome – Horloge temps réel Page 29 / 33

Page 30: Real Time clock

Thomas Zorninger - Annexe Année 2015/201628/04/2023

1.3 Code d’action après appui clavier

switch(clavier) case 0: alr(); break;

case 1: affichage(&date); break;

case 2:

if(app2 == 1) lcd.clear(); //lcd.setCursor(0, 0); clr = true; // Variable pour effacer lcd lcd.print("1/ Etat porte"); lcd.setCursor(0,1); lcd.print("2/ Etat alarmes"); delay(500); app2 = 0;

while(1)

if(!digitalRead(5)) EtatP = 1; break;

if(!digitalRead(9)) EtatA = 1; break; if(!digitalRead(14)) clavier = 1; delay(500); break; else if(EtatP) EtatP = 0; lcd.clear(); lcd.setCursor(0,0); if(ouvert) lcd.print("Porte ouverte"); if(fermer) lcd.print("Porte fermee"); delay(1000); break; if(EtatA) lcd.clear(); if(alr1 == 1) //EtatA = 0; // lcd.clear(); case 3: lcd.clear(); lcd.setCursor(0, 0);

lcd.setCursor(0,0); lcd.print("Ouverture en cours"); //delay(1000); //break; if(alr1 == 0) //EtatA = 0;

lcd.setCursor(0,0); lcd.print("Pas d'alarme"); //delay(1000); // break; if(alr2 == 1) //EtatA = 0; // lcd.clear(); lcd.setCursor(0,1); lcd.print("Fermeture en cours"); delay(1000); // break; if(alr2 == 0) //EtatA = 0; //lcd.clear(); lcd.setCursor(0,1); lcd.print("Pas d'alarme"); delay(1000); // break; break; break;

case 5: lcd.clear(); lcd.setCursor(0, 0);

Poulailler autonome – Horloge temps réel Page 30 / 33

Page 31: Real Time clock

Thomas Zorninger - Annexe Année 2015/201628/04/2023

clr = true; // Variable pour effacer lcd lcd.print("Niveau batterie :"); sensorValue = analogRead(A0); voltage = sensorValue * (5.20 / 1023.00) * 3; // print out the value you read: Serial.println(voltage); lcd.setCursor(0,1); lcd.print(voltage); lcd.setCursor(5,1); lcd.print("V"); delay(3000); clavier = 1; break;

case 4: lcd.clear(); lcd.setCursor(0, 0); clr = true; // Variable pour effacer lcd lcd.print("1) Ouverture"); lcd.setCursor(0, 1); clr = true; // Variable pour effacer lcd lcd.print("2) Fermeture"); while(1) if(!digitalRead(5)) ouverture(); Serial.print("ouv"); break;

if(!digitalRead(9)) fermeture(); Serial.print("fer"); break; if(!digitalRead(14)) clavier = 1; Serial.print("sortie"); delay(500); break; clavier = 1; break;

clr = true; // Variable pour effacer lcd lcd.print("Nb Poules tot"); lcd.setCursor(13, 0); lcd.print(" 0"); //lcd.print(identification.getnbPoule()); lcd.setCursor(0, 1); clr = true; // Variable pour effacer lcd lcd.print("Nb Poules int"); lcd.setCursor(13, 1); lcd.print(" 0"); //lcd.print(identification.combienPouleInterieur()); delay(3000); clavier = 1; break;

case 10: affalr(); break;

case 11: retro(); clavier = 1; break;

default : break; if(back == true) // On teste la variable du rétroéclairage lcd.backlight(); // On active le rétroéclairage

else lcd.noBacklight(); // Sinon on le désactive

1.4 Script python# -*- coding: cp1252 -*-

Poulailler autonome – Horloge temps réel Page 31 / 33

Page 32: Real Time clock

Thomas Zorninger - Annexe Année 2015/201628/04/2023

import serial, datetime, time

# Port Série utilisez par l'arduinoSERIALPORT = "COM6"

# Vitesse du port sérieSERIALSPEED = 9600

# ---------------------------------------------------------------------

print "~ Arduino Clock - Sync Tool ~"print "Created by SkyWodd"print " "

print "Openning serial port ... ",try: arduino = serial.Serial(SERIALPORT, SERIALSPEED, timeout=1)except: print "FAILLED !" exit(-1)print "OK !"

print "Booting up arduino ... ",arduino.setDTR(level = True)time.sleep(0.5)arduino.setDTR(level = False)ligne = arduino.readline()while not "SYNC" in ligne: ligne = arduino.readline()print "Ok !"time.sleep(1)

now = datetime.datetime.now()print "Current year: %d" % int(str(now.year)[-2:])print "Current month: %d" % now.monthprint "Current day: %d" % now.dayprint "Current hour: %d" % now.hourprint "Current minute: %d" % now.minuteprint "Current second: %d" % now.second

sdow = time.strftime("%A")dow = 0if sdow == "Monday" : dow = 1if sdow == "Tuesday" : dow = 2if sdow == "Wednesday" : dow = 3if sdow == "Thursday" : dow = 4if sdow == "Friday" : dow = 5if sdow == "Saturday" : dow = 6if sdow == "Sunday" : dow = 7

print "Current Day Of Week : %d" % dow

arduino.write("ACK")arduino.write(chr(now.second))arduino.write(chr(now.minute))arduino.write(chr(now.hour))arduino.write(chr(dow))arduino.write(chr(now.day))arduino.write(chr(now.month))arduino.write(chr(int(str(now.year)[-2:])))

print "Closing serial port ... ",arduino.close()print "OK !"

print "Bye bye !"

Poulailler autonome – Horloge temps réel Page 32 / 33

Page 33: Real Time clock

Thomas Zorninger - Annexe Année 2015/201628/04/2023

1.5 Fonction de synchronisationvoid synchronisation(Date *date) Serial.print("SYNC"); // Envoi de la commande de synchronisation int i; for(i = 0 ; (Serial.available() < 3) && (i < 6) ; i++) // Attente de 3s max delay(500); if(i != 6) // Il n'y as pas eu de timeout if(Serial.read() == 'A') if(Serial.read() == 'C') if(Serial.read() == 'K') // Si le pc à répondu par une commande ACK c'est que la synchronisation peut commencer while(Serial.available() < 7); // Attente des 7 octets de configuration date->secondes = Serial.read(); // Réception et conversion des données reçu date->minutes = Serial.read(); date->heures = Serial.read(); date->jourDeLaSemaine = Serial.read(); date->jour = Serial.read(); date->mois = Serial.read(); date->annee = Serial.read(); ecrire(date); // Stockage dans le DS1307 des donnees reçues else lire(date); // Si le pc n'as pas répondu à la demande de synchronisation la fonction se contente de lire les données du DS1307

>>>>>>>>>>FIN DE DOCUMENT<<<<<<<<<<

Poulailler autonome – Horloge temps réel Page 33 / 33