Architectur Web Service

INFORMATIQUE
Rapport du Travail d'Etude et de Recherche

du Master 1 Ingnierie Logiciel
Interface Android pour la

consultation de donnes
envoyes par un capteur
Encadrant : Mr BOUNCEUR Ahcne

Ralis par : LE CAM Quentin
TRICHA Mhamed
Anne Universitaire : 2011 2012
Ddicaces
Je remercie ma famille et mon amie, dtre

mes cots durant ma formation. Mais aussi Google
davoir lanc Android qui est pour moi une passion.
- LE CAM Quentin
A mes chers parents et ma sur, qui mont

toujours soutenu et encourag tout au long de mon
parcours, et sans qui je ne serais jamais l
aujourdhui.
- TRICHA Mhamed
Interface Android pour la consultation de donnes envoyes par un capteur | Page 2

Remerciements
Nous tenons remercier profondment notre encadrant, Mr

BOUNCEUR Ahcne, pour nous avoir consacr son temps, pour
nous avoir guid et pour tre rest tout le temps notre coute
et ce du dbut jusqu' la fin de ce travail.
On en profite aussi pour remercier tous nos camarades de

promotion pour leur support moral, qui nous ont aid
dpasser les obstacles et continuer vers lavant, et ce malgr
des priodes de doute et de fatigue.
Enfin, un merci pour toute autre personne qui a contribu de

prs ou de loin la ralisation de ce projet.

Rsum
Notre projet est bas sur le dveloppement embarqu, plus

prcisment lenvironnement Android. En parallle avec
lapplication raliser, il est galement indispensable de savoir
utiliser les capteurs des diffrentes cartes lectroniques mises
notre disposition, ainsi que trouver le moyen idal pour
enregistrer les donnes rcoltes.
On commencera ce rapport par donner une ide gnrale sur

le travail effectu ainsi que les outils et applications utilises,
avant de nous pencher vers une approche pratique.
Le but de ce travail est de raliser une application Android,

capable dafficher les rsultats et enregistrements de divers
capteurs depuis des cartes lectroniques.

Liste des figures
- Figure 1 : Vue de la carte Arduino Mega........................................ 12
- Figure 2 : Vue de de la carte Libelium Wapmote ........................... 13
- Figure 3 : Waspmote Gateway ...................................................... 14
- Figure 4 : Schma dutilisation via Webservices ............................ 18
- Figure 5 : Interface du logiciel Arduino .......................................... 19
- Figure 6 : Relation linaire Temprature-Voltage .......................... 20
- Figure 7 : Interface du logiciel Waspmote IDE ............................... 21
- Figure 8 : Extrait de la base de donnes MySQL ............................ 24
- Figure 9 : Schma dutilisation via socket ...................................... 25
- Figure 10 : Schma dutilisation de la programmation OTA ........... 26
- Figure 11 : Interface du logiciel X-CTU ........................................... 27
- Figure 12 : Interface du terminal ................................................... 28
- Figure 13 : Interface dEclipse ........................................................ 29
- Figure 14 : Interface de lmulateur Android ................................. 30
- Figure 15 : Cycle de vie dune application Android ........................ 31
- Figure 16 : Schma dutilisation de lapplication Android .............. 35
Liste des abrviations

- JSON : JavaScript Object Notation.
- OTA : Over The Air.

Table des matires
Ddicaces ..................................................................................................... ii
Remerciements............................................................................................ iii
Rsum ........................................................................................................ iv
Liste des figures ........................................................................................... v
Liste des abrviations .................................................................................. v
Table des matires ...................................................................................... vi
Chapitre 1 : Prsentation du projet
1.1. Introduction ....................................................................... 8
1.2. Objectif du projet .............................................................. 8
1.3. Mthodologie du projet..................................................... 8
Chapitre 2 : Fondements thoriques
2.1. Cartes ................................................................................ 11
2.2. Capteurs ............................................................................ 13
2.3. Transmetteurs ................................................................... 14
2.4. Collecte de donnes .......................................................... 15
2.5. Base de donnes et Webservices ....................................... 15
2.6. Android .............................................................................. 15
Chapitre 3 : Application ralise
3.1. Cartes embarqus ............................................................. 19
3.1.1. Rcupration des donnes depuis les capteurs .... 19
3.1.2. Rception des donnes ......................................... 22
3.1.3. Transfert de ces donnes via Webservices............ 23
3.1.4. Transfert de ces donnes via socket ..................... 24
3.1.5. Programmation OTA ............................................. 26
3.2. Android .............................................................................. 29
3.2.1. Installation et utilisation de lenvironnement ....... 29
3.2.2. Accs a la base de donnes depuis Android .......... 31
3.2.3. Rcupration des donnes dun socket ................ 33
Conclusion ......................................................................................... 36
Rfrences lectroniques ............................................................................ 37
Annexes ....................................................................................................... 38

Chapitre 1 :
Prsentation
du projet

1.1. Introduction
Ce projet sintgre dans le cadre du Travail dEtude et Recherche, UE faisant partie du

me
8 semestre de la filire Ingnierie Logiciel lUFR Sciences et Techniques de Brest, sous
lencadrement de Mr. BOUNCEUR Ahcne et ralis par LE CAM Quentin et TRICHA
Mhamed.
Nous avons ainsi russi acqurir des connaissances fondamentales dans le domaine du
dveloppement embarqu, et dcouvrir ainsi de nouvelles fonctionnalits qui ne pourront
qutre un plus pour nos futures carrires.
1.2. Objectif du projet
Dans le cadre de notre TER, nous allons nous intresser au domaine des systmes
embarqus, et plus spcifiquement aux applications Android.
Notre travail essayera de rpondre dabord aux questions basiques quon pourrait se
poser en se penchant sur le sujet, savoir : Comment se fait la rcolte des donnes depuis
les capteurs utiliss ? Comment fonctionne notre application ? Quels sont les lments cl
de cette opration ? Quels sont les acteurs ? etc
Pour une tude plus pratique, nous avons dcid de tester en premier, la carte Arduino
sur une base de donnes locale, avant de nous attaquer aux nombreux capteurs de la carte
Libelium pour un accs a une base de donnes distante. Nous esprons que ce travail ralis
sera la hauteur de vos esprances et rpondra toutes vos questions.
1.3. Mthodologie du projet
Notre TER a commenc ds le soir de la distribution des sujets, le 27 Avril dernier. On a

eu droit notre premier entretien avec notre encadrant, Mr BOUNCEUR 3 jours plus tard, o
il nous a expliqu en quoi consistait notre travail et quels outils utiliser.
La semaine suivante fut intgralement ddie aux recherches dinformations. Nous

avons opt pour une approche sans partage de tches afin que les deux membres du binme
puissent aller au mme rythme sans avoir perdre du temps plus tard. Une fois les notions
de base acquises, on sest rapidement attaqu la pratique.
Les premiers tests pratiques ont commenc sur la carte Arduino, avec les capteurs de
prsence et de temprature. Il nous a pas fallu beaucoup de temps pour pouvoir rcuprer

les premires donnes du capteur, ce qui a permis a Quentin dessayer galement le capteur
de prsence, et Mhamed de se familiariser un peu plus avec lenvironnement Android.
Utilisant en un premier temps une base de donnes MySQL locale, et ne voulant plus
dpendre des contraintes quimposent ce mode (adresse IP non-fixe entre-autres), on a
dcid dutiliser une base de donnes externe, hberge sur le domaine de Quentin.
Lutilisation des capteurs de la carte Liblium, la prochaine tape, nous a permis de

pousser ce travail un niveau plus compliqu, mais galement plus intressant. Jusque l, le
travail se faisait en parallle, chacun travaillant de son cot et avanant son rythme. Une
fois lapplication Android finalise, Quentin, en qute dune exprience plus enrichissante,
est parvenue en plus tablir une connexion directe entre les divers capteurs de la carte
Liblium et lapplication Android grce au Wifi.
Ce prsent rapport a t rdig par nous deux, chacun compltant les informations de
lautre, afin de vous proposer une documentation complte de notre travail.
En complment avec ce document, nous avons galement ralis un tutorial en format

HTML, la demande de M. BOUNCEUR Ahcne, expliquant ainsi les tapes de
configurations, les codes de programmes utiliss ainsi que les principes des diffrentes
mthodes utilises pour transfrer les donnes des capteurs lapplication Android.
Ce tutorial est disponible sur le lien suivant :

http://pagesperso.univ-brest.fr/~e21105243/Tuto.html

Chapitre 2 :
Fondements
thoriques

2.1. Cartes
Dans nos tests pratiques, nous avons eu accs 2 cartes lectroniques, Arduino et
Libelium, capables de communiquer entre elles grce des adaptateurs Xbee que nous
prsenterons plus tard.
2.1.1. Arduino
a. Prsentation et caractristiques :
La carte Arduino Mega 2560, prte gnreusement pour le besoin du TER, est une
carte microcontrleur base sur un Atmega2560.
Cette carte dispose :
de 54 broches numriques dentres/sorties,

de 16 entres analogiques,
de 4 UART (port srie matriel),
dun quartz 16Mhz,
dune connexion USB,
dun connecteur dalimentation jack,
dun connecteur ICSP,
et dun bouton de rinitialisation.
Elle contient tout ce qui est ncessaire pour le fonctionnement du microcontrleur.

Pour pouvoir lutiliser et se lancer, il suffit simplement de la connecter un ordinateur
laide dun cble USB (ou de lalimenter avec un adaptateur secteur ou une pile, mais ceci
nest pas indispensable, lalimentation tant fournie par le port USB).
La carte Arduino Mega2560 dispose de toute une srie de facilits pour

communiquer avec un ordinateur, une autre carte Arduino, ou avec dautres
microcontrleurs. L Arduino Mega2560 dispose de quatre UARTs (Universal Asynchronous
Receiver Transmitter ou metteur-rcepteur asynchrone universel en franais) pour une
communication en srie de niveau TTL (5V) et qui est disponible sur les broches 0 (RX) et 1
(TX). Un circuit intgr Atmega8U2 sur la carte assure la connexion entre cette
communication srie de lun des ports srie de lAtmega 2560 vers le port USB de
lordinateur qui apparat comme un port COM virtuel pour les logiciels de lordinateur. Le
code utilis pour programmer lAtmega8U2 utilise le driver standard USB COM, et aucun
autre driver externe nest ncessaire.

Figure 1 : Vue de la carte Arduino Mega 2560
b. Programmation :
Afin de pouvoir programmer la carte Arduino, il faudra le logiciel Arduino pour charger le
code en question. Le logiciel Arduino a pour fonctions principales :
de pouvoir crire et compiler des programmes pour la carte Arduino

de se connecter avec la carte Arduino pour y transfrer les programmes
de communiquer avec la carte Arduino
Le logiciel Arduino intgre galement un TERMINAL SERIE (fentre spare) qui permet
dafficher des messages textes reus de la carte Arduino et denvoyer des caractres vers la
carte Arduino. Cette fonctionnalit permet une mise au point facilite des programmes,
permettant dafficher sur lordinateur ltat de variables, de rsultats de calculs ou de
conversions analogique-numrique : un lment essentiel pour amliorer, tester et corriger
ses programmes.
2.1.2. Libelium
La socit Libelium propose Waspmote, une plateforme Zigbee base sur Arduino et
destine recevoir une multitude de capteurs industriels :
Gaz : CO, CO2, CH4, SH2, NH3, etc.

Evnements : luminosit, poids, inclinaison, acclration, niveau de liquide,
acclration, GPS, etc.

Avec une consommation en veille de 0,7 uA seulement, Waspmote pourra facilement
utiliser des sources dnergies alternatives, tels les panneaux solaires ou des oliennes de
petites tailles.
Pour communiquer, Waspmote utilise les bandes 2.4 GHz, 900 MHz, 868 MHz, voir le
GPRS. Les portes sont de 40 km maximum sur 868 MHz.
Ces Waspmotes sont programmables en C++ via le logiciel Waspmote IDE. Ils doivent
tre connects lordinateur par USB pour la programmation. Une fois programms et
allums, ils peuvent communiquer entre eux de la faon souhaite.
Figure 2 : Vue de la carte Libelium Waspmote avec un Xbee
2.2. Capteurs
Afin doptimiser notre travail et rcolter le maximum de donnes possibles, nous avons
procd lessai des capteurs suivants :
Capteur de temprature
Capteur de prsence
Capteur de CO2
Capteur de qualit dair

Il faut noter que le capteur de CO2 (TGS4161) a un temps de rponse plus long que les
autres capteurs, do la ncessit de dlai dune dure suprieure au minimum 30
secondes.
Le Figaro TGS2600 (capteur de qualit dair) est un capteur qui calcule le taux de
concentration de plusieurs gaz. Parmi ces gaz, on retrouve titre dexemple :
Ethanol (CH3
Isobutane (C4H10).
Monoxyde de Carbone (CO).
Mthane (CH4).
Ce capteur permet galement de calculer le taux de concentrations de lHydrogne (H2).

Damples prcisions ainsi que les fiches techniques de ces capteurs sont disponibles en
annexe.
2.3. Transmetteurs
a. Xbee :
Les modules RF 802.15.4 Xbee-PRO pour OEM sont des solutions embarques offrant
une connectivit sans fils aux terminaux finaux. Ces modules exploitent le protocole IEEE
802.15.4 pour une mise en rseau point--multipoint ou point--point rapide. Ils
conviennent aux applications de hauts dbits ncessitant une faible latence et des dlais de
communications prvisibles.
b. Waspmote Gateway :
En cas dutilisation dune carte Libelium, les Waspmote

Gateway permettent de faire le lien entre lordinateur et le
rseau, en plus des Wapmote. Un Waspmote Gateway est une
interface qui se connecte lordinateur par port USB. On y
branche un modem avec une antenne pour recevoir les
messages du rseau envoys cette interface. Tous les
messages reus sont envoys dans le port USB et peuvent tre
lu avec un logiciel (comme Eclipse).
Figure 3 : Gateway

2.4. Collecte de donnes
La collecte de donnes est une proccupation de plus en plus majeure pour les
entreprises, tant sur les individus que sur lenvironnement. Elles permettent ainsi dtudier
la nature ou de surveiller un espace sur des caractristiques prcises, ou dtre vendues
directement dautres entreprises.
2.5. Base de donnes et Webservices
La base de donnes est un service qui propose de stocker des donnes structures
afin de pouvoir les manipuler. Ce service est plac sur un serveur qui va tre interrog par
les diverses applications site web, logiciel, etc . Une solution qui permet dinteragir avec
une base de donnes est dutiliser les web services. Ce sont des applications dveloppes
dans un langage tel que Java ou Php, elles font le lien entre une application externe et une
base de donnes, permettant ainsi daccder au contenu tout en la gardant en scurit. Car
le fait de pouvoir accder une base de donnes depuis lextrieur directement peut tre
risqu.
2.6. Android
Android os a t cr par une socit portant le mme nom, celle ci fut rachete par
Google en 2007. Depuis, ce systme dexploitation pour mobile bas sur le noyau Linux est
propos aux constructeurs afin quils puissent lintgrer leurs smartphones. Android est
aussi une plateforme ouverte proposant aux dveloppeurs tiers de le modifier ou dy
dvelopper une application qui pourra tre propose au public via un market Google
play . Ces applications sont dveloppes en Java et interprtes par une machine virtuelle

nomme Dalvik qui est implmente directement dans Android. Le fait dutiliser le langage
Java pour la cration dapplication permet aux dveloppeurs de profiter de la librairie
Android mise en place par Google mais aussi de toute la librairie Java standard. De plus
linterface des applications est construite laide dun fichier XML, ce qui permet davoir un
SDK qui propose une aide graphique pour la construction de celles ci.

Chapitre 3 :
Application
ralise

Voici la liste des outils et logiciels utiliss durant ce travail :
Carte Arduino et Libelium

Logiciels Arduino, Waspmote et X-CTU
Capteurs de temprature, prsence et gaz
Modules Xbee
Base de donnes MySQL
Eclipse
Notre travail consiste en 3 tapes distinctes :
- La collecte des donnes depuis les capteurs

- Le transfert de ces donnes vers une base de donnes
- La rcupration de ces donnes sur lAndroid
Il peut tre reprsent via ce schma :
Radio
Carte Arduino et capteurs Machine Webservices
Base de donnes
distante
Interne
Application Android
Figure 4 : Schma dutilisation via Webservices

3.1 Cartes embarques
3.1.1 Rcupration des donnes depuis les capteurs :
Nous avons dans un premier temps utilis la carte Arduino pour calculer la temprature
ambiante. Le capteur de temprature MCP9700A lit des donnes quon convertit en valeurs
utilisables selon la mesure requise.
Pour cela, nous avons besoin du logiciel open-source Arduino, tlchargeable sur le site
officiel. Aprs avoir install le driver correspondant, il faudra galement slectionner la carte
et le port avant utilisation depuis longlet Tools.
Figure 5 : Interface du logiciel Arduino
Un programme Arduino est un fichier de code crit en langage proche du java. Une fois
compil et transfr vers la carte Arduino (via USB), on peut accder aux rsultats du
programme via le terminal incorpor au logiciel. Ici un extrait du code utilis pour relever les
valeurs de temprature depuis le capteur de temprature :
void loop()
{ int reading = analogRead(sensorPin);
float voltage = reading * 5.0;
voltage /= 1024.0;
float temperatureC = (voltage - 0.5) * 100 ;
Serial.print(temperatureC);
delay(1000);
}

Dans cet exemple, la carte Arduino lit la valeur releve par le capteur de temprature
grce la fonction analorgRead(). Cette valeur est ensuite convertie en voltage grce une
formule. Puis, on convertit le voltage en temprature degr Celsius grce une formule
linaire entre ces deux entits que lon retrouve dans ce schma :
Figure 6 : Relation linaire Temprature-Voltage
Il suffira ensuite de mettre ce code dans une boucle loop() pour recevoir ces donnes
aprs un dlai (au choix) d1 seconde.
Pour la carte Liblium qui offre lopportunit de tester des capteurs de gaz comme le
CO2, le principe reste le mme, si ce nest que les capteurs de gaz demandent une dure
minimale de 30 secondes pour chauffer avant de transmettre la valeur souhaite.

Pour pouvoir rcuprer les donnes des capteurs, nous avons besoin de lAPI
Waspmote IDE afin de pouvoir compiler et transfrer les programmes vers la carte Liblium.
Figure 7 : Interface du logiciel Waspmote IDE
Il faut savoir galement quon peut rcuprer plusieurs donnes (de diffrents
capteurs) durant le mme envoi de donnes. Pour cela, il suffit de concatner ces donnes
sous forme de chaine de caractres envoyer aprs un dlai fixe.
Ci-dessous un exemple de code pour relever les taux de CO2 :
void loop()
{
SensorGas.setBoardMode(SENS_ON);
SensorGas.configureSensor(SENS_CO2,GAIN_CO2);
SensorGas.setSensorMode(SENS_ON, SENS_CO2);
delay(30000);
float valco2 = SensorGas.readValue(SENS_CO2);
float co2 = 350*pow(10, valco2);
SensorGas.setSensorMode(SENS_OFF, SENS_CO2);
USB.println(co2);
}
Le rsultat du programme renvoie la concentration du CO2 en PPM aprs chaque 30

secondes.

Pour ce qui est du capteur prsence, il faut mettre en place une interruption qui va
rveiller la carte et envoyer un signal lorsque le capteur est activ.
void loop(){
SensorEvent.attachInt();
PWR.sleep(UART0_OFF | UART1_OFF | BAT_OFF | RTC_OFF);
SensorEvent.detachInt();
SensorEvent.loadInt();
if (SensorEvent.intFlag & SENS_SOCKET7){
XBee.setMode(XBEE_ON);
XBee.begin();
delay(200);
v = SensorEvent.readValue(SENS_SOCKET7);
XBee.print("1");
XBee.print(v);
delay(200);XBee.close();
}
}
3.1.2. Rception des donnes
Une fois la valeur de temprature acquise, il faudra dsormais lenvoyer vers notre
machine de travail pour pouvoir la stocker dans une base de donnes MySQL. Pour cela,
nous allons utiliser la connexion Radio qui relie 2 modules Xbee via le protocole 802.15.4. En
effet, lordinateur reoit les valeurs envoyes par la carte Arduino qui seront ensuite lues et
traites sur Eclipse grce la librairie RXTX, une librairie open-source externe qui permet au
JDK de communiquer avec dautres objets. Cette librairie nous offre la possibilit de lire sur
le port slectionn (ici USB), de la mme manire quun port srie. Dans un premier temps, il
faut ouvrir la connexion sur une frquence et ensuite crer les ouputStream et inputStream
qui nous permettrons de lire et crire sur le port srie.
serialPort = (SerialPort) portId.open(this.getClass().getName(),

2000);
serialPort.setSerialPortParams(38400,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
input = serialPort.getInputStream();
output = serialPort.getOutputStream();
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);

Ensuite cette librairie nous offre la possibilit de r-implmenter une mthode qui va
tre appele lorsquun message est reu sur le port srie. Ce qui nous permet ainsi de
pouvoir effectuer un traitement prcis sur les donnes qui ont t transmise.
@Override
public synchronized void serialEvent(SerialPortEvent oEvent) {
if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
try {
int chunk = input.read();//Lecture sur le port srie
if (chunk == '0') {//nouvelle carte libelium alum
System.out.println("demarrage d'une carte");
}
} catch (Exception e) {
System.err.println(e.toString());
}
}
}
3.1.3. Transfert de ces donnes vers une base de donnes :
Le programme Java se chargera de crer une liaison et de convertir les donnes reues
dans un format correspondant.
Vient ensuite ltape des Webservices : Le code Java appelle un script PHP auquel il
passera les valeurs releves sous forme de paramtres. Le script PHP se charge alors
dinsrer ces dernires dans une base de donnes.
Ci-dessous un extrait du code Java sur Eclipse qui permet denvoyer les donnes reues
depuis la carte Liblium :
URL url = new

URL("http://localhost/libelium.php?data1="+date+"&data2="+data2+"&data3
="+data3+"&data4="+data4+"&data5="+data5);
HttpURLConnection con = (HttpURLConnection)url.openConnection();
con.setRequestMethod("GET");
con.connect();
con.getContent();
Ainsi quun extrait du script PHP en question :

<?php
$req =mysql_query("INSERT INTO
libelium(HEURE,CELSIUS,CARBONE,CONCENT,AIR)
VALUES('".$_GET["data1"]."','".$_GET["data2"]."','".$_GET["data3"]."',
'".$_GET["data4"]."','".$_GET["data5"]."')");
?>
Le rsultat peut tre visualis directement sur la base de donnes :
Figure 8 : Extrait de la base de donnes MySQL
3.1.4. Transfert de ces donnes avec une socket
Cest une mthode qui permet un change de donnes en direct entre les deux
services, ici le programme java qui contrle les cartes liblium et le smartphone Android.
Ce qui permet davoir la rception de linformation au moment o elle a t mise.

Radio Socket Internet
Carte Liblium et capteurs Machine
Socket
Application Android
Figure 9 : Schma dutilisation via sockets
Sur la machine host qui fait le lien entre la carte et le smartphone, il faut mettre en place
une socket serveur dcoute sur un port prcis, qui va attendre larrive dun nouveau client
afin de lui envoyer les informations sur ltat du capteur.
ServerSocket s = new
ServerSocket(3434,0,InetAddress.getLocalHost());
Socket cli = s.accept();//attende dun client
byte[] b = new byte[512];

InputStream is = cli.getInputStream();
while((is.read(b))>0){
if(new String(b).contains("connection"))break;
b = new byte[512];
}
OutputStream os = cli.getOutputStream();
os.write("connection ok".getBytes());//envoi dun message

3.1.5. Programmation OTA (Over The Air)
a. Principe :
La programmation OTA (Over The Air) est une technologie sans-fil permettant la
programmation et la transmission de donnes sans avoir relier le matriel grce a un cble.
Les cartes Libelium Waspmote intgrent en effet cette technologie, et permettent la
programmation de ces cartes sans-fil via le protocole 802.15.4 accessible grce aux XBee.
Parmi les fonctionnalits de cette technologie, on peut citer :
La possibilit de mettre jour la version du firmware sans-fil.

La recherche des cartes disponibles a proximit.
Figure 10 : Schma dutilisation de la programmation OTA
Le principe de lOTA consiste envoyer un nouveau programme sur une carte SD

insre au niveau de la carte Libelium grce des commandes ralises sur un terminal.
Cette dernire se chargera ensuite de copier ce programme dans sa mmoire Flash depuis la
carte SD.
b. Application :
Pour mettre au point la technologie Over The Air, il faut dabord :

- Un Waspmote Gateway pour diffuser le nouveau programme.
- Un rseau de cartes Waspmote quipes de cartes SD.
- Un terminal pour envoyer les commandes.
Dabord, il faut sassurer que la carte SD est compatible avec lOTA. Une carte SD
contient en gnral des blocs dfectueux qui ne peuvent tre ignors lors de lutilisation de
la programmation OTA, cest pour cela que les seules cartes SD garanties fonctionner sont
celles distribues par Libelium, ayant comme capacit 1,86 Go.
Ensuite, il faut vrifier que les cartes Waspmote aient une configuration identique.
Pour cela, nous avons utilis le logiciel X-CTU, qui permet de modifier la configuration dune
carte Waspmote.
Figure 11 : Interface du logiciel X-CTU
Pour utiliser lOTA, il faut avoir :

- La mme version API (1 pour les cartes Waspmote, 2 pour le Waspmote
Gateway).
- Le mme canal.
- Le mme PAN ID.

Une fois cela fait, il faudra tlcharger lAPI open-source OTA disponible sur le site
officiel Libelium, et renseigner la configuration cite plus haut dans le fichier Xbee.conf.
Enfin, on peut lancer, depuis un terminal Windows, les commandes suivantes :
otap -scan_nodes : Pour lister toutes les cartes Waspmote disponibles

proximit, leurs adresses MAC ainsi que leurs tats.
otap -send : Pour envoyer le nouveau programme aux nodes prts.
otap -start_new_program : Pour charger le nouveau programme sur les cartes
Waspmote.
Dautres options sont disponibles pour la programmation OTA, notamment le choix

de lenvoi du programme (UNICAST, MULTICAST, BROADCAST, ).
Figure 12 : Interface du terminal

3.2. Android
3.2.1. Installation et utilisation de lenvironnement de travail
La conception de lapplication Android sest droule sur 3 tapes distinctes :
- Cration de la structure de lapplication en Java.

- Ouvrir une connexion entre lapplication et la base de donnes.
- Ouvrir une connexion directe entre lapplication et le pc
Nous avons commenc par installer un environnement Java, avec Eclipse (version
Indigo). Afin de pouvoir lire et modifier les donnes reues depuis les cartes et leurs
capteurs, il est impratif dutiliser la libraire RXTX pour de pouvoir lancer le programme.
Vient ensuite ltape dinstallation du SDK Android, savoir lenvironnement de travail
consacr la programmation pour Android. Celui-ci propose une dition dinterface en
graphique et permet dutiliser les librairies requises pour la conception dune application.
Figure 13 : Interface dEclipse
Lun des avantages du SDK Android sur Eclipse est la disponibilit davoir un mulateur
permettant ainsi de vrifier le fonctionnement des applications ainsi que leur rendu avant de
les tester sur du matriel.

Figure 14 : Interface de lmulateur Android
Pour crer une application Android, il suffit de commencer un nouveau projet Android et
indiquer lAPI minimum requise pour son utilisation, ce qui permet choisir la version
minimum dAndroid.
Durant le dmarrage dune application sur Android, il y a un cycle de procdure

respecter. Ce qui permet au dmarrage de choisir linterface mettre en place ainsi que les
fonctionnalits des lments de celle ci. Le cycle de vie dune application permet aussi de
pouvoir librer lespace durant une autre activit.

Figure 15 : Cycle de vie dune application Android
3.2.2. Accs a la base de donnes depuis Android :
Lapplication Android, offre un menu son ouverture afin de pouvoir choisir les donnes
afficher.
La connexion avec la base de donnes se fait sous forme dune requte HTTP afin
dappeler un script PHP, hberg sur un serveur externe WebService . Ci-dessous un
extrait du code Java pour lappel du script:

try{
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost("http://generation-
droide.fr/TERANDROID/temp.php");
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
is = entity.getContent();
}
Ci-dessous un extrait du script PHP utilise pour extraire les donnes. Ce dernier va
convertir les donnes reues via la requte SELECT en format JSON compatible avec Android:
<?php
$req =mysql_query("SELECT temperature.INDEX, HEURE, CELSIUS from
temperature ORDER BY temperature.INDEX DESC");
while ($row=mysql_fetch_array($req)) {
$output[]=$row;
}
print(json_encode($output));
?>
Le rsultat retourn par cette requte est alors en format JSON :
[{"0":"809","INDEX":"809","1":"13:45:37","HEURE":"13:45:37","2":"20.80","
CELSIUS":"20.80"},{"0":"808","INDEX":"808","1":"13:45:36","HEURE":"13:45:
36","2":"20.31","CELSIUS":"20.31"},{"0":"803","INDEX":"803","1":"13:45:31"
,"HEURE":"13:45:31","2":"20.31","CELSIUS":"20.31"},{"0":"802","INDEX":"80
2","1":"13:45:30","HEURE":"13:45:30","2":"21.29","CELSIUS":"21.29"}, ]
Lapplication convertira en un premier temps ces donnes en chaine de caractres avant

de rcuprer les donnes JSON pour les afficher selon le format souhait.

Intent
Le rsultat final est une liste des donnes enregistres.
3.2.3. Rcupration des donnes dun socket
Pour ce qui est du client Android , cest la cration dun socket sur une adresse IP et
un numro de port qui va crer la connexion sur le serveur. Une fois la connexion tablie, il
ne reste plus qu utiliser les inputStream et outputStream pour communiquer avec
le serveur.
s = new Socket("172.29.76.254",3434);//connection
byte[] b = new byte[512];
int n;
//teste si la connection a bien t effectu
if (s.isConnected()) {
handler.sendEmptyMessage(INFO_CONNECTION);
OutputStream os = s.getOutputStream();
os.write("connection".getBytes());
//se place en lecture de flux
InputStream is = s.getInputStream();
while((n=is.read(b))>0){
char car = (char) b[0];
//teste si il s'agit d'une information capteur de prsence
if(car == '1'){
//envoi un message au handler
handler.sendEmptyMessage(INFO_CAPTEUR);
}
b = new byte[512];
}
}

Ainsi le client reste dans la boucle de lecture while afin de recevoir les donnes
envoyes par le serveur. Pour ne pas bloquer lensemble du programme sur la lecture du
socket, il faut placer cette partie dans un autre Thread.
Application IHM
Thread socket
Signal
Thread principal
Socket
Matriel
Sur Android lIHM est la proprit du thread principal, il est donc impossible de
modifier ou de lancer une autre interface via le thread qui gre le socket. Cest pourquoi il
faut utiliser un Handler, qui va permettre lchange de messages entre les Threads avec la
fonction handler.sendEmptyMessage(INFO_CAPTEUR). Celui-ci en fonction de la valeur
passe en paramtre va effectuer une action dans le Thread principal.
Procdure de connexion et communication avec le serveur :
handler = new Handler(){

@Override
public void handleMessage(Message msg) {
switch(msg.what){
case INFO_CAPTEUR:
Intent intent = new Intent(context, passage.class);
startActivity(intent);
break;
case INFO_CONNECTION :
param.setBackgroundResource(R.drawable.button_green);
break;
}
}
};

Intent
Socket
Socket
Connexion Envoi donnes capteur
Figure 16 : Schma dutilisation de lapplication Android

Conclusion
Ce travail tait une occasion de nous approfondir dans le monde de la

programmation des systmes embarqus, et une opportunit de tester les
diffrents capteurs disponibles au laboratoire de faons diffrentes.
Notre travail sest droul en 3 tapes distinctes : On a dabord

commenc par nous familiariser avec le sujet, savoir les diffrents capteurs,
leurs modes de communication et lenvironnement Android, avant de passer
la pratique et tudier chaque outil, dabord la carte Arduino puis la carte
Libelium, pour enfin concevoir une application Android capable de grer toutes
ces donnes, chacun apportant les connaissances quil a ainsi pu acqurir
auprs de loutil quil tudiait.
Nous esprons que ce rapport permet de rpondre aux questions quon

pourrait se poser en se penchant sur ce sujet et que notre travail est la
hauteur de vos esprances.

Rfrences lectroniques
Support Android
http://developer.android.com/index.html
Support Arduino
http://arduino.cc/en/Tutorial/HomePage
Documentation Waspmote
http://www.libelium.com/support/waspmote
Forum Libelium :
http://www.libelium.com/forum/
Tutorial ralis :
http://pagesperso.univ-brest.fr/~e21105243/Tuto.html

Annexes

Annexe 1 : Matriel utilis
Logo :
Nom : Arduino
Produit : Arduino Mega 2560
Microcontrleur : ATmega2560
Mmoire Programme Flash : 256 KB
Mmoire SRAM : 8 KB
Mmoire EEPROM : 4 KB
Vitesse d'horloge : 16 MHz
Tableau 1 : Fiche technique de la carte Arduino
Logo :
Nom : Libelium
Produit : Waspmote v1.1
Microcontrleur : ATmega1281
Mmoire Programme Flash : 128 KB
Mmoire SRAM : 8 KB
Mmoire EEPROM : 4 KB
Vitesse d'horloge : 8 MHz
Tableau 2: Fiche technique de la carte Libelium
Nom : TGS2600
Capteur :
Fonction : Capteur de gaz

Champs de mesure : 1~100ppm
Consommation : 46mA
Temprature: -10C ~ +40C
Temps de rponse : 30 secondes
Nom : MCP9700A
Capteur :
Fonction : Capteur de temprature

Nombre de broches : 3
Prcision : 1C
Temprature Max : 125C
Temprature Min : -40C
Tension dalimentation : 2.5, 3.3, 5V
Type de sortie : Analogique
Nom : TGS4161
Capteur :
Fonction : Capteur de CO2

Champs de mesure : 350~10000ppm
Voltage a 330ppm : 220~490V
Temprature: -10C ~ +50C
Temps de rponse : 1.5 minute
Consommation : 50mA
Nom : PIR

Capteur :
Fonction : Capteur de prsence

Hauteur : 24.3mm
Longueur : 28.0mm
Consommation : 100A
Dtection : 6-7m

Architectur Web Service

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Architectur Web Service

Încărcat de

Drepturi de autor:

Formate disponibile

INFORMATIQUE

Rapport du Travail d'Etude et de Recherche

Interface Android pour la

Encadrant : Mr BOUNCEUR Ahcne

Je remercie ma famille et mon amie, dtre

A mes chers parents et ma sur, qui mont

Interface Android pour la consultation de donnes envoyes par un capteur | Page 2

Nous tenons remercier profondment notre encadrant, Mr

On en profite aussi pour remercier tous nos camarades de

Enfin, un merci pour toute autre personne qui a contribu de

Interface Android pour la consultation de donnes envoyes par un capteur | Page 3

Notre projet est bas sur le dveloppement embarqu, plus

On commencera ce rapport par donner une ide gnrale sur

Le but de ce travail est de raliser une application Android,

Interface Android pour la consultation de donnes envoyes par un capteur | Page 4

Liste des abrviations

Interface Android pour la consultation de donnes envoyes par un capteur | Page 5

Interface Android pour la consultation de donnes envoyes par un capteur | Page 6

Interface Android pour la consultation de donnes envoyes par un capteur | Page 7

Ce projet sintgre dans le cadre du Travail dEtude et Recherche, UE faisant partie du

1.2. Objectif du projet

1.3. Mthodologie du projet

Notre TER a commenc ds le soir de la distribution des sujets, le 27 Avril dernier. On a

La semaine suivante fut intgralement ddie aux recherches dinformations. Nous

Interface Android pour la consultation de donnes envoyes par un capteur | Page 8

Lutilisation des capteurs de la carte Liblium, la prochaine tape, nous a permis de

En complment avec ce document, nous avons galement ralis un tutorial en format

Ce tutorial est disponible sur le lien suivant :

Interface Android pour la consultation de donnes envoyes par un capteur | Page 9

Interface Android pour la consultation de donnes envoyes par un capteur | Page 10

Cette carte dispose :

de 54 broches numriques dentres/sorties,

Elle contient tout ce qui est ncessaire pour le fonctionnement du microcontrleur.

La carte Arduino Mega2560 dispose de toute une srie de facilits pour

Interface Android pour la consultation de donnes envoyes par un capteur | Page 11

de pouvoir crire et compiler des programmes pour la carte Arduino

Gaz : CO, CO2, CH4, SH2, NH3, etc.

Interface Android pour la consultation de donnes envoyes par un capteur | Page 12

Figure 2 : Vue de la carte Libelium Waspmote avec un Xbee

Interface Android pour la consultation de donnes envoyes par un capteur | Page 13

Ce capteur permet galement de calculer le taux de concentrations de lHydrogne (H2).

En cas dutilisation dune carte Libelium, les Waspmote

Interface Android pour la consultation de donnes envoyes par un capteur | Page 14

2.5. Base de donnes et Webservices

Interface Android pour la consultation de donnes envoyes par un capteur | Page 15

Interface Android pour la consultation de donnes envoyes par un capteur | Page 16

Interface Android pour la consultation de donnes envoyes par un capteur | Page 17

Carte Arduino et Libelium

Notre travail consiste en 3 tapes distinctes :

- La collecte des donnes depuis les capteurs

Il peut tre reprsent via ce schma :

Carte Arduino et capteurs Machine Webservices

Figure 4 : Schma dutilisation via Webservices

Interface Android pour la consultation de donnes envoyes par un capteur | Page 18

3.1.1 Rcupration des donnes depuis les capteurs :

Figure 5 : Interface du logiciel Arduino

Interface Android pour la consultation de donnes envoyes par un capteur | Page 19

Figure 6 : Relation linaire Temprature-Voltage

Interface Android pour la consultation de donnes envoyes par un capteur | Page 20

Figure 7 : Interface du logiciel Waspmote IDE

Le rsultat du programme renvoie la concentration du CO2 en PPM aprs chaque 30

Interface Android pour la consultation de donnes envoyes par un capteur | Page 21

serialPort = (SerialPort) portId.open(this.getClass().getName(),

Interface Android pour la consultation de donnes envoyes par un capteur | Page 22