Utiliser une carte Arduino

dans une station météo

Alain Jouve, Professeur de physique au Lycée Rosa Parks, Neuville sur Saône
Publié par Gérard Vidal
Utiliser une carte Arduino dans une station météo
par Alain Jouve, Professeur de physique au Lycée Rosa Parks, Neuville sur Saône et Gérard Vidal

Date de publication 2015-07-25

Résumé

Les cartes Arduino sont des cartes "opensource" comportant un circuit microcontrôleur permettant de réaliser des
acquisitions de données issus de capteurs. Elles sont peu coûteuses et assez faciles à mettre en oeuvre avec quelques
lignes de codes de programmation et peuvent gérer une communication sans fil type WiFi ou Bluetooth ce qui
est très intéressant dans le cas d'une station météo, il n'est pas nécessaire de se rendre sur le site pour acquérir
les mesures.

Les modules XBee sont également des modules de télécommunication sans fil aisés à mettre en oeuvre.

Cet article décrit comment réaliser une station météo interrogeable à distance construite avec une carte Arduino
et un module XBee.
Table des matières
Utiliser une carte Arduino dans une station météo ............................................................... 1
Présentation de la station ........................................................................................ 1
Choix de la carte Arduino ....................................................................................... 2
Les cartes Arduino ......................................................................................... 2
Les contraintes .............................................................................................. 2
Le dispositif Arduino choisi ............................................................................ 2
Le module de communication sans fil ....................................................................... 3
Les capteurs ......................................................................................................... 4
Généralités ................................................................................................... 4
Le capteur de température et le capteur de pression ............................................. 5
L'hygromètre ................................................................................................. 5
L'anémomètre ................................................................................................ 5
L'abri ................................................................................................................... 6
Le boîtier émetteur ................................................................................................ 7
Alimentation de la carte Arduino et des capteurs ......................................................... 8
Le sketch à téléverser dans la carte Arduino ............................................................... 9
L'EDI Arduino .............................................................................................. 9
Structure générale d'un programme Arduino ....................................................... 9
Le sketch Arduino ....................................................................................... 10
Initialisation de la station ...................................................................................... 11
Le programme Python .......................................................................................... 11
Relevé et enregistrement des mesures ...................................................................... 12
Repérage des dates ....................................................................................... 12
Enregistrement des données ........................................................................... 12
Exemple de mesures enregistrée ..................................................................... 12
Annexes ............................................................................................................. 13
Le sketch Arduino ....................................................................................... 13
Le programme Python complet ....................................................................... 22

iii
Liste des illustrations
1. Vue de la station météo en état de fonctionnement ........................................................... 1
2. Synoptique du système complet .................................................................................... 2
3. La carte Arduino ....................................................................................................... 2
4. Le dispositif électronique de la station météo .................................................................. 3
5. Module radio XBee® "XBP24-AUI-001" ....................................................................... 3
6. XCTU : Copies d'écran de la page des paramètres du XBee ............................................... 3
7. Modification du paramètre SM SleepMode ..................................................................... 4
8. Pont diviseur de tension .............................................................................................. 4
9. Les capteurs fixés sur l'assiette inférieure de l'abri météo .................................................. 5
10. Le capteur anénomètre .............................................................................................. 6
11. L'abri de la station météo .......................................................................................... 7
12. Vue de l''assiette inférieure amovible de l'abri ............................................................... 7
13. Le boîtier émetteur : monté sur le mât support , intérieur du couvercle , partie fixe avec le
RIT et les connecteurs .................................................................................................... 8
14. Capteur photovoltaïque .............................................................................................. 9
15. Interface graphique du programme Python .................................................................. 11

iv
Utiliser une carte Arduino dans une
station météo
De nombreux sites proposent des programmes divers et variés notamment le site Arduino [http://
[Link]/fr/] qui est très complet. La tâche des développeurs est ainsi facilitée.

Présentation de la station
La station météo se présente telle que le montre la photo ci-dessous.

Figure 1. Vue de la station météo en état de fonctionnement

Sur un pied de parasol de 14 kg est fixée une tige métallique normalement destinée à supporter un
antenne [Link] cette tige sont fixés le panneau solaire, l'abri ventilé(blanc) et le boîtier(gris)
contenant le montage electronique.

Dans l'abri ventilé se situent trois capteurs :

-un capteur de température

-un capteur de pression

- un capteur d'humidité

Un anémomètre à ailettes surmonte l'abri.

Un boitier protège l'ensemble du montage électronique qui lit et télétransmet les données issues des
capteurs. Une petite antenne le surmonte.

La station est énergétiquement autonome et le panneau solaire recharge une batterie de 12 V 12

Ah située dans une boîte étanche placée au pied de la station. Cette batterie alimente le montage
électronique et les capteurs.

Un logiciel implanté dans un ordinateur distant permet de récupérer périodiquement les données. La
structure générale de l'ensemble est comme l'indique la figure ci-dessous :

1
 Utiliser une carte Arduino
dans une station météo

Figure 2. Synoptique du système complet

Choix de la carte Arduino

Les cartes Arduino
Les cartes Arduino sont bâties autour d'un microcontrôleur ATméga .

Il existe plusieurs modèle ayant chacun leurs spécificités. La plus courante est la carte Arduino Uno
qui a le mérite d'être robuste, et le microcontroleur, monté sur un support, peut être changé en cas
de panne. La carte Leonardo présente l'avantage de gérer deux ports série en même temps, mais le
microcontrôleur est soudé et ne peut pas être changé.

Figure 3. La carte Arduino

Ces cartes comportent toutes plusieurs entrées analogiques, des entrées et des sorties numériques. Le
convertisseur analogique numérique possède 10 bits et sa tension de pleine échelle est par défaut de
5 V mais peut être règlée entre 2,3 et 5 V.

On peut ajouter des fonctions grâce à des cartes aditionnelles appelées Shield qui se branchent
exactement dans les connecteurs de la carte Arduino. On peut superposer ainsi plusieurs Shield

Les contraintes
L'autonomie en énergie impose la consommation d'un faible courant.

Le panneau solaire photovoltaïque doit pouvoir recharger la batterie le jour, même l'hiver.

Les cartes Arduino comportent une mémoire vive de faible capacité : 32 ko pour l'UNO et 28 k pour
la carte Leonardo.

Les mesures doivent être assez rapprochées dans le temps pour un suivi précis de l'évolution rapide de
la météo locale lors d'orages par exemple. Les données doivent pouvoir être stockées dans la station,
puis ensuite téléchargées sur un ordinateur distant.

Il faut téléverser dans l'Arduino plusieurs bibliothèques qui occupent beaucoup de place mémoire,
la bibliothèque du port SPI qui gère la carte micro-SD, la bibliothèque du port I2C qui gère la
communication avec les capteurs.

Le dispositif Arduino choisi

Le dispositif comporte une carte Arduino UNO S3 surmontée d'un Shield "Carte micro-SD - Xbee".

2
 Utiliser une carte Arduino
dans une station météo

Figure 4. Le dispositif électronique de la station météo

Le Shield comporte un lecteur de carte mirco-SD de 4 Go, ce qui permet d'enregistrer les données dans
un fichier de type texte. Le shield comporte également le connecteur pour Xbee.

Le module possède un petit interrupteur qui doit être placé sur la position "usb" lorsqu'on téléverse le
programme dans la carte Arduino. Lorsque le téléversement est terminé il faut placer l'interrupteur sur
la position "micro" afin que le module Xbee soit mis en service.

Le module de communication sans fil

Le module est directement fixé sur la platine Arduino soit via un module shield pour la carte Uno soit
directement sur la carte leonardo DFRobot qui possède un connecteur XBee. Il s'agit d'un module Xbee
pro série 1 avec un connecteur"UFL" qui permet de brancher une antenne via un fil de connection.
La fréquence d'émission est de 2,4 GHz.

Figure 5. Module radio XBee® "XBP24-AUI-001"

Une antenne extérieure est indipensable pour que la portée soit d'une centaine de mètres, car l'ensemble
est enfermé dans une boîte en matière plastique. Un autre module Xbee est connecté sur l'ordinateur via
un connecteur USB. Il permet au programme Python de communiquer avec la station mété[Link] dernier
module possède une antenne intégrée et n'est pas enfermé donc ne nécessite pas d'antenne aditionnelle.

Il faut paramétrer le XBee avec le logiciel XCTU qui est gratuit. Le paramétrtage usine convient
sauf pour la mise en veille. Pour que la mise en veille soit commandée par le logiciel il faut fixer le
paramètre "SM SleepMode" à la valeur de "Pin Hybernate1":

Figure 6. XCTU : Copies d'écran de la page des paramètres du XBee

3
 Utiliser une carte Arduino
dans une station météo

Figure 7. Modification du paramètre SM SleepMode

Pour provoquer la mise en veille ou le réveil du XBee, le logiciel implanté dans l'Arduino place une des
sorties logiques (la sortie 9 par exemple) à l'état "HIGH" (mise en veille) ou l'état "LOW" (réveil). Il
faut réaliser une connection électrique avec un fil entre la sortie 9 de l'Arduino et la patte 9 du module
Xbee. ATTENTION : le module XBee n'accepte pas de tension supérieure à 3,3 V, il faut donc que
la borne 9 de l'arduino soit branchée sur un pont diviseur qui abaisse la tension de 4,8 V(état haut des
sortie Arduino) à 3 V. Le Xbee grille à la longue si on applique la tension de 4,8 V sur une de ses
pattes(votre serviteur en a fait l'amère expérience).

Figure 8. Pont diviseur de tension

Ce pont diviseur sera câblé sur le circuit imprimé qui supporte la carte Arduino. Le fil de liaison entre
la sortie du pont diviseur et la patte 9 du Xbee sera soudé sur la connexion du shield qui correspond
à la patte 9.

Les capteurs
Généralités
Trois des capteurs utilisés ici sont des capteur électroniques de la marque Sparkfun [https://
[Link]/] . Ils utilisent le protocole I2C. Ils ont été acheté chez Lextronic [http://
[Link]] et le site de Sparkfun permet de télécharger la librairie Arduino de chaque capteur
avec un exemple d'utilisation.

4
 Utiliser une carte Arduino
dans une station météo

Le capteur de température et le capteur de pression

Figure 9. Les capteurs fixés sur l'assiette inférieure de l'abri météo

C'est le module BMP180 qui comporte un capteur de température et un capteur de pression. Il faut
d'abord lire la température qui est ensuite utilisée pour lire et établir la pression. On peut corriger la
valeur de la pression en la ramenant à l'altitude du niveau de la mer. La liaison avec l'Arduino s'effectue
à l'aide du protocole I2C.

L'hygromètre
Le module HTU21 de sparkfun mesure à la fois la température et l'hygrométrie. Il faut aussi utiliser
le protocole I2C.

L'anémomètre
C'est un anémomètre à ailettes acheté aussi chez Lextronic

5
 Utiliser une carte Arduino
dans une station météo

Figure 10. Le capteur anénomètre

Son principe est simple, un interrupteur de type ILS, commandé avec un petit aimant solidaire du
moulinet, se ferme à chaque tour. La carte Arduino compte le nombre de tours par seconde. Il faut
utiliser un petit montage dit "interrupeur sans rebond" entre la sortie de l'anémomètre et l'entrée
de l'arduino pour éliminer les oscillations amorties qui apparaissent parfois lors de la fermeture et
ouverture de l'interrupteur. Après étalonnage, avec un anémomètre du commerce, la vitesse du vent
est calculée par le logiciel de la carte Arduino.

L'abri
Pour que les mesures soient valables, il faut que les capteurs soient en contact direct avec l'air, mais
aussi protégés du soleil et de la pluie. L'abri doit donc être bien ventilé, mais aussi suffisament
protecteur pour que les capteurs ne soient pas mouillés par le pluie. On utilise des assiettes de pot
de fleur en plastique renversées. L'idée provient du site : Soucabri [[Link]
Soucabris/[Link]]

6
 Utiliser une carte Arduino
dans une station météo

Figure 11. L'abri de la station météo

Chaque assiette est séparée de sa voisine par une entretoise de 2 cm de [Link] rebord en creux de
chaque assiette est percé de trous afin d'éviter l'accumulation de l'eau de pluie ou de rosé[Link] assiettes
sont peintes en blanc pour minimiser l'absorption de la lumière du Soleil qui réchaufferait l'abri et
rendrait erronée la valeur de la température.

Une connexion à l'aide d'un câble 4 fils permet de relier les capteurs avec l'Arduino avec le procole I2C.

Figure 12. Vue de l''assiette inférieure amovible de l'abri

L'assiette du bas porte les capteurs et est facilement amovible car fixée à l'aide d'écrous à ailettes.

Le boîtier émetteur
Il contient la carte Arduino et son Shield. L'antenne reliée au module XBee est fixée sur boîtier.

7
 Utiliser une carte Arduino
dans une station météo

Figure 13. Le boîtier émetteur : monté sur le mât support , intérieur du

couvercle , partie fixe avec le RIT et les connecteurs

La carte Arduino est fixée sur une plaque imprimée sur laquelle sont fixés trois connecteurs :

1. Le connecteur d'alimentation

2. Le connecteur des capteurs utilisant la liaison I2C

3. Le connecteur relié à l'anémomètre

L'utilisation de connecteurs permet de débrancher facilement le boîtier émetteur et de l'emporter pour

une maintenance éventuelle, c'est pour cette même raison que l'antenne et l'ensemble Arduino sont
fixés dans le couvercle du boîtier que l'on peut facilement détacher du corps principal fixé sur le tube
support.

On trouve aussi sur la carte imprimée, le pont diviseur nécessaire à l'adaptation de la tension de la
borne 9 du Xbee, et un autre pont diviseur par 4 alimenté directement par la tension aux bornes de
la batterie. La sortie de ce pont diviseur est reliée à la borne A1 de l'Arduino. Le sketch lit la tension
appliquée sur cette borne et peut ainsi envoyer à l'ordinateur l'état de la charge de la batterie.

Le boîtier émetteur doit être étanche, mais doit cependant être ventilé pour éviter une surchauffe de
circuits électroniques, des trous sont percés en dessous du boîtier et dans la partie supérieure, ces
derniers sont recouverts d'une protection évitant que la pluie ne pénètre.

Alimentation de la carte Arduino et des

capteurs
Alimentation autonome avec une batterie de 12 V 12 Ah rechargée avec un panneau solaire de 0,15
m2. L'ensemble du dispositif consomme 0,06 A lorsque le module Xbee est en veille, et 0,12 A
lorsque le module Xbee est éveillé. L'éveil du Xbee dure 1min30 par 10 min. L'intensité moyenne
calculée sur heure est donc 0,07 A Donc l'autonomie de la batterie est de 12/0,07 = 171 h environ.
Le panneau solaire photovoltaïque polycristallin a pour puissance maximale Pm = 20 W, avec un
courant maximal de 1,2 A. Valeurs données pour une énergie recue par unité de surface de 4000 W/
m2, c'est-à-dire lorsque les rayons du Soleil sont orthogonaux à la surface du capteur, au mois de juin
à Lyon. L'expérence montre que la simple lumière du jour (même en hiver) suffit à compenser la
consommation de la station.

8
 Utiliser une carte Arduino
dans une station météo

Figure 14. Capteur photovoltaïque

On peut éventuellement alimenter la station météo sous 12 V avec une petite ligne électrique issues
d'un transformateur situé à l'abri. La consommation de la carte Arduino et des capteurs étant très faible,
il n'y a pas de courant important (60 mA), et la chute de tension dans la ligne est réduite. Pour une
longueur de 100 m de câble 1 mm2, par exemple, la résistivité du laiton étant ρ = 7,0·10 -8 Ω.m , en
utilisant la relation : on obtient une résistance de 14 Ω (il faut tenir compte des deux fils) ;
a chute de tension serait donc de 0,8V environ.

Le sketch à téléverser dans la carte Arduino

L'EDI Arduino
L'EDI "Arduino" est à télécharger gratuitement sur le site Arduino [[Link]
Software] dans l'onglet "download". On peut l'installer n'importe où sur son disque dur. Il comporte
de nombreuses bibliothèques. On tape le programme en langage C. Une fois terminé on le téléverse
dans la mémoire de la carte Arduino branchée sur le port USB de l'ordinateur.

Structure générale d'un programme Arduino

Un programme Arduino encore appelé sketch comporte toujours au moins deux procédures :

1. La procédure "setup" dans laquelle on fixe les valeurs des variables globales, on intialise le port
série utilisé et ses caractéristiques, etc ... Le setup est exécuté à chaque mise sous tension ou chaque
reset de la carte Arduino et uniquement.

2. La procédure "loop" qui, comme son nom l'indique, tourne en permanence, sur elle-même tant que
l'Arduino est alimenté.

3. Des fonctions peuvent être définies également (facultatif mais recommandé) en dehors de ces deux
précédentes procédures, il faut les implémenter avec la procedure "loop".

9
 Utiliser une carte Arduino
dans une station météo

Le sketch Arduino
Il est proposé dans les annexes et comporte essentiellement :

Bibliothèques et variables
• L'importation des bibliothèques pour la gestion de la carte SD, du port I2C, des capteurs , et du port
SPI utilisé par la carte SD.

• La création des variables : par exemple le fichier de sauvegarde des données, les repères temporels,
etc ...

Le setup
Le setup contient l'ouverture du port série, et il fixe les paramètres des entrées et sorties. Pour que le
lecteur de carte SD fonctionne correctement, il faut que la sortie 10 soit définie en sortie et soit fixée à
l'état haut. La borne 9 est définie en sortie et permet de mettre en veille ou de réveiller le XBee. L'éveil
est obtenu si elle est à l'état bas, et l'endormissement lorsqu'elle est à l'état haut.

On teste aussi la présence de la carte SD.

La boucle
On trouve dans la boucle

• une série d'instructions uniquement réalisées lors de la première boucle :

lecture de la date courante sur l'ordinateur

test de l'existence et création du fichier de sauvegarde

• Des instructions effectuées lors de chaque boucle

1. La lecture du port série et l'exécution des instructions imposées par l'ordinateur :

a. Lecture des données

b. Lecture du fichier de sauvegarde de la date courante

c. Lecture des fichiers antérieurs

2. L'enregistrement des valeurs toute les minutes

3. La mise en veille et le réveil du XBee

Des fonctions
• lecture de la tempéraure, de la pression, de l'hygrométrie, et de la vitesse du vent

• sauvegardes des données sur la carte SD

• initialisation de la date et de l'heure

• calcul de la date et de l'heure

• lecture du Xbee

• changement du fichier de sauvegarde

10
 Utiliser une carte Arduino
dans une station météo

• lecture de la date et de l'heure sur le module timer RTC (éventuellement)

Initialisation de la station
Il faut d'abord lancer le logiciel situé sur l'ordinateur qui permettera d'intialiser la date et l'heure.. Après
la mise sous tension de la carte Arduino, appuyer sur le bouton "reset". Le sketch efffectue d'abord
le "setup" puis la "loop". Lors de la première boucle il demande à l'ordinateur la date et l'heure en
envoyant le message "T". Le programme Python lit la date sur l'ordinateur et l'envoie à la station.

Le programme Python
Il est donné en annexe. On utilise la biliothèque Tkinter pour créer une interface graphique. La fenêtre
qui s'affiche comporte les éléments suivants :

1. Les valeurs des mesures qui s'affichent en temps réel, rafraîchissement toutes les 10 minutes, avec
une indication de l'heure de l'enregistrement de ces mesures.

2. La commande de détection du module Xbee connecté à l'ordinateur sur le port USB

3. La commande de lancement des mesures, lorsque l' heure est de la forme hh mm 00

4. La commande de désactivation de la mise en veille de la station en cas de mise au point ou de

maintenance.

5. La commande de lecture du fichier journalier en cours.

6. La commande de lecture de tous les fichiers enregistrés sur la carte SD de la station.

7. Une information sur l'état de veille ou non de la station, avec l'heure de la précédente mise en veille :
un voyant est rouge si la station est en veille et est vert sinon.

Figure 15. Interface graphique du programme Python

La charge de la batterie est affichée à titre informatif, mais n'est pas enregistrée.

La fermeture de la fenêtre et l'arrêt du programme sont obtenus en cliquant sur le petit carré muni
d'une croix rouge.

Deux Timers sont créés dans le programme: l'un de 1 h qui lit les valeurs à chaque heure(facultatif),
l'autre de 2 s qui scrute le port XBee et qui détecte s'il se réveille. Il commande la mesure et met l'heure
de l'Arduino à jour.

11
 Utiliser une carte Arduino
dans une station météo

Relevé et enregistrement des mesures

Repérage des dates
Le module Arduino étant livré à lui-même il faut repérer les dates à l'aide de son horloge interne. Il
est possible d'utiliser l'instruction millis() (format type long) qui donne le nombre de milliseconde
écoulées depuis le "reset" de la [Link] sketch calcule le nombre de secondes, minutes, heures, jours,
mois écoulés depuis le reset. L'horloge interne n'est pas stable et présente une importante dérive.
Plusieurs essais ont conduit à corriger le nombre de millisecondes en ajoutant 1250 ms par minute.
Cela n'est pas très précis.

On peut utiliser petit module un timer externe branché sur la carte Arduino qui est plus précis, mais
qui présente un problème de compatibilité avec la carte SD car il utilise le même port SPI avec un
paramétrage différent.

Chaque fois que la station envoie des données vers l'ordinateur, toutes les 10 minutes si l'ordinateur
structe le port XBee, elle demande la date et l'heure à l'ordinateur qu'elle corrige si besoin.

Enregistrement des données

Un module Xbee est relié au port USB de l'ordinateur. Un programme écrit en Python , ou autre
langage, scrute toutes les deux secondes les messages envoyés par la station. Lorsque le réveil a lieu,
le sketch Arduino envoie un message "up" ce qui déclenche une demande de relevé de mesures. Le
sketch Arduino relève les mesures et les envoie. Ces mesures sont enregistrées dans un fichier type
"csv" dans l'ordinateur. Lorsque la station se place en mode veille la station envoie le message"down"
ce qui indique au programme Python que la station est inaccessible.

Si l'ordinateur se met en veille, il n'est pas possible de relever les valeurs de la station météo. Le
sketch Arduino enregistre systématiquement(en veille ou non) sur la carte SD de la station les données
toutes les minutes dans un fichier type "csv" nommé "[Link]". avec mm: mois, jj :jour. La
bibliothèque SD ne gère pas les fichiers dont le nom est différent de la structure ********.***(8
caractères simples+ '.' + ***)

Structure d'une ligne enregistrée dans le fichier csv :

"aaaa;mm;jj;hh,mm,ss;tempe;pression;hygrométrie;vent;"

Le sketch Arduino change automatiquement de fichier d'enregistrement chaque jour à 0 h 00. Il y a

donc un fichier par jour.

Le programme python comporte une commande permettant de lire le fichier en cours et une autre
commande permettant de lire tous les fichiers enregistrés. Les données sont alors stockées dans
l'ordinateur dans un fichier de type "csv" .

Exemple de mesures enregistrée

Date, heure température, pression atm, hygrométrie,vitesse du vent

27/10/2014,1h10,8.36,1025.84,101.38,0.00
27/10/2014,1h11,8.37,1025.89,101.41,0.00
27/10/2014,1h12,8.33,1025.79,101.26,0.00
27/10/2014,1h13,8.29,1025.72,101.23,0.00
27/10/2014,1h14,8.31,1025.76,101.28,0.00
27/10/2014,1h15,8.31,1025.82,101.35,0.00
27/10/2014,1h16,8.38,1025.82,101.50,0.00
27/10/2014,1h17,8.36,1025.80,101.41,0.00
27/10/2014,1h18,8.31,1025.82,101.25,0.00
27/10/2014,1h19,8.29,1025.78,101.28,0.00
27/10/2014,1h20,8.27,1025.80,101.25,0.00

12
 Utiliser une carte Arduino
dans une station météo

27/10/2014,1h21,8.27,1025.83,101.22,0.00
27/10/2014,1h22,8.29,1025.81,101.36,0.00
27/10/2014,1h23,8.29,1025.95,101.35,0.00
27/10/2014,1h24,8.29,1025.86,101.40,0.00
27/10/2014,1h25,8.29,1025.85,101.40,0.00
27/10/2014,1h26,8.26,1025.87,101.42,0.00
27/10/2014,1h27,8.27,1025.86,101.40,0.00
27/10/2014,1h28,8.24,1025.86,101.35,0.00
27/10/2014,1h29,8.21,1025.85,101.30,0.00
27/10/2014,1h30,8.19,1025.84,101.26,0.00
27/10/2014,1h31,8.18,1025.94,101.23,0.00
27/10/2014,1h32,8.16,1025.88,101.19,0.00
27/10/2014,1h33,8.13,1025.81,101.17,0.00
27/10/2014,1h34,8.12,1025.90,101.14,0.00
27/10/2014,1h35,8.10,1025.86,101.14,0.00
27/10/2014,1h36,8.10,1025.93,101.15,0.00
27/10/2014,1h37,8.09,1025.86,101.17,0.00
27/10/2014,1h38,8.10,1025.83,101.20,0.00
27/10/2014,1h39,8.09,1025.87,101.18,0.00
27/10/2014,1h40,8.07,1025.79,101.17,0.00
27/10/2014,1h41,8.06,1025.78,101.16,0.00
27/10/2014,1h42,8.04,1025.78,101.15,0.00
27/10/2014,1h43,8.04,1025.81,101.15,0.00
27/10/2014,1h44,8.03,1025.76,101.15,0.00
27/10/2014,1h45,8.02,1025.77,101.11,0.00
27/10/2014,1h46,7.98,1025.79,101.03,0.00
27/10/2014,1h47,7.94,1025.78,100.96,0.00
27/10/2014,1h48,7.90,1025.78,100.90,0.00

Annexes
Le sketch Arduino

#include < SPI.h>//ouvre le port qui gère la carte SD

/* SD card attached to SPI bus as follows:

** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4*/

#include < SD.h>//carte SD

#include "HTU21D.h"//bibliothèques des capteurs sparkfun humidité

#include SFE_BMP180.h// bibliothèques des capteurs sparkfun pression

#include Wire.h//Pour le port I2C

File Myfile;

13
 Utiliser une carte Arduino
dans une station météo

char fichier_[12];

SFE_BMP180 pressure;//Capteur de pression et de température

HTU21D myHumidity;// capteur d'hygrométrie

long minute_debut;
char commande_mesure;
char message;
int mois_;
int jour_;
int an_;
int heure_=0;
int minute_=0;
int seconde_ = 0;
int anemometre = 2; //Anemometre connecte sur le port 2
long date_ini_veille;

boolean debut=true;//A la mise sous tension de l'Arduino, debut = true afin que la boucle loop effectue l'initialisation de
long date_ini,date_depart,date_depart_;
//long date_courante;
boolean Xbee_reveille=true;
//String reponse="";
char status;

long temps;

void setup()
{

pinMode(anemometre, INPUT);
[Link](9600); //Port Xbee

[Link]();
delay(10);
[Link]();
delay(100);
//Réglage en mode veille du Xbee;
// La borne 9 de l'Arduino est reliée à la borne9 du Xbee

date_depart=millis();
debut=true;
pinMode(9, OUTPUT);//borne de sortie pour commander la mise ne veille du Xbee nécéssite le réglage de avec XCT
digitalWrite(9, LOW);//mode réveillé du XBee
pinMode(10, OUTPUT);
digitalWrite(10, HIGH);//obligatoire pour que la carte sd soit reconnue
//[Link](4);//Sur leonardo ou mega voir [Link]
if ([Link](4)){//vérification de la présence de la carte SD
[Link]("La carte SD est reconnue");
delay(1000);
return;
}
else{
[Link]("La carte SD n'est pas reconnue");
}

14
 Utiliser une carte Arduino
dans une station météo

void loop(){

//double T,P,p0;
if (debut==true){
initialisation_jour_heure();
changt_fichier();
delay(1000);
if (){
Myfile = [Link](fichier_, FILE_WRITE);
[Link]("date ; heure; température; pression; hygrométrie;vent :");
[Link]();

}
else{

delay(1000);

date_ini=millis();
debut =false;
[Link]("down");
delay(100);
digitalWrite(9,HIGH);
date_ini_veille=millis();
Xbee_reveille = false;
}

if ([Link]()){//Si le port Xbee recoit une donnée de la part de l'ordinateur par les ondes wifi

commande_mesure=[Link]();//Lecture de la valeur sur le port Xbee

delay(100);

if (commande_mesure==49){//Si la valeur est de 49; valeur 1 en code ASCII envoyé par processing : mesures instan

delay(1000);

//envoie des quatres valeurs les unes après les autres, cela se traduit par un chaîne de caractère recue par le program
[Link](mesure_temperature());//envoie sur le Xbee
delay(400);//delais technique
[Link](';');//séparation des données
delay(10);
[Link](mesure_pression(mesure_temperature()));
delay(400);
[Link](';');
delay(10);
[Link](mesure_hygrometrie());
delay(400);

15
 Utiliser une carte Arduino
dans une station météo

[Link](';');
delay(10);
[Link](vitesse_vent());
delay(400);
[Link](';');
delay(10);
[Link](analogRead(0));//Envoyer surle port Xbee la valeur du niveau de la batterie
delay(10);

delay(3000);//délais technique

initialisation_jour_heure();
delay(2000);
date_ini=millis();
[Link]();

}
if (commande_mesure==50){//Si la valeur est de 50; valeur 2 en code ASCII envoyé par processinglectures des donn

if ([Link](fichier_)){
//[Link](fichier_);
Myfile = [Link](fichier_);
while([Link]()){
[Link]( char([Link]()));

}
delay(10);
[Link]();
}}

if (commande_mesure==51){ // Si la valeur est 3 : valeur 51 en code ASCII: Lecture des données des fichiers non e

delay(100);
File racine = [Link]("/");
[Link]();
while(true) {

File fichier_donnees = [Link]();

char fichier_tmp[12];
if (! fichier_donnees) {
// no more files
//[Link]("**nofiles**");
//[Link]();
break;
}

[Link](fichier_donnees.name());
if (fichier_donnees.name()[6]=='U'){
//boolean transfere = false;
for(int n = 0;n <12;n++){
fichier_tmp[n]=fichier_donnees.name()[n];
}
fichier_donnees.close();
//[Link](fichier_tmp);
Myfile = [Link](fichier_tmp);

16
 Utiliser une carte Arduino
dans une station météo

while([Link]()){
[Link]( char([Link]()));
}
/*transfere=true;
delay(10);
if (transfere==true){
char fichier_tmp_[12];
for(int n = 0;n 12;n++){
fichier_tmp_[n]=fichier_tmp[n];
}
fichier_tmp_[6]='L';
File Myfile_tmp = [Link](fichier_tmp_,FILE_WRITE);
[Link](0);
while([Link]()){
Myfile_tmp.write([Link]());

}
Myfile_tmp.close();

}*/
[Link]();

}
else{fichier_donnees.close();}
}
//[Link]();
}
}

/**********************************************************************************************
* MESURES toutes les 60 s- mise en veille *
***********************************************************************************************
double tempe_;
double pression_;
float hygro_;
float vent_;
if (millis()>=date_ini + 60000){//mesure effectuée environ toutes les minutes
digitalWrite(9,LOW);//réveil du Xbee
delay(1000);//délais technique dû au temps de réveil du Xbee
tempe_ =mesure_temperature();
delay(400);
pression_= mesure_pression(tempe_);
delay(400);
hygro_=mesure_hygrometrie();
delay(400);
vent_=vitesse_vent();
delay(1100);
determination_date();//Calcul de la date de la mesure

sauv_donnees(tempe_,pression_,hygro_,vent_);//sauvegarde dans le fichier du jour des dates et valeurs

date_ini=millis();//initialisation de la date de la mesure en milliseconde

digitalWrite(9,HIGH);
}
if ((millis()=date_ini_veille + 600000)(Xbee_reveille == false)){//réveil du Xbbe toutes les 10 min pendant 1 min pou

17
 Utiliser une carte Arduino
dans une station météo

digitalWrite(9,LOW);
delay(100);
[Link]("up");

Xbee_reveille = true;
}
if ((millis()>=date_ini_veille + 690000)(Xbee_reveille == true)){//réveil du Xbbe toutes les 10 min pour permettre la
[Link]("down");
delay(100);
digitalWrite(9,HIGH);
date_ini_veille=millis();
Xbee_reveille = false;
}
//[Link]();
}
/**********************************************************************************************
* Diverses fonctions *
***********************************************************************************************
double mesure_temperature(){// fontion de mesure de la température codée sur un entier
double T;
status = [Link]();//la mesure de la température s'effectue sur le module sparkfun BMP201 et utilisa
if (status != 0)//si le module répond
{
delay(status);//délais imposé par le module

// Retrieve the completed temperature measurement:

// Note that the measurement is stored in the variable T.
// Function returns 1 if successful, 0 if failure.

status = [Link](T);
}//lecture de la température
return T;//renvoie la valeur de T
}
double mesure_pression(double T){//fonction de mesure de la pression codée sur un entier
double P;//défintion de la variable pression
status = [Link](3);//demarrage de la mesure de la pression
if (status != 0)//si le module répond
{
delay(status);//délais imposé par le module
status = [Link](P,T);//lecture de la pression sur le module
delay(50);
}//imposé par le calcul qui suit
float p0 = [Link](P,200);//Pression corrigée de l'altitude de 200 m, changer la veleur selon le lieu
delay(50);//imposé par le calcul précédent
return p0;//renvoie la pression corrigée de l'altitude
}
float mesure_hygrometrie(){//fonction de mesure de le l'hygrométrie codée sur un réel
float humd = [Link](); //lecture de la valeur de l'humidité sur le module sparkfun
return humd; //renvoie la valeur de l'humidité
}

float vitesse_vent(){//Mesure et Calcul la vitesse du vent : [Link]

unsigned long vent= 0;

vent=pulseIn(anemometre,HIGH,800000);
//[Link](vent);
//[Link](vent2);
float valeur=0;

18
 Utiliser une carte Arduino
dans une station météo

if (vent>0){
valeur=(70000.0*6.2/vent)*3.6;
//[Link]("valeur=");
//[Link](valeur);
}
//formule donnée par le constructeur du moulinet
//[Link](valeur);

return valeur;
}

String reponse_Xbee(){//fonction de lecture des donnees recues par le Xbee lors

int n=0;
while(![Link]()){
n++;
if(n>50000){break;}};
char byte_recu = [Link]();//le xbee envoie un succession de charactère
String reponse_="";
while (byte_recu!=-1){ //si on lit -1 sur le port série cela signifie que la communication n'a pas lieu et on répète tant q

if (byte_recu!=-1){//on vérifie de nouveau car la boucle while comporte deux lectures et la deuxième peut être mauv
reponse_=reponse_+byte_recu;
}//on crée une chaîne de caractère en concaténant les charactères reçus
byte_recu = [Link]();//lecture du charactère
delay(20);
} //délais technique
//[Link](reponse_);
return reponse_ ; //renvoie de la chaîne réponse
//[Link]();
}

void sauv_donnees(float tempe_,float pression_, float hygro_,float vent_){//Sauvegarde des données dans le fichier de
if ([Link](fichier_)) {
Myfile = [Link](fichier_, FILE_WRITE);

[Link](an_);
[Link](";");
[Link](mois_);
[Link](";");
[Link](jour_);
[Link](";");
[Link](heure_);
[Link](";");
[Link](minute_);
[Link](";");
[Link](seconde_);
[Link](";");
[Link](tempe_);
[Link](";");
[Link](pression_);
[Link](";");
[Link](hygro_);
[Link](";");
[Link](vent_);
//[Link](":");

19
 Utiliser une carte Arduino
dans une station météo

//[Link]("\r\n");

delay(10);

[Link]();}
else {changt_fichier();}
}
void initialisation_jour_heure(){//fonction nécessaire si on ne dispose pas d'un module timing extérieur

String reponse="";
boolean reponse_=false;
//int n=0;
//[Link]("initialisation de la date");
[Link]();//effacement des données sur tampon de réception du port Xbee
delay(1000);
[Link]('T');
delay(2000);

reponse=reponse_Xbee();

delay(1000);

if (reponse!=""){
//[Link](reponse);
//[Link]("date recue");

int repere_1= [Link](';');

int repere_2= [Link](';',repere_1+1);
//[Link](repere_1);
int repere_3 = [Link](';',repere_2+1);
//[Link](repere_2);
int repere_4 = [Link](';',repere_3+1);
//[Link](repere_3);
int repere_5 = [Link](';',repere_4+1);
//[Link](repere_4);
if((repere_1!=0)(repere_2!=0)(repere_3!=0)(repere_4!=0)(repere_5!=0)){

an_=[Link](0,repere_1).toInt();
mois_=[Link](repere_1+1,repere_2).toInt();

// [Link](mois_ini);
jour_=[Link](repere_2+1,repere_3).toInt();
// [Link](jour_);

heure_=[Link](repere_3+1,repere_4).toInt();
//[Link](heure_);

minute_=[Link](repere_4+1,repere_5).toInt();
//[Link](minute_);

seconde_=[Link](repere_5+1).toInt();
//[Link](minute_);
//changt_fichier();
//delay(1000);
date_ini=seconde_*1000;}}

20
 Utiliser une carte Arduino
dans une station météo

[Link]();
}
void determination_date(){//fonction nécessaire si on ne dispose pas d'un module timing extérieur
boolean changt_date = false;
long date_presente = millis();
long temps_ecoule=date_presente-date_ini+1250;
temps_ecoule=temps_ecoule/1000;
if ((seconde_+temps_ecoule)59){seconde_ = seconde_+temps_ecoule;}
else{seconde_=(temps_ecoule-59);
if (minute_<59){minute_=minute_+1;}
else{minute_=0;
if(heure_<23){heure_=heure_+1;}
else{heure_=0;

switch (mois_) {
case 1 :if (jour_<31){jour_=jour_+1;}
else{jour_ = 1;
mois_= 2;}
break;
case 2 :if (jour_<28){jour_=jour_+1;}
else{jour_ = 1;
mois_= 3;}
break;
case 3 :if (jour_<31){jour_=jour_+1;}
else{jour_ = 1;
mois_= 4;}
break;
case 4 :if (jour_<30){jour_=jour_+1;}
else{jour_ = 1;
mois_= 5;}
break;
case 5 :if (jour_<31){jour_=jour_+1;}
else{jour_ = 1;
mois_= 6;}
break;
case 6 :if (jour_<30){jour_=jour_+1;}
else{jour_ = 1;
mois_= 7;}
break;
case 7 :if (jour_<31){jour_=jour_+1;}
else{jour_ = 1;
mois_= 8;}
break;
case 8 :if (jour_<31){jour_=jour_+1;}
else{jour_ = 1;
mois_= 9;}
break;
case 9 :if (jour_<30){jour_=jour_+1;}
else{jour_ = 1;
mois_= 10;}
break;
case 10 :if (jour_<31){jour_=jour_+1;}
else{jour_ = 1;
mois_= 11;}

21
 Utiliser une carte Arduino
dans une station météo

break;
case 11 :if (jour_<30){jour_=jour_+1;}
else{jour_ = 1;
mois_= 12;}
break;
case 12 :if (jour_<31){jour_=jour_+1;}
else{jour_ = 1;
mois_= 1;
an_= an_+1;}
break;
}

changt_fichier();
delay(1000);}}

void changt_fichier(){
int n=0;
String string_mois;
String string_jour;
if (mois_<10){string_mois = "0"+ String(mois_);}
if (mois_>=10){string_mois = String(mois_);}
if (jour_<10){string_jour = "0"+ String(jour_);}
if (jour_>=10){string_jour = String(jour_);}
String nom_fichier=string_mois+"-"+string_jour+"-"+"U"+"."+"TXT";

while(n<11){
fichier_[n]=nom_fichier[n];
n++;

}
//[Link]("nom du fichier ="+nom_fichier);
if (){
Myfile = [Link](fichier_, FILE_WRITE);//Creation du fichier de sauvegarde
[Link]("date ; heure; temperature; pression; hygrometrie;vent :");//Premiere ligne de la sauvegarde
[Link]();//Fermeture du fichier
}
}
]]

Le programme Python complet

# -*- coding: utf-8 -*-

#
# Module de lecture/ecriture du port Xbee station météo
from Tkinter import *
from serial import *
import time
import threading
from datetime import datetime,date,timedelta

22
 Utiliser une carte Arduino
dans une station météo

from time import gmtime, strftime

import platform
from [Link] import list_ports
import os, io,itertools
import signal
import sys
import pylab
from PIL import Image, ImageTk
import tkMessageBox

if [Link]() == 'Windows':#Détection du système , utilisation du registre windows

import _winreg as winreg
else:
import glob
port_Xbee=''

path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM'
marche=True
debut=True
forcage=False
mise_en_veille_active=True

def enumerate_serial_ports(): # fonction listant l'ensemble des ports série(USB) utilisés sur la machine

#définition du chemin de la clef du registre donnant la lsite des ports séries en activité
try:
key = [Link](winreg.HKEY_LOCAL_MACHINE, path) #défintion de la clef du registre des po
except WindowsError:
raise Exception

for i in [Link](): #pour l'ensemble des ports série détectés,les lister dans l'ordre croissan
try:
val = [Link](key, i) # valeur des différents ports
yield (str(val[1])) # , str(val[0])) #La fonction yield permet de garder la liste des ports classés
#print(str(val[i]))

except EnvironmentError:
print("erreur")
break

def detection_port_Xbee():
global Xbee
liste_des_ports=enumerate_serial_ports()
for i in liste_des_ports :#Détetection du port série(USB) sur lequel est branché le module xbee
print(i)
try :
with Serial(port=i, baudrate=9600, timeout=1, writeTimeout=1) as Xbee:
if [Link]():
[Link](1)
[Link]('+++')
[Link](1.2)
ligne = [Link]()

23
 Utiliser une carte Arduino
dans une station météo

if (ligne=='OK'+chr(13)) :
port_Xbee=i
#return port_Xbee
break
[Link]()
except :
continue

Xbee = Serial(port=port_Xbee, baudrate=9600, timeout=1, writeTimeout=1)

chaine = "Xbee branché sur le port :" +port_Xbee
[Link](state=DISABLED)#change l état des boutons
[Link](state=NORMAL)
[Link](state=NORMAL)
[Link](chaine ) #indication du port utilisé
detection_creation_fichier_sauvegarde() #Détecte si le fichier de sauvegarde est présent
#

def Configuration_Xbee() :#Entrée dans le mode configuration du Xbee relié à l'orinateur (pas utilisé)

while [Link]():
[Link](1)
[Link]('+++') #activation du mode config du Xbee
[Link](1.2)
ligne = [Link]()
if (ligne=='OK'+chr(13)) : #Vérification de la réponse du Xbee
print(ligne)
print( 'mode config')
[Link]('ATID'+chr(13)) #lecture de n° identification du Xbee
[Link](1)
ligne = [Link]()
[Link](0.2)
print(ligne)

[Link]('ATCN'+chr(13)) # on quitte le mode config

[Link](1)
ligne = [Link]()
[Link](0.2)
print(ligne)
reponse =raw_input("Taper q pour quitter le mode config :")# Demande à l'opérateur si on doit quitter

#le mode config la fonction input n'est pas adaptée en python 2 :

#interprétation du code
print reponse
if (reponse == 'q'):
break
print('terminé')
#Envoie de données de la carte Arduino vers l'ordinateur:

def lecture_des_donnees(moment_d_acquisition) :#Commande à l'arduino de lire les données

if ([Link]()) :

[Link]('1') #code 1 : indique à l'arduino qu'il faut lire les données

[Link]()#arrêt du timer de 10 s pour eviter les conflits de lecture du port série

24
 Utiliser une carte Arduino
dans une station météo

[Link](2)#pause de 2s

mesure_ = [Link]()#lecture du port série de la ligne envoyé par l'Arduino

[Link](2)#mise en veille technique
mesure=mesure_.split(";")#Sépare les données et les transforme en tableau : le';' est envoyépar l'arduino en
print mesure#écrit la ligne dans la console pour vérification
if (len(mesure)==5):#si il y a 5 éléments dans le tableau la lecture est sans doute bonne

temperature=mesure[0] #l'élément 1 du tableau est la tempé

#print('Temperature = '+temperature)
text_tempe.set( "Tempé =" +temperature[:4] + "°C")

pression=mesure[1] #l'élément 2 du tableau est la pression

#print('Pression = '+ pression)
text_pression.set("Pression = "+pression[:4] + " hPa")

hygro = mesure[2]#l'élément 3 du tableau est l'hygrométrie

#print('Hygrométrie =' +hygro)
text_hygro.set("Hygrométrie = " + hygro[:4]+" % hum")

vent=mesure[3]#l'élément 4 du tableau est la vitesse du vent

text_vent.set("vent ="+vent[:4]+"km/h")
batterie = mesure[4]#l'élément 5 du tableau est la tension aux bornes de la batterie
#print('Batterie =' +batterie)

y=int(float(batterie)/860*700)#donne un nombre de pixel proportionnel à la tension de charge de la batte

tension=round(float(batterie)/1024.0*16.0,1)#Permet d'obtenir la tension à partir du nombre binaire
texte=str(tension)+ " V"

#print(y)

[Link]("Mesures : Temperature = " + temperature +"°C ;" +" Pression = " +pression+"hPa ;"+" Hygro

[Link]("Heures des données affichées : "+ str(moment_d_acquisition.hour) +":"+ str(moment_d_acqui

[Link](ALL)#effacemement du canvas de charge de batterie

if (tension>=9.0) :
poly2=can1.create_polygon(0, 0, y, 0,y,50,0,50, fill='green')#Si la charge de la batterie est bonne on t

else :
poly2=can1.create_polygon(0, 0, y, 0,y,50,0,50, fill='red')#Si la charge de la batterie est insuffisant on

#tracé d'un rectangle de couleur et de longueur proprotionnelle à la tesnion aux bornes de la batterie
texte1=can1.create_text(y, 12, text=texte, font="Arial 12 italic", fill="black")
texte2=can1.create_text(350, 30, text="charge batterie", font="Arial 16", fill="blue")
return [temperature,pression,hygro,vent,batterie]#La fonction de lecture des données renvoie les valeurs
[Link]()#efface les données du tampon de réception du port série
[Link]();#redémarrage du timer de 2 s : lecture du port série
else :
[Link](ALL)
[Link]("La station météo n'est pas prête")#Si la lecture est mauvaise
can2.create_oval(5,5,45,45,fill='red')#le voyant rouge s'allume
can3.create_text(200,24, text =' Rouge : station en mode veille')#indique que la station ne répond pas
return [0,0,0,0]
[Link]()#efface les données du tampon de réception du port série
[Link]() #redémarrage du timer de 2 s : lecture du port série
else :

25
 Utiliser une carte Arduino
dans une station météo

print('Le module Xbee ne répond pas')

return [0,0,0,0]

[Link]();#redémarrage du timer de 2 s : lecture du port série

def sauvegarde_donnees(donnees) :#Sauvegarde des données dans un fichier csv

if [Link]('C:\IFE\Météo\documents_contribution\programme python\donnees_meteo.csv') :
fichier = open('C:\IFE\Météo\documents_contribution\programme python\donnees_meteo.csv',"a")
#[Link]( strftime("%a, %d %b %Y %H:%M", gmtime())+';')
for i in range(6) :

[Link](str(donnees[i]))
[Link](';')
[Link]('\n')
[Link]()
else :
print('Le fichier n''existe pas')
donnees=[0,0,0,0] #pour éviter une erreur d'écriture

def test_date_recuperation():
if [Link]('C:\IFE\Météo\documents_contribution\programme python\donnees_meteo.csv') :
fichier = open('C:\IFE\Météo\documents_contribution\programme python\donnees_meteo.csv',"r")

chaine = [Link]()
print chaine
[Link]()

def detection_creation_fichier_sauvegarde(): #Vérification de l'existence d'un fichier de sauvegarde, sinon le créer

if ([Link]('C:\IFE\Météo\documents_contribution\programme python\donnees_meteo.csv')!=True) :
fichier = open('C:\IFE\Météo\documents_contribution\programme python\donnees_meteo.csv',"w")
[Link]()

def fermer_programme():
"""Fonction appelée quand vient l'heure de fermer notre programme"""
print("C'est l'heure de la fermeture !")
if ([Link]()) :
[Link]()
if (a) :
[Link]()
if(b) :
[Link]()
fenetre_meteo.destroy()

def mise_enveille_Xbee(moment_d_acquisition):
if ([Link]()) :
[Link](1)
[Link]('5') # 5 est le code de mise en veille du Xbee station
[Link](1)
[Link](str(moment_d_acquisition.hour))#Donne l'heure à la station

[Link](1)
[Link](str(moment_d_acquisition.minute))#Donne les minutes à la station
[Link](1)

26
 Utiliser une carte Arduino
dans une station météo

def mesures() :
#fonction appelée par le timer toutes les 60s, la mesure n'est ici effectuée que chaque heure
global debut
global forcage
[Link](state=DISABLED)#le bouton arret des mesures est désactivé

#if( ((moment_d_acquisition.minute%2)==0)and (moment_d_acquisition.second==0)):#toutes les heures (

moment_d_acquisition = [Link]()
if (moment_d_acquisition.minute>0):#pour que l'acquisition n'ai lieu qu'a l'heure pile
global acquisition_effectuee#variable globale indiquant que l'acquisition est effectuée
acquisition_effectuee =False
if (((moment_d_acquisition.minute==0)and (acquisition_effectuee==False))or(debut==True)or(forcage==T
[Link]()#L'acquisition a lieu lorsque le timer de 2 s est à l'arrêt

[Link](1.5)#Mise en veille technique.

[Link]() #effacement des données entrantes du port série

debut=False #indique que ce n'est plus la première mesure

forcage=False #indique que l'on de force pas la lecture de la meusre à un moment quelconque
acquisition_effectuee=True;
donnees=lecture_des_donnees(moment_d_acquisition) #appel de la lecture des données sur l'Arduino di
jour = [Link]()
date_= str([Link])+"/"+str([Link])+"/"+str([Link])#lecture de la date et de l'heure
heure_=str([Link])+"h"+str([Link])
[Link](0,heure_)
[Link](0,date_)
print(donnees)
sauvegarde_donnees(donnees)#appel de la fonction de sauvgarde des données
#mise_enveille_Xbee(moment_d_acquisition)#met en veille le Xbee pour préserver les batteries de la st
[Link]()
[Link]()
[Link](state=NORMAL)#le bouton arret des mesures est activé

def scrutation_mise_en_veille() :#fonction applée par le timer de 2 s pour srcuter la mise en veille de la station
examen_veille=[Link]()#lecture du port série
[Link](0.1);

print ("Le port Xbee indique : "+examen_veille)

if(examen_veille=="up"):#si la station envoie up, elle se réveille
[Link](ALL)
can2.create_oval(5,5,45,45,fill='green')
can3.create_text(200,24, text ='Vert : station accessible.')
[Link](text="Desactiver la mise en veille")
forcage_mesures()
[Link]()
if(examen_veille=="down"):#si la station envoir down, elle se met en veille
[Link](ALL)
can2.create_oval(5,5,45,45,fill='red')
heure_courante = [Link]()
phrase=' Rouge : station en mode veille à '+str(heure_courante.hour)+' h' +str(heure_courante.minute)+'.
can3.create_text(200,24, text =phrase)
[Link]()
if (examen_veille=="T"):
[Link]()

27
 Utiliser une carte Arduino
dans une station météo

[Link](1.0);
heure_courante = [Link]()
date_heure = str(heure_courante.year) + ";"+str(heure_courante.month) + ";" + str(heure_courante.day)
[Link](date_heure)
print(date_heure)
[Link](1.0)
[Link]()
[Link]()

class MyTimer: #classe définissant un timer

def __init__(self, tempo, target, args= [], kwargs={}):
self._target = target
self._args = args
self._kwargs = kwargs
self._tempo = tempo

def _run(self):
self._timer = [Link](self._tempo, self._run)
self._timer.start()
self._target()

def start(self):
self._timer = [Link](self._tempo, self._run)
self._timer.start()

def stop(self):
self._timer.cancel()

def lance_mesures() :#lance les mesures

[Link](state=DISABLED)#le bouton de lancement des mesures est déactivé

[Link](state=NORMAL)#
print('debut des mesures')
debut=True

#mesures() #une première serie de mesure est prise au début

moment_d_acquisition = [Link]()
while (moment_d_acquisition.second!=0) :#afin que le démarrage du timer ne prenne effet que lorsque l'heure est de
moment_d_acquisition = [Link]()

[Link](state=NORMAL)
[Link]()
[Link]()
mesures()

def arret_mesures() :
[Link](state=NORMAL)
[Link](state=DISABLED)
debut=True
[Link]()
[Link]()

def forcage_mesures():
global forcage
forcage= True
mesures()

28
 Utiliser une carte Arduino
dans une station météo

def recup_mesures_total():
code_lecture = '3'
lecture_mesures(code_lecture)

def recup_mesures() :
code_lecture = '2'
lecture_mesures(code_lecture)

def lecture_mesures(code_lecture):#permet la récupération des mesures des 48 h précédentes

[Link]()
[Link](1)
[Link](code_lecture)
#Lecture des mesures
[Link](2)

M = [Link]()

#décompose M en autant de lignes qu'il y a d'heures M=M_.split(':')

print M

for n in range(0,len(M)-1):
A = M[n].split(';')
date_=A[2]+"/"+A[1]+"/"+A[0]
A[9]=A[9][0:4]

heure_ = A[3]+"h"+A[4]
mesures_=[date_,heure_,A[6],A[7],A[8],A[9]]
print mesures_
try :
sauvegarde_donnees(mesures_)
except :
[Link]('Warning','Accés au fichier impossible ! Veuillez le fermer !')
[Link]()

[Link]()

def desactive_veille() :#désactive la mise en veille de l'Arduinostation pour la maintenance

global mise_en_veille_active
if ([Link]()) :
[Link](1)
[Link]('7') #code indiquant qu'il faut sortir ou entrer du mode éco
[Link](1)

if (mise_en_veille_active==True) :#informe que le mode éco est actif

mise_en_veille_active=False
[Link](text='Activer la mise en veille')
elif (mise_en_veille_active==False) :#informe que le mode éco est déactivé
mise_en_veille_active=True
[Link](text='Désactiver la mise en veille')
#######################################################################
# Programme principal #

29
 Utiliser une carte Arduino
dans une station météo

#######################################################################
fenetre_meteo=Tk()#créaction d'une fenêtre graphique
fenetre_meteo.title("Mesures de la station météo")
fenetre_meteo.geometry("800x800")

text1 = StringVar()
[Link]("Activer la recherche du Xbee") #initialise le message : il faut lancer la détection du Xbee
text2 = StringVar()
[Link]("Mesures : ") #
text3 = StringVar()
[Link]("Temps : ")
text_tempe = StringVar()
text_tempe.set("°C")
text_pression=StringVar()
text_hygro=StringVar()
text_vent=StringVar()
label_tempe =Label(fenetre_meteo,textvariable=text_tempe,relief=RAISED,font=("Sans Serif", "24", "bold"),fg ="red"
label_tempe.place(x=20,y=400) #affichage de la température
label_pression =Label(fenetre_meteo,textvariable=text_pression,relief=RAISED,font=("Sans Serif", "24", "bold"),fg =
label_pression .place(x=20,y=450) #affichage de la pression
label_hygro =Label(fenetre_meteo,textvariable=text_hygro,relief=RAISED,font=("Sans Serif", "24", "bold"),fg ="oran
label_hygro.place(x=20,y=500) #affichage de l'hygrométrie
label_vent = Label(fenetre_meteo,textvariable=text_vent,relief=RAISED,font=("Sans Serif", "24", "bold"),fg ="green"
label_vent.place(x=20,y=550)#affichage de la vitesse du vent
B1=Button(fenetre_meteo,text="Détection du Xbee",command=detection_port_Xbee,state=NORMAL,width=100)#Bo
[Link](x=20,y=10)#bouton de détection du Xbee
croix=PhotoImage(file='C:/IFE/Météo/documents_contribution/programme python/[Link]')#image de la croix du bou

B2=Button(fenetre_meteo,image=croix,text='Fermer',command=fermer_programme,state=NORMAL)#Bouton de ferm
[Link](x=600,y=700)
L1=Label(fenetre_meteo,textvariable=text1)#Label Texte affichant l'état d erecherche du Xbee

[Link](x = 160, y=50)

B3=Button(fenetre_meteo,text="Lancer les mesures ",command=lance_mesures,state=DISABLED,width=100)#bouton
[Link](x=20,y=200)#
B4=Button(fenetre_meteo,text="Arrêter les mesures ",command=arret_mesures,state=DISABLED,width=100)#bouton
[Link](x=20,y=250)
B5=Button(fenetre_meteo,text="SD : récuperer les mesures enregistrées",command=recup_mesures,state=NORMAL,w
[Link](x=100,y=700)#commande la lecture du fichier du jour en cours
B7=Button(fenetre_meteo,text="SD : récuperer les mesures enregistrées les jours précédents",command=recup_mesure
[Link](x=100,y=650)#commande la lecture de tous les fichiers
B6=Button(fenetre_meteo,text="Forçage des mesures",command=forcage_mesures,state=DISABLED,width=50)
[Link](x=100,y=100)#commande manuelle la lecture des mesures
B7=Button(fenetre_meteo,text="Désactiver la mise en veille",command=desactive_veille,state=NORMAL,width=50)
[Link](x=400,y=100)# Bouton permettant de désactivier la mise en veille du Xbee Distant
L2=Label(fenetre_meteo,textvariable=text2)
[Link](x = 20, y=300)#Label d'affichage
L3=Label(fenetre_meteo,textvariable=text3)
[Link](x = 20, y=350)

can1 = Canvas(fenetre_meteo,bg='yellow',height=50,width=700)#canvas d'affichage de l'état de la batterie fond

[Link](x= 20, y = 600)
can2 = Canvas(fenetre_meteo,height=50,width=50)#canvas d'affichage de l'état de la batterie
[Link](x=650,y=450)
can3 = Canvas(fenetre_meteo,height=50,width=400)
[Link](x=400,y=400)

poly2=can1.create_polygon(0, 0, 0, 0,0,50,0,50, fill='red')#canvas d'affichage de l'état de la batterie en rouge si pas asse

30
 Utiliser une carte Arduino
dans une station météo

txt0=can1.create_text(350, 30, text="charge batterie", font=("Arial"," 16"), fill="blue")#Texte indiquant l'état de la batt
texte1=can1.create_text(0, 12, text="0 V" , font=("Arial"," 12"," italic"), fill="black")
a = MyTimer(60, mesures, ["MyTimer"]) #un timer de 1 h demande la lecture des données et leur enregistrement

b = MyTimer(2, scrutation_mise_en_veille, ["MyTimer"])#un timer de 2 s scrute le port Xbee

fenetre_meteo.mainloop()

31