Real Time Clock

Rapport projet
Master 1 AII
Anne 2015/2016
Projet collaboratif :
Ralisation d'un poulailler autonome
Module 3 : tude et ralisation

d'une horloge temps rel
programmable
tudiant : Thomas Zorninger

Enseignant tuteur : Gilles Hermann
Collaborateurs : Narcisse Kapdjou
Loc Metzger
Abhinav Kant
Thomas Zorninger - Introduction
Anne 2015/2016
16/05/2016
REMERCIEMENTS
Je tiens remercier, en premier lieu, mon enseignant tuteur Monsieur Gilles
HERMANN. Ses conseils et son soutien mont t importants dans lavancement
et la mise au point de mon projet, merci pour son aide et le suivi quil ma
apport.
Mes remerciements vont galement mes collgues Narcisse Kapdjou, Loic Metzger
et Abhinav Kant avec lesquels jai men bien ce projet collaboratif.
Je remercie galement mes collgues de formation pour leurs ides et leur aide.
Enfin, je remercie les enseignants de ma formation pour les connaissances quils
nous ont inculques tout au long de lanne.
Poulailler autonome Horloge temps rel
Page 2 / 32
SOMMAIRE
REMERCIEMENTS..........................................................................................................................................2
SOMMAIRE.......................................................................................................................................................3
TABLE DES ILLUSTRATIONS.......................................................................................................................4
1.
INTRODUCTION........................................................................................................................................5
2.
LE PROJET..................................................................................................................................................6
2.1
2.2
2.3
Dfinition gnrale du projet.....................................................................................................................6

Fonctionnement envisag..........................................................................................................................6
Cahier des charges.....................................................................................................................................6
3.
EQUIPEMENT.............................................................................................................................................7
3.1
3.2
3.3
3.4
Horloge temps rel DS1307........................................................................................................................7

Clavier matriciel 3x4..................................................................................................................................7
Ecran LCD rtro clair 16x2.....................................................................................................................8
Arduino.......................................................................................................................................................8
3.4.1
3.4.2
Arduino Mega.................................................................................................................................................................... 9
IDE Arduino.....................................................................................................................................................................10
4.
ETUDE ET IMPLMENTATION............................................................................................................11
4.1
4.2
4.3
Communication I2C..................................................................................................................................11
Horloge temps rel DS1307......................................................................................................................12
Acquisition appui clavier..........................................................................................................................15
4.3.1
4.4
4.5
4.6
Utilisation des touches......................................................................................................................................................... 15
Ecran LCD rtro clair............................................................................................................................16

Gestion ouverture/fermeture.....................................................................................................................20
Gestion de la batterie................................................................................................................................22
RSUM ANGLAIS........................................................................................................................................23
BILAN ET PERSPECTIVES..........................................................................................................................24
CONCLUSION.................................................................................................................................................25
BIBLIOGRAPHIE ET WEBOGRAPHIE.....................................................................................................26
LEXIQUE.........................................................................................................................................................27
ANNEXE...........................................................................................................................................................29
1.1
1.2
1.3
1.4
1.5
Brochage DS1307.....................................................................................................................................29
Code de scrutation de lappui clavier........................................................................................................29
Code daction aprs appui clavier.............................................................................................................30
Script python.............................................................................................................................................32
Fonction de synchronisation.....................................................................................................................33
TABLE DES ILLUSTRATIONS

Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
1:
2:
3:
4:
5:
6:
7:
8:
9:
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Image DS1307.................................................................................................... 7
Image clavier...................................................................................................... 7
Image cran LCD................................................................................................ 8
Image Arduino Mga........................................................................................... 9
Tableau caractristiques Arduino Mga..............................................................9
Capture cran IDE Arduino................................................................................ 10
Codage NRZ pour bus I2C................................................................................. 11
Schma de principe communication Arduino / DS1307....................................12
Organisation mmoire DS1307.........................................................................13
: Interfaage Arduino/Clavier............................................................................ 15
: Schma de principe communication Arduino / Ecran LCD..............................16
: Photo Affichage par dfaut............................................................................. 17
: Photo Appui touche *...................................................................................... 17
: Photo Appui sur 1 aprs touche *...................................................................17
: Photo Appui sur 2 aprs touche *...................................................................17
: Photo Appui sur autre alarme configurer aprs touche *................................17
: Photo Appui touche 0...................................................................................... 18
: Photo entrez heure......................................................................................... 18
: Photo entrez minutes...................................................................................... 18
: Photo menu gestion systme..........................................................................19
: Photo tat porte.............................................................................................. 19
: Photo tat alarmes.......................................................................................... 19
: Photo niveau batterie..................................................................................... 19
: Photo ouverture/fermeture............................................................................. 19
: Photo nombre poules...................................................................................... 19
1. INTRODUCTION
Lorsque lon souhaite raliser un systme autonome, il est ncessaire de faire en
sorte que celui-ci soit assez intelligent pour grer, de manire automatique et
sans interventions extrieures, certaines tches ou certains travaux que lon
souhaite lui confier.
Un systme dit autonome est habituellement compos de deux parties :
-
Une partie commande : Cest cette partie qui donne les ordres et reoit des
informations de lextrieur (dun autre systme par exemple) ou de la partie
oprative (voir ci-dessous). La partie commande est gnralement articule
autour dun microprocesseur ou dune ordinateur.
Une partie oprative : Cest cette partie qui va effectuer les tches. Elle
reoit les ordres de la partie commande et les excutent. La partie
oprative contient gnralement les capteurs et les actionneurs.
Il est nanmoins important de faire la distinction entre un systme autonome et

un systme intelligent.
Un systme intelligent est un systme qui est capable de prendre des dcisions
tout seul, bnficiant dune capacit dapprentissage et ralisant des tches en
consquence. Un systme intelligent est autonome mais un systme autonome
nest pas forcment intelligent.
Un systme autonome tel qutudier et raliser dans ce projet nest pas
intelligent. Cest--dire quil naura aucune capacit dapprentissage. Il pourra
nanmoins prendre certaines dcisions programmes en fonction de ltat des
diffrentes parties du systme.
Le systme tudi dans ce projet est un poulailler autonome. Il aura pour but la
mise en place de plusieurs sous-systmes permettant le fonctionnement efficace
de lensemble. On peut citer notamment la mise en place dune alimentation
solaire, dune porte automatique ou encore la ralisation dun compteur de
poules.
Dans ce rapport, nous verrons la partie Etude et ralisation dune horloge
temps rel programmable .
2. LE PROJET
2.1
Dfinition gnrale du projet
Ce projet porte sur ltude et la ralisation dun poulailler autonome. Pour

ce faire, le poulailler comportera plusieurs parties ralises par chaque membre
du projet.
Cest pour cela quil est essentiel que chaque partie ne soit pas compltement
indpendante. Par exemple, lalimentation solaire permettra dalimenter chaque
sous systme.
2.2
Fonctionnement envisag
Le fonctionnement final envisag devra permettre la gestion autonome dun

poulailler. Cest--dire quil ne doit pas y avoir la ncessit dune action extrieure
pour assur un bon fonctionnement.
On verra cependant quun utilisateur pourra superviser lensemble du systme. Il
pourra notamment visualiser ltat des diffrentes parties (niveau de batterie par
exemple) ainsi que les alarmes (heure douverture et de fermeture de la porte par
exemple).
Le but final sera galement larticulation de tous les sous systmes autour dun
seul Arduino Mga. Celui-ci servira donc de partie commande du systme global.
Pour la partie horloge temps rel, le projet se basera sur une horloge DS1307
permettant lenregistrement de la date et lheure. Linterface avec lutilisateur se
fera laide dun clavier 3x4 ainsi quun cran LCD rtro clair.
2.3
Cahier des charges
La gestion de la date et lheure sarticulera autour dune horloge temps rel

DS1307. Elle doit permettre notamment en cas de coupure dalimentation de
garder en mmoire la date et lheure courante (pile lithium incluse permettant le
basculement sur alimentation secondaire).
Linterface avec lutilisateur se fera laide dun clavier 3x4 et dun cran LCD
16x2. Laffichage devra permettre la visualisation de la date et lheure, ltat des
diffrentes parties du systme (porte, niveau batterie, nombre de poules), la
gestion des alarmes (heure douverture et fermeture de la porte et autres).
Cette interface devra tre intuitive et concise puisque lcran 16x2 limite le
nombre dlments affichs lcran.
Bien videmment, toutes ces parties seront gres par un Arduino Mga.
3. EQUIPEMENT
3.1 Horloge temps rel DS1307
Pour la gestion de la date et lheure, on utilisera une horloge temps rel DS1307.
Cette
horloge
possde
lavantage
de
sa
facilit
dutilisation grce au bus I2C.
Vous trouverez le brochage du
composant en Annexe 1.1.
Figure 1 : Image DS1307
Elle possde galement une

RAM non utilise par le
composant
qui
va
nous
permettre denregistrer certains
tats ou variables critiques
en
cas
de
coupure
dalimentation principale.
On remarque
galement
3.2
Clavier matriciel
3x4la prsence dune pile lithium 3.6V servant
dalimentation secondaire en cas de coupure de lalimentation principale.
On verra dans la partie tude comment communiquer avec le composant et on

analysera galement le format des donnes enregistres.
Lutilisateur pourra interagir avec le systme grce un clavier 3x4.
Ce clavier 3 colonnes, 4 lignes va
permettre linterfaage avec lutilisateur.
nous
Grce celui-ci, lutilisateur sera capable de

grer le systme global (visualisation des tats,
gestions des heures et alarmes, ).
Comme on peut le remarquer sur limage cicontre, le clavier possde 13 pins de sortie.
Chaque pin correspond une touche et un pin
servira de point commun.
On verra, dans la partie tude, lassociation
touche/pin.
On
laborera
galement
linterfaage avec lArduino. En effet, on aura la
ncessit dutiliser 12 entres numriques de
lArduino.
Figure 2 : Image clavier
3.3 Ecran LCD rtro clair 16x2
Lutilisateur aura la possibilit de visualiser certaines informations du systme

grce un cran LCD rtro clair.
Cet cran LCD rtro clair permettra
lutilisateur de visualiser de
manire simple et efficace les
informations importantes concernant
le systme.
Figure 3 : Image cran LCD
Lcran affichera par dfaut la date

et lheure.
Celui-ci possde lavantage dintgrer un module I2C pour sa communication.

Deux fils suffiront donc sa commande (plus lalimentation).
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 lutilisateur puisse bnficier dune interface claire et ergonomique.
3.4 Arduino
Arduino est une plate-forme de prototypage lectronique open-source cre

par une quipe de dveloppeurs, compose de six personnes : Massimo Banzi,
David Cuartielles, Tom Igoe, Gianluca Martino, David Mellis et Nicholas Zambetti.
Cette quipe a cr le systme Arduino . Cest un outil qui permet aux
dbutants, amateurs ou professionnels de crer des systmes lectroniques plus
ou moins complexes.
3.4.1 Arduino Mega
Figure 4 : Image Arduino Mga
Figure 5 : Tableau caractristiques

Arduino Mga
LArduino Mga est une carte base sur un microcontrleur ATmega2560.
La carte possde 56 entres/sorties numriques (dont 15 pouvant tre utilises

en PWM), 16 entres analogiques (chacune connecte un convertisseur
analogique/numrique sur 10 bits), un quartz cadenc 16 Mhz, une connexion
USB, une alimentation jack et un bouton reset (rinitialisation).
LArduino Mga 2560 est une mise jour de lArduino Mga.
Sa tension de fonctionnement est 5V et elle supporte une alimentation continue
de 20V maximum. Elle possde une mmoire flash de 256Ko (dont 8 Ko utiliss
par le boot loader) une SRAM de 8Ko et une EEPROM de 4Ko.
3.4.2 IDE Arduino

LIDE
Arduino
(Integrated
Development Environment) est
un
environnement
de
dveloppement open-source
crit en Java.
Cest ce logiciel qui va nous
permettre la programmation de
notre microcontrleur.
La cration de librairie ce fait
en
langage
C++
et
la
programmation en langage C.
Il est ncessaire daller dans
Outils Type de carte puis de
choisir la carte que lon
souhaite utiliser.
Figure 6 : Capture cran IDE Arduino
4. ETUDE ET IMPLMENTATION
4.1 Communication I2C
Le bus I2C est un bus de donnes synchrone.
Plusieurs quipements, soit matres, soit esclaves, peuvent tre connects au
bus.
Il comprend trois fils :
-
Un signal de donnes (appel SDA),
Un signal dhorloge (appel SCL, permettant le cadenage de lenvoi des

donnes),
Un signal de rfrence lectrique (masse).
Le codage des bits est de type NRZ (non retour 0).

Voici la reprsentation 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 connects 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 cbls sur le bus par le principe de ET cbl , ce
qui veut dire quen cas dmission simultane de 2 quipements, la valeur 0
crase la valeur 1.
On dit donc :
-
Que ltat logique 0 ou Low est ltat dominant .
Que ltat logique 1 ou High est ltat rcessif .
Lorsque le bus nest pas utilis, il est au niveau haut ( travers une ou des
rsistance(s) de pull-up).
4.2 Horloge temps rel DS1307
Comme
nous
lavons
vu
prcdemment, lhorloge temps
rel DS1307 possde un module
I2C
nous
permettant
la
communication avec celle-ci via
une bibliothque disponible sur
lArduino.
Dans le schma de principe cicontre, on admet que lArduino
Mga sera le matre et le DS1307
lesclave.
Les deux rsistances R sont des
rsistances de pull-up de valeur
1K.
Figure 8 : Schma de principe communication Pour la communication entre les
Arduino / DS1307
quipements, chaque esclave est
dfini par une adresse.
Le DS1307 est dfini par ladresse 0x68. Cette adresse permettra au matre de
communiquer avec un esclave spcifique.
Par exemple, on verra que lcran LCD que nous utiliserons aussi en I2C aura
ladresse 0x20.
Le module DS1307 contient 63 octets de RAM. Sur ces 63 octets, 7 contiennent la
date et lheure (incrments automatiquement), plus un 8 me octet pour la
configuration du DS1307. Les 56 octets restants sont un bonus o on pourra y
stocker des donnes dusage (variables et tats importants par exemple).
Voici un extrait de la documentation constructeur dtaillant lorganisation interne

de la ram du DS1307 :
Figure 9 : Organisation mmoire DS1307

On remarque que les informations sur la date et lheure sont contenues entre
ladresse 00H et 07H (7 octets). La valeur de ces adresses est importante
puisquelle nous permettra de communiquer avec lhorloge.
La bibliothque qui nous permettra de grer cette communication I2C est Wire.
On verra que pour nous faciliter la tche, la communication avec lcran LCD se
fera avec la bibliothque LiquidCrystal_I2C.
La particularit du DS1307 est que les informations sur la date et lheure sont
enregistrs dans un format BCD.
Le BCD (dcimal 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 indpendamment, 63 donnera donc 6(0110) et 3(0011)
0110 0011.
Il va donc falloir convertir cette valeur BCD en dcimal pour la lecture et convertir
une valeur dcimale en BCD pour lcriture.
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 dcimale. On ralise lopration inverse pour la conversion
dcimale/BCD.
Elle
va
nos
permettre
lenregistrement de la date et
lheure
retourne
par
lhorloge.
On lutilisera galement pour
enregistrer certaines alarmes
comme lheure douverture et
de fermeture.
Pour stocker les valeurs que lon rcuprera du DS1307, on utilisera une structure
dfinie comme suit :
Une particularit prendre en compte est quil est impossible de dfinir une
structure en la dclarant dans un sketch. Il faut au pralable la placer dans un
fichier den-tte que lon placera dans le mme dossier que le programme
principal.
Grce cela on peut maintenant dfinir deux fonctions dcriture et de lecture de
la ram de lhorloge :
Afin denregistrer initialement la date et lheure, on utilisera un script python

communiquant avec lArduino via le port srie. Ce script permettra de lire lheure
et le date sur lordinateur afin de la transmettre lArduino qui se chargera de
lenregistrer dans lhorloge temps rel. Vous trouverez en Annexe 1.4 le code
python correspondant.
LArduino utilisera une fonction de synchronisation pour lenregistrement. Vous
trouverez le code de cette fonction en Annexe 1.5.
4.3 Acquisition appui clavier
Le clavier que lon utilisera

est un clavier utilisant 13
pins. Un pin de point
commun (GND) et 12 pins
relis chacun une touche
du clavier.
Cette particularit implique
lutilisation de 12 entres
numriques de lArduino
afin de dtecter un appui
sur chaque touche.
Grce lArduino mga, on
bnficie
dun
grand
nombre dentres et pour
notre application il ne sera
pas ncessaire dutiliser un
autre procd de dtection
dappui.
Figure 10 : Interfaage Arduino/Clavier
En effet il aurait t
ventuellement possible de
srialis linterface ou bien
plus simplement de ne pas
utiliser certaines touches du
clavier.
Certains claviers matriciels prsentent lavantage dutiliser moins de broches.

Le clavier que lon utilisera sera donc une simple association de boutons
poussoirs. On utilisera une fonction de scrutation afin de dtecter un appui
ventuel de lutilisateur. Vous trouverez le code de cette fonction en Annexe 1.2.
LArduino ne bnficie pas dassez dentres dinterruption pour utiliser le clavier
en interruption.
4.3.1 Utilisation des touches

On se place dans le cas ou laffichage est en mode par dfaut (voir Partie cran
LCD rtro clair pour la dfinition du mode).
La touche # : Grce cette touche, lutilisateur peut activer ou dsactiv le rtro
clairage de lcran LCD. En effet, lcran consomme beaucoup plus lorsque le
rtro clairage est activ.
La touche * : Cette touche permet lutilisateur de rentrer dans la visualisation
des alarmes qui ont t configures. Une fois dans ce mode, lutilisateur peut
utiliser les chiffres du clavier pour accder lalarme correspondante. Les chiffres
1 et 2 correspondent respectivement louverture et la fermeture. Le reste
peut tre configur selon les besoins de lutilisateur. Un appui sur * annule toute
action ou modification en cours et ramne laffichage ltat par dfaut.
La touche 0 : Cette touche permet lutilisateur de rentrer dans la configuration

des alarmes. Une fois dans ce mode, lutilisateur peut utiliser les chiffres du
clavier pour accder lalarme quil souhaite modifier. Les chiffres 1et 2
correspondent respectivement louverture et la fermeture. Lutilisateur pourra
modifier lheure douverture ou de fermeture grce au clavier. Il pourra indiquer la
date et lheure dautres alarmes ventuelles. Un appui sur * annule toute action
ou modification en cours et ramne laffichage ltat par dfaut.
La touche 1 : Cette touche permet de revenir laffichage par dfaut.
La touche 2 : Cette touche permet daccder au menu de visualisation de ltat
du systme. Dans ce mode, la touche 1 permet daccder ltat de la porte
(ouverte ou ferme), la touche 2 permet de visualiser ltat des alarmes
(ouverture, fermeture ou autres). Un appui sur * annule toute action ou
modification en cours et ramne laffichage ltat par dfaut.
La touche 3 : Cette touche permet daccder ltat de la batterie. Un appui sur *
annule toute action ou modification en cours et ramne laffichage ltat par
dfaut.
La touche 4 : Cette touche permet lutilisateur daccder la gestion de la
porte. Un appui sur la touche 1 permet louverture de la porte sauf si celle-ci est
dj ouverte. Un appui sur la touche 2 permet la fermeture de la porte sauf si
celle-ci est dj ferme.
Vous trouverez le code daction aprs lappui sur le clavier en Annexe 1.3.
4.4 Ecran LCD rtro clair

Comme
nous
lavons
vu
prcdemment,
lcran
LCD
rtro clair est pilot par un
module I2C.
Dans le schma de principe cicontre, on admet que lArduino
Mga sera le matre et lcran
LCD lesclave.
Les deux rsistances R sont des
rsistances de pull-up de valeur
1K.
Pour la communication entre les
quipements, chaque esclave
est dfini par une adresse.
Figure 11 : Schma de principe communication Lcran LCD est dfini par
Arduino / Ecran LCD
ladresse 0x20. Cette adresse
nous
permettra
de
communiquer avec lcran.
Il est maintenant ncessaire de se poser la question suivante : Quelles
informations va-t-on afficher sur lcran ?
En effet, lespace disponible pour laffichage par dfaut est limit et il est
ncessaire dafficher les informations utiles en priorit.
Jai choisi dafficher par dfaut les informations suivantes :

-
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 grce cet affichage une

information globale sur le systme.
Figure 12 : Photo Affichage par dfaut
Ecran LCD
Nous allons maintenant voir les diffrents menus que lutilisateur peut ouvrir
partir de laffichage par dfaut grce aux touches du clavier dfinies
prcdemment.
Figure 13 : Photo Appui touche *
Lorsque lon se trouve dans le mode

affichage par dfaut , on peut entrer
dans
le menu de visualisation des
alarmes en appuyant sur la touche * du
clavier. On visualise ensuite lcran cicontre (figure 13).
Une fois dans ce menu, un appui sur la
touche 1 permet la visualisation de
lheure douverture de la porte (figure
14).
Figure 14 : Photo Appui sur 1 aprs

touche *
Un appui sur la touche 2 permet la
visualisation de lheure de fermeture de
la porte (figure 15).
Figure 15 : Photo Appui sur 2 aprs
touche *
Figure 16 : Photo Appui sur autre

alarme configurer aprs touche *
Un appui sur un autre chiffre (3 9

configur avec une alarme) permet la
visualisation de la date et lheure de
lalarme correspondante (figure 16).
Figure 17 : Photo Appui touche 0

dans le menu de configuration des
alarmes en appuyant sur la touche 0 du
clavier. On visualise ensuite lcran cicontre (figure 17).
touche 1 permet la configuration de
lheure douverture de la porte (figure
18).
Figure 18 : Photo entrez heure
Cette figure prsente le moment ou

lutilisateur doit entrer lheure.
La figure 19 ci-contre prsente le
moment ou lutilisateur doit entrer les
minutes.
Figure 19 : Photo entrez minutes
Le mme procd est suivi pur la

modification de lheure de fermeture.
Si lutilisateur souhaite modifier une alarme qui nest pas lheure douverture ou
de fermeture, il devra entrer dans un premier temps, la date.
Un des problmes rencontr pendant la mise en place du code grant les entres
de lutilisateur est le fait de devoir rentrer des dates et heures cohrentes. En
effet, Lheure doit tre comprise entre 00h00 et 23h59. Lutilisateur ne pourra pas
entrer 24h78 par exemple.
Au niveau des dates, jai fait le choix de ne pas pouvoir entrer une anne
antrieure 2016 (anne en cours). Bien videmment, de la mme manire que
lheure, les dates doivent restes cohrentes. Impossible, par exemple, de
configurer une date pour le 56/80/2010.
Jai galement fait le choix de ne pas laisser lutilisateur la possibilit de grer
les secondes. Dans notre application, la gestion du temps la seconde prs nest
pas ncessaire.
Figure 20 : Photo menu gestion

systme
Figure 21 : Photo tat porte

dans le menu de visualisation de ltat
du systme en appuyant sur la touche
2 du clavier. On visualise ensuite
lcran ci-contre (figure 20).
touche 1 permet la visualisation de
ltat de la porte (figure 21).
Un appui sur la touche 2 permet la
visualisation de ltat des alarmes
(figure 22).
Figure 22 : Photo tat alarmes
Figure 23 : Photo niveau batterie

dans le menu de visualisation de ltat
de la batterie en appuyant sur la
touche 3 du clavier. On visualise
ensuite lcran ci-contre (figure 23).
Le niveau de batterie ci-dessus, nest pas reprsentatif. Cette valeur est une
valeur alatoire mesure sur une entre analogique de lArduino.
La vraie valeur du niveau de la batterie sera visualisable lorsque celle-ci sera
implmente dans le systme.
Figure 24 : Photo ouverture/fermeture

dans le menu de gestion la porte en
appuyant sur la touche 4 du clavier. On
visualise ensuite lcran ci-contre
(figure 24).
Ceci permet lutilisateur de grer manuellement la porte.
Figure 25 : Photo nombre poules

dans la visualisation du nombre de
poule total et lintrieur du poulailler.
On visualise lcran ci-contre (figure
25).
La partie gestion du nombre de poule est gre par mon collgue Loc Metzger.
4.5 Gestion ouverture/fermeture

Afin de grer louverture et la fermeture de la porte il est intressant de pouvoir
enregistrer les heures de manires scuris . Jai donc rflchie un moyen
dviter de perdre les heures enregistres pour louverture et la fermeture en cas
de coupure dalimentation principale.
Comme prcis dans la partie quipement, jai remarqu la disponibilit dune
mmoire ram non utilise par lhorloge DS1307. Celle ci possde 56 octets de
ram que jai pu utiliser pour enregistrer les deux alarmes.
Ceci est intressant puisquen cas de coupure de lalimentation principale,
lhorloge bascule sur lalimentation par la pile lithium. Les donnes contenues
dans la ram ne sont donc pas effaces sauf si la pile est vide (son autonomie
tant nanmoins trs grande, surtout que son utilisation devrait arriver trs
rarement).
Ces 56 octets de ram sont contenus entre ladresse 08H et 3FH (voir figure 9).
Afin de grer cette fonctionnalit, jai choisi dutiliser 4 fonctions me permettant
lenregistrement et la lecture de la ram.
Jai choisi denregistrer lheure douverture sur les 6 premiers octets de la ram
disponible et lheure douverture sur les 6 octets suivants.
Voici les deux fonctions permettant dcrire dans la ram. La fonction EcrireRam1
permet lenregistrement de lheure douverture et la fonction EcrireRam2 lheure
de fermeture.
void EcrireRam1(Date * alarme1)
void EcrireRam2(Date * alarme2)
{
Wire.beginTransmission(DS1307_ADDRESS);
Wire.write(0x08);
Wire.write(0x0E);
Wire.write(dec2bcd(alarme1->jour));
Wire.write(dec2bcd(alarme2->jour));
Wire.endTransmission();
Wire.write(0x09);
Wire.write(0x0F);
Wire.write(dec2bcd(alarme1->mois));
Wire.write(dec2bcd(alarme2->mois));
Wire.write(0x0A);
Wire.write(0x10);
Wire.write(dec2bcd(alarme1->annee));
Wire.write(dec2bcd(alarme2->annee));
Wire.write(0x0B);
Wire.write(0x11);
Wire.write(dec2bcd(alarme1->heures));
Wire.write(dec2bcd(alarme2->heures));
Wire.write(0x0C);
Wire.write(0x12);
Wire.write(dec2bcd(alarme1->minutes));
Wire.write(dec2bcd(alarme2->minutes));
Wire.write(0x0D);
Wire.write(0x13);
Wire.write(dec2bcd(alarme1->secondes));
Wire.write(dec2bcd(alarme2->secondes));
Jai choisi denregistrer galement la date mme si celle-ci nest pas importante
pour louverture et la fermeture. Cependant par soucis de compatibilit avec la
structure Date, jai opt pour cette faon de faire.
Les fonctions de lecture sont bases sur le mme procd. Vous pouvez les
retrouver en annexe.
A chaque fois que lutilisateur rentrer une nouvelle heure pour louverture ou la
fermeture, celle-ci est enregistre dans la ram. Les donnes sont lues dans la ram
chaque dmarrage de lArduino.
Afin de savoir sil est lheure pour une ouverture ou une fermeture, lArduino
effectue une comparaison en boucle de lheure actuelle et de lheure enregistre.
Etant donn que la comparaison se fait la minute prs, il est ncessaire de
mettre en place un flag afin dviter que laction ne seffectue pendant une
minute. Le flag est simplement pass 1 lors de lopration afin de la faire une
seule fois.
Lorsquune opration douverture est effectue, le flag pour la fermeture est
remis 0 (on autorise une fermeture si lheure est arrive), et vice-versa.
Voici les deux fonctions douverture 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);
variable 'pos'
unsigned long temps = millis();
while(!digitalRead(16)){
if(millis() - temps > 10000)
{
Serial.println("Problme 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;
// ouvert = 1;
// fermer = 0;
lcd.clear();
return;
}
Serial.println("Pas fin course 1");
}
void fermeture()
{
if(FER == 1)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Fermeture porte");
Porte.write(125);
variable 'pos'
delay(200);
unsigned long temps = millis();
while(!digitalRead(17)){
if(millis() - temps > 10000)
{
Serial.println("Problme 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();
return;
}
Serial.println("Pas Fin de course");}
Verr.write(-50);
variable 'pos'
Serial.println("Fin de course");
delay(2000);
delay(200);
Serial.println("Fin de course 1");
OUV = 0;
FER = 1;
ouvert = 1;
fermer = 0;
lcd.clear();
}
FER = 0;
OUV = 1;
fermer = 1;
ouvert = 0;
lcd.clear();
}
}
Les deux fonctions ont bien videmment t ralises en collaboration avec mon
collgue Narcisse Kapdjou qui sest occup de la gestion de louverture et de la
fermeture de la porte. Les oprations 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 srie nous ont permis de visualiser les oprations en
cours dexcution. Nous avons galement implment la gestion de deux
capteurs de fin de course tout ou rien nous permettant de dtecter la fin
douverture et de fermeture de la porte.
Nous avons galement fait le choix dattendre 10 secondes pendant louverture
et la fermeture avant de gnrer un message derreur si aucun capteur nest
activ.
4.6 Gestion de la batterie

La partie alimentation et gestion de la batterie a t ralis par mon collgue
Abhinav Kant. Jai simplement implment le code quil 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 ramene

une tension mesurable par lArduino.
RSUM 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 Mga 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.
BILAN ET PERSPECTIVES
Il a t trs important dans un premier temps dtudier assez prcisment le
fonctionnement de lhorloge temps rel DS1307. En effet, le composant tait la partie
principale du projet.
Jai notamment appris quil stockait ses informations en BCD et que je pouvais utiliser
une partie de sa mmoire afin denregistrer certaines donnes.
Lutilisation dun bus I2C a rendu les communications beaucoup plus faciles. En effet, il
ny avait besoin que de deux fils pour communiquer avec lhorloge et lcran LCD.
LArduino tant trs utilis et document par la communaut jai pu rutiliser et
radapter certains principes utiliss par des personnes partageant leur exprience afin
de rendre la tche plus facile.
Il ne sagit nanmoins pas de reprendre btement ce que quelquun a fait mais bien de
ladapter et surtout de comprendre ce que lon fait et ce quon utilise.
Une partie mayant un petit peu dranger est la gestion du clavier. En effet, jai mis en
place un systme de scrutation sur lArduino mais cela me semble trs lourd grer et
jaurai sans doute pu gagner en efficacit en srialisant par exemple linterface avec le
clavier.
Jai galement rencontr des problmes de rebond avec les touches du clavier que jai
choisi de rsoudre laide dun anti-rebond logiciel. Nanmoins cela ralentit galement
beaucoup le systme.
On pourrait imaginer, pour amliorer le systme, de raliser une interface par page Web
prsentant le mme principe que la supervision avec le clavier et lcran mais
bnficiant de la gestion dporte du systme.
On peut galement penser une amlioration du systme clavier comme dit
prcdemment en srialisant linterface pour viter un code lourd. Un systme antirebond matriel peut aussi tre envisag pour viter lajout de temporisation dans le
code source.
CONCLUSION
La mise en place dun projet collaboratif comme celui-ci est une bonne faon de mettre
en uvre toutes les comptences acquises pendant mes annes de formation.
La rigueur que reprsente un travail en quipe ma permis dutiliser au mieux mes acquis
afin de rpondre au cahier des charges.
Lorganisation de son temps et de son travail est une chose primordiale pour mener
bien un projet dans un temps imparti.
Jai trouv trs intressant lentraide quil y a pu y avoir entre les collaborateurs.
La communication entre composants et microcontrleur laide dun bus de donnes
t la pierre angulaire de mon projet. Cela implique une liaison directe avec le thme de
ma formation.
Ltude de la documentation de lhorloge temps rel DS1307 galement t trs
importante. La connaissance dun anglais technique de base est toujours apprciable
dans ces cas l.
Au final, ce projet ma permis dacqurir des comptences en informatique industrielle,
et dans la rigueur quun travail en quipe demande.
BIBLIOGRAPHIE ET WEBOGRAPHIE
Documentation
DS1307 : http://datasheets.maximintegrated.com/en/ds/DS1307.pdf
Sites internet
DS1307 + LCD : https://skyduino.wordpress.com/2012/01/07/tutoriel-arduinohorloge-rtc-ds1307-librairie-liquidcryst
DS1307 :http://electroniqueamateur.blogspot.fr/2013/06/une-horloge-pour-votrearduino-real.html
Clavier :http://playground.arduino.cc/Main/KeypadTutorialhttp://playground.arduin
o.cc/Main/KeypadTutorial
Arduino Mga : https://www.arduino.cc/en/Main/arduinoBoardMega2560
LEXIQUE
Bit : C'est l'unit binaire de quantit d'information qui peut reprsenter deux
valeurs distinctes : 0 ou 1.
Boot Loader : Un boot loader est un programme qui charge et dmarre les tches
et processus de dmarrage dun systme. Il permet de charger le systme
opratif dans la mmoire lors du dmarrage.
Bus I2C : Le bus I2C (inter-Integrated Circuit) est un bus informatique conu par
Philips pour les applications de domotique et dlectronique domestique.
EEPROM : La mmoire EEPROM (Electrically-Erasable Programmable Read-Only
Memory) est un type de mmoire morte. Les donnes dans cette mmoire ne
sont donc pas effaces la coupure de lalimentation.
Flag : En informatique, un drapeau ou flag est une valeur binaire (vraie ou fausse)
indiquant le rsultat dune opration ou le statut dun objet.
Horloge temps rel : Une horloge temps rel HTR ou RTC en anglais, est une
horloge permettant un dcompte trs prcis du temps pour un systme
lectronique, en vue de dater ou dclencher des vnements selon lheure.
LCD rtro clair : Un cran LCD (Liquid Crystal Display) rtro clair est un cran
utilisant une technique dclairage par larrire permettant aux crans
damliorer le contraste de laffichage et dassurer une bonne lisibilit.
Mmoire flash : Une mmoire flash possde les caractristiques dune mmoire
vive mais les donnes ne disparaissent pas lors de la coupure de lalimentation.
Open-source : Open source sapplique aux logiciels dont la licence est tablie sur
des critres de lOpen Source Initiative, cest--dire incorporant les possibilits de
libre redistribution, daccs au code source et de cration de travaux drivs.
Pin : Un pin dsigne une patte ou broche dun circuit intgr ou dun composant
lectronique.
Pull-up : Une rsistance de pull-up (ou tirage) est une rsistance place entre
lalimentation et une ligne et qui amne cette ligne dlibrment ltat haut.
PWM : La modulation de largeur dimpulsions (MLI) permet de gnrer un signal
dont on va jouer sur le rapport cyclique afin de modifier la valeur moyenne de
celui-ci. On peut notamment lutiliser pour modifier la vitesse dun moteur
courant continu.
RAM : La mmoire vive est une mmoire rapide permettant denregistrer des
donnes lors de leur traitement. Cest une mmoire volatile, toutes les donnes
sont effaces la coupure de lalimentation.
SCL : Serial CLock Line, ligne dhorloge de synchronisation bidirectionnelle du bus
i2c
SDA : Serial Data Line, ligne de donnes bidirectionnelle du bus i2c
SRAM : Static Random Access Memory, est une mmoire vive statique. Elle
possde les caractristiques de la mmoire vive (perte des donnes la coupure
de lalimentation) mais possde la particularit de ne pas ncessit de
rafraichissement priodique de son contenu.
USB : LUniversal Serial Bus est une norme relative un bus informatique en
transmission srie qui sert connecter des priphriques informatiques une
ordinateur ou tout autre appareil supportant la connexion.
ANNEXE
1.1
Brochage DS1307
1.2
Code de scrutation de lappui clavier
void testappuiclavier(){
if(!digitalRead(14))
clavier = 10;
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;
1.3
if(!digitalRead(9))
{
clavier = 2;
app2 = 1;
}
clavier = 11;
clavier = 1;
clavier = 1;
clavier = 3;
Code daction aprs 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;
}
{
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.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(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.print("Nb Poules tot");
lcd.print(" 0");
//lcd.print(identification.getnbPoule());
lcd.setCursor(5,1);
lcd.print("V");
delay(3000);
clavier = 1;
break;
case 4:
lcd.clear();
lcd.print("1) Ouverture");
lcd.print("2) Fermeture");
while(1)
{
if(!digitalRead(5))
{
ouverture();
Serial.print("ouv");
break;
}
if(!digitalRead(9))
{
fermeture();
Serial.print("fer");
break;
}
{
clavier = 1;
Serial.print("sortie");
delay(500);
break;
}
lcd.print("Nb Poules int");

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 rtroclairage
lcd.backlight(); // On active le rtroclairage
else
lcd.noBacklight(); // Sinon on le dsactive
}
}
clavier = 1;
break;
1.4
Script python
# -*- coding: cp1252 -*import serial, datetime, time
sdow = time.strftime("%A")
dow = 0
# Port Srie utilisez par l'arduino

SERIALPORT = "COM6"
if sdow == "Monday" :
dow = 1
if sdow == "Tuesday" :
# Vitesse du port srie

SERIALSPEED = 9600
dow = 2
if sdow == "Wednesday" :
dow = 3
# ---------------------------------------------------------------------
if sdow == "Thursday" :
dow = 4
print "~ Arduino Clock - Sync Tool ~"

print "Created by SkyWodd"
print " "
if sdow == "Friday" :
dow = 5
if sdow == "Saturday" :
dow = 6
if sdow == "Sunday" :
print "Openning serial port ... ",
dow = 7
try:
arduino = serial.Serial(SERIALPORT, SERIALSPEED,
timeout=1)
print "Current Day Of Week : %d" % dow
except:
print "FAILLED !"
arduino.write("ACK")
exit(-1)
arduino.write(chr(now.second))
print "OK !"
arduino.write(chr(now.minute))
arduino.write(chr(now.hour))
print "Booting up arduino ... ",
arduino.write(chr(dow))
arduino.setDTR(level = True)
arduino.write(chr(now.day))
time.sleep(0.5)
arduino.write(chr(now.month))
arduino.setDTR(level = False)
arduino.write(chr(int(str(now.year)[-2:])))
ligne = arduino.readline()
while not "SYNC" in ligne:
ligne = arduino.readline()
print "Ok !"
print "Closing serial port ... ",

arduino.close()
print "OK !"
time.sleep(1)
print "Bye bye !"
now = datetime.datetime.now()
print "Current year: %d" % int(str(now.year)[-2:])
print "Current month: %d" % now.month
print "Current day: %d" % now.day
print "Current hour: %d" % now.hour
print "Current minute: %d" % now.minute
print "Current second: %d" % now.second
1.5
Fonction de synchronisation
void 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 rpondu 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(); // Rception et conversion des donnes reu
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 reues
}
}
else
lire(date); // Si le pc n'as pas rpondu la demande de synchronisation la
fonction se contente de lire les donnes du DS1307
}
>>>>>>>>>>FIN DE
DOCUMENT<<<<<<<<<<

Real Time Clock

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Real Time Clock

Enviado por

Direitos autorais:

Formatos disponíveis

Rapport projet

Module 3 : tude et ralisation

tudiant : Thomas Zorninger

Thomas Zorninger - Introduction

Poulailler autonome Horloge temps rel

Dfinition gnrale du projet.....................................................................................................................6

Horloge temps rel DS1307........................................................................................................................7

Utilisation des touches......................................................................................................................................................... 15

Ecran LCD rtro clair............................................................................................................................16

TABLE DES ILLUSTRATIONS

Il est nanmoins important de faire la distinction entre un systme autonome et

Dfinition gnrale du projet

Ce projet porte sur ltude et la ralisation dun poulailler autonome. Pour

Le fonctionnement final envisag devra permettre la gestion autonome dun

Cahier des charges

La gestion de la date et lheure sarticulera autour dune horloge temps rel

Figure 1 : Image DS1307

Elle possde galement une

On verra dans la partie tude comment communiquer avec le composant et on

Grce celui-ci, lutilisateur sera capable de

3.3 Ecran LCD rtro clair 16x2

Lutilisateur aura la possibilit de visualiser certaines informations du systme

Lcran affichera par dfaut la date

Celui-ci possde lavantage dintgrer un module I2C pour sa communication.

Arduino est une plate-forme de prototypage lectronique open-source cre

3.4.1 Arduino Mega

Figure 4 : Image Arduino Mga

Figure 5 : Tableau caractristiques

La carte possde 56 entres/sorties numriques (dont 15 pouvant tre utilises

3.4.2 IDE Arduino

Figure 6 : Capture cran IDE Arduino

Un signal de donnes (appel SDA),

Un signal dhorloge (appel SCL, permettant le cadenage de lenvoi des

Un signal de rfrence lectrique (masse).

Le codage des bits est de type NRZ (non retour 0).

Figure 7 : Codage NRZ pour bus I2C

Que ltat logique 0 ou Low est ltat dominant .

Que ltat logique 1 ou High est ltat rcessif .

4.2 Horloge temps rel DS1307

Voici un extrait de la documentation constructeur dtaillant lorganisation interne

Figure 9 : Organisation mmoire DS1307

Afin denregistrer initialement la date et lheure, on utilisera un script python

4.3 Acquisition appui clavier

Le clavier que lon utilisera

Certains claviers matriciels prsentent lavantage dutiliser moins de broches.

4.3.1 Utilisation des touches

La touche 0 : Cette touche permet lutilisateur de rentrer dans la configuration

4.4 Ecran LCD rtro clair

Jai choisi dafficher par dfaut les informations suivantes :

En haut gauche : Jour + Date

En haut droite : Etat de la

En bas gauche : Heure

En bas droite : Etat de la porte

On a grce cet affichage une

Figure 13 : Photo Appui touche *

Lorsque lon se trouve dans le mode

Figure 14 : Photo Appui sur 1 aprs

Figure 16 : Photo Appui sur autre

Un appui sur un autre chiffre (3 9

Figure 17 : Photo Appui touche 0

Lorsque lon se trouve dans le mode

Figure 18 : Photo entrez heure

Cette figure prsente le moment ou