Real Time Clock
Real Time Clock
Real Time Clock
Master 1 AII
Anne 2015/2016
Projet collaboratif :
Ralisation d'un poulailler autonome
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.
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
3.
EQUIPEMENT.............................................................................................................................................7
3.1
3.2
3.3
3.4
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
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
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.
2. LE PROJET
2.1
2.2
Fonctionnement envisag
2.3
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.
On remarque
galement
3.2
Clavier matriciel
3x4la prsence dune pile lithium 3.6V servant
dalimentation secondaire en cas de coupure de lalimentation principale.
nous
3.4 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 :
-
Lorsque le bus nest pas utilis, il est au niveau haut ( travers une ou des
rsistance(s) de pull-up).
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).
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 :
En effet il aurait t
ventuellement possible de
srialis linterface ou bien
plus simplement de ne pas
utiliser certaines touches du
clavier.
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.
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.
La partie gestion du nombre de poule est gre par mon collgue Loc Metzger.
{
Wire.beginTransmission(DS1307_ADDRESS);
Wire.beginTransmission(DS1307_ADDRESS);
Wire.write(0x08);
Wire.write(0x0E);
Wire.write(dec2bcd(alarme1->jour));
Wire.write(dec2bcd(alarme2->jour));
Wire.endTransmission();
Wire.endTransmission();
Wire.beginTransmission(DS1307_ADDRESS);
Wire.beginTransmission(DS1307_ADDRESS);
Wire.write(0x09);
Wire.write(0x0F);
Wire.write(dec2bcd(alarme1->mois));
Wire.write(dec2bcd(alarme2->mois));
Wire.endTransmission();
Wire.endTransmission();
Wire.beginTransmission(DS1307_ADDRESS);
Wire.beginTransmission(DS1307_ADDRESS);
Wire.write(0x0A);
Wire.write(0x10);
Wire.write(dec2bcd(alarme1->annee));
Wire.write(dec2bcd(alarme2->annee));
Wire.endTransmission();
Wire.endTransmission();
Wire.beginTransmission(DS1307_ADDRESS);
Wire.beginTransmission(DS1307_ADDRESS);
Wire.write(0x0B);
Wire.write(0x11);
Wire.write(dec2bcd(alarme1->heures));
Wire.write(dec2bcd(alarme2->heures));
Wire.endTransmission();
Wire.endTransmission();
Wire.beginTransmission(DS1307_ADDRESS);
Wire.beginTransmission(DS1307_ADDRESS);
Wire.write(0x0C);
Wire.write(0x12);
Wire.write(dec2bcd(alarme1->minutes));
Wire.write(dec2bcd(alarme2->minutes));
Wire.endTransmission();
Wire.endTransmission();
Wire.beginTransmission(DS1307_ADDRESS);
Wire.beginTransmission(DS1307_ADDRESS);
Wire.write(0x0D);
Wire.write(0x13);
Wire.write(dec2bcd(alarme1->secondes));
Wire.write(dec2bcd(alarme2->secondes));
Wire.endTransmission();
Wire.endTransmission();
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);
// tell servo to go to position in
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);
// tell servo to go to position in
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);
// tell servo to go to position in
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.
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
void 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;
1.3
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;
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);
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(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);
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.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;
1.4
Script python
# -*- coding: cp1252 -*import serial, datetime, time
sdow = time.strftime("%A")
dow = 0
if sdow == "Monday" :
dow = 1
if sdow == "Tuesday" :
dow = 2
if sdow == "Wednesday" :
dow = 3
# ---------------------------------------------------------------------
if sdow == "Thursday" :
dow = 4
if sdow == "Friday" :
dow = 5
if sdow == "Saturday" :
dow = 6
if sdow == "Sunday" :
dow = 7
try:
arduino = serial.Serial(SERIALPORT, SERIALSPEED,
timeout=1)
except:
print "FAILLED !"
arduino.write("ACK")
exit(-1)
arduino.write(chr(now.second))
arduino.write(chr(now.minute))
arduino.write(chr(now.hour))
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 !"
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
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<<<<<<<<<<