Interface Android pour la consultation de données envoyées par un

Rapport du Travail d'Etude et de Recherche du Master 1 Ingénierie Logiciel

Interface Android pour la consultation de données envoyées par un capteur

Encadrant : Mr BOUNCEUR Ahcène

Réalisé par : LE CAM Quentin TRICHA M’hamed

Année Universitaire : 2011 – 2012

INFORMATIQUE

Interface Android pour la consultation de données envoyées par un capteur | Page 2

Dédicaces

‘‘ Je remercie ma famille et mon amie, d’être à mes cotés durant ma formation. Mais aussi à Google d’avoir lancé Android qui est pour moi une passion.’’

- LE CAM Quentin

‘‘ A mes chers parents et ma sœur, qui m’ont toujours soutenu et encouragé tout au long de mon parcours, et sans qui je ne serais jamais là aujourd’hui. ’’

- TRICHA M’hamed


Remerciements

Nous tenons à remercier profondément notre encadrant, Mr

BOUNCEUR Ahcène, pour nous avoir consacré son temps, pour nous avoir guidé et pour être resté tout le temps à notre écoute et ce du début 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é à dépasser les obstacles et à continuer vers l’avant, et ce malgré des périodes de doute et de fatigue.

Enfin, un merci pour toute autre personne qui a contribué de près ou de loin à la réalisation de ce projet.


Résumé

Notre projet est basé sur le développement embarqué, plus

précisément l’environnement Android. En parallèle avec l’application à réaliser, il est également indispensable de savoir utiliser les capteurs des différentes cartes électroniques mises à notre disposition, ainsi que trouver le moyen idéal pour enregistrer les données récoltées.

On commencera ce rapport par donner une idée générale sur le travail effectué ainsi que les outils et applications utilisées, avant de nous pencher vers une approche pratique.

Le but de ce travail est de réaliser une application Android, capable d’afficher les résultats 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 : Schéma d’utilisation via Webservices ............................ 18 - Figure 5 : Interface du logiciel Arduino .......................................... 19 - Figure 6 : Relation linéaire Température-Voltage .......................... 20 - Figure 7 : Interface du logiciel Waspmote IDE ............................... 21 - Figure 8 : Extrait de la base de données MySQL ............................ 24 - Figure 9 : Schéma d’utilisation via socket ...................................... 25 - Figure 10 : Schéma d’utilisation de la programmation OTA ........... 26 - Figure 11 : Interface du logiciel X-CTU ........................................... 27 - Figure 12 : Interface du terminal ................................................... 28 - Figure 13 : Interface d’Eclipse ........................................................ 29 - Figure 14 : Interface de l’émulateur Android ................................. 30 - Figure 15 : Cycle de vie d’une application Android ........................ 31 - Figure 16 : Schéma d’utilisation de l’application Android .............. 35

Liste des abréviations

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


Table des matières Dédicaces ..................................................................................................... ii Remerciements ............................................................................................ iii Résumé ........................................................................................................ iv Liste des figures ........................................................................................... v Liste des abréviations .................................................................................. v Table des matières ...................................................................................... vi

Chapitre 1 : Présentation du projet 1.1. Introduction ....................................................................... 8 1.2. Objectif du projet .............................................................. 8 1.3. Méthodologie du projet ..................................................... 8

Chapitre 2 : Fondements théoriques 2.1. Cartes ................................................................................ 11 2.2. Capteurs ............................................................................ 13 2.3. Transmetteurs ................................................................... 14 2.4. Collecte de données .......................................................... 15 2.5. Base de données et Webservices ....................................... 15 2.6. Android .............................................................................. 15

Chapitre 3 : Application réalisée 3.1. Cartes embarqués ............................................................. 19

3.1.1. Récupération des données depuis les capteurs .... 19 3.1.2. Réception des données ......................................... 22 3.1.3. Transfert de ces données via Webservices ............ 23 3.1.4. Transfert de ces données via socket ..................... 24 3.1.5. Programmation OTA ............................................. 26

3.2. Android .............................................................................. 29 3.2.1. Installation et utilisation de l’environnement ....... 29 3.2.2. Accès a la base de données depuis Android .......... 31 3.2.3. Récupération des données d’un socket ................ 33

Conclusion ......................................................................................... 36 Références électroniques ............................................................................ 37 Annexes ....................................................................................................... 38


Chapitre 1 :

Présentation du projet


1.1. Introduction

Ce projet s’intègre dans le cadre du Travail d’Etude et Recherche, UE faisant partie du 8ème semestre de la filière Ingénierie Logiciel à l’UFR Sciences et Techniques de Brest, sous l’encadrement de Mr. BOUNCEUR Ahcène et réalisé par LE CAM Quentin et TRICHA M’hamed.

Nous avons ainsi réussi à acquérir des connaissances fondamentales dans le domaine du développement embarqué, et découvrir ainsi de nouvelles fonctionnalités qui ne pourront qu’être un plus pour nos futures carrières.

1.2. Objectif du projet

Dans le cadre de notre TER, nous allons nous intéresser au domaine des systèmes embarqués, et plus spécifiquement aux applications Android.

Notre travail essayera de répondre d’abord aux questions basiques qu’on pourrait se poser en se penchant sur le sujet, à savoir : Comment se fait la récolte des données depuis les capteurs utilisés ? Comment fonctionne notre application ? Quels sont les éléments clé de cette opération ? Quels sont les acteurs ? etc …

Pour une étude plus pratique, nous avons décidé de tester en premier, la carte Arduino sur une base de données locale, avant de nous attaquer aux nombreux capteurs de la carte Libelium pour un accès a une base de données distante. Nous espérons que ce travail réalisé sera à la hauteur de vos espérances et répondra à toutes vos questions.

1.3. Méthodologie du projet

Notre TER a commencé dès 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 intégralement dédiée aux recherches d’informations. Nous avons opté pour une approche sans partage de tâches afin que les deux membres du binôme puissent aller au même rythme sans avoir à perdre du temps plus tard. Une fois les notions de base acquises, on s’est rapidement attaqué à la pratique.

Les premiers tests pratiques ont commencé sur la carte Arduino, avec les capteurs de présence et de température. Il nous a pas fallu beaucoup de temps pour pouvoir récupérer


les premières données du capteur, ce qui a permis a Quentin d’essayer également le capteur de présence, et à M’hamed de se familiariser un peu plus avec l’environnement Android.

Utilisant en un premier temps une base de données MySQL locale, et ne voulant plus dépendre des contraintes qu’imposent ce mode (adresse IP non-fixe entre-autres), on a décidé d’utiliser une base de données externe, hébergée sur le domaine de Quentin.

L’utilisation des capteurs de la carte Libélium, la prochaine étape, nous a permis de pousser ce travail à un niveau plus compliqué, mais également plus intéressant. Jusque là, le travail se faisait en parallèle, chacun travaillant de son coté et avançant à son rythme. Une fois l’application Android finalisée, Quentin, en quête d’une expérience plus enrichissante, est parvenue en plus à établir une connexion directe entre les divers capteurs de la carte Libélium et l’application Android grâce au Wifi.

Ce présent rapport a été rédigé par nous deux, chacun complétant les informations de l’autre, afin de vous proposer une documentation complétée de notre travail.

En complément avec ce document, nous avons également réalisé un tutorial en format HTML, à la demande de M. BOUNCEUR Ahcène, expliquant ainsi les étapes de configurations, les codes de programmes utilisés ainsi que les principes des différentes méthodes utilisées pour transférer les données des capteurs à l’application Android.

Ce tutorial est disponible sur le lien suivant : http://pagesperso.univ-brest.fr/~e21105243/Tuto.html


Chapitre 2 :

Fondements théoriques


2.1. Cartes Dans nos tests pratiques, nous avons eu accès à 2 cartes électroniques, Arduino et Libelium, capables de communiquer entre elles grâce à des adaptateurs Xbee que nous présenterons plus tard.

2.1.1. Arduino

a. Présentation et caractéristiques :

La carte Arduino Mega 2560, prêtée généreusement pour le besoin du TER, est une carte à microcontrôleur basée sur un Atmega2560.

Cette carte dispose :

de 54 broches numériques d’entrées/sorties, de 16 entrées analogiques, de 4 UART (port série matériel), d’un quartz 16Mhz, d’une connexion USB, d’un connecteur d’alimentation jack, d’un connecteur ICSP, et d’un bouton de réinitialisation.

Elle contient tout ce qui est nécessaire pour le fonctionnement du microcontrôleur. Pour pouvoir l’utiliser et se lancer, il suffit simplement de la connecter à un ordinateur à l’aide d’un câble USB (ou de l’alimenter avec un adaptateur secteur ou une pile, mais ceci n’est pas indispensable, l’alimentation étant fournie par le port USB).

La carte Arduino Mega2560 dispose de toute une série de facilités pour communiquer avec un ordinateur, une autre carte Arduino, ou avec d’autres microcontrôleurs. L’ Arduino Mega2560 dispose de quatre UARTs (Universal Asynchronous Receiver Transmitter ou émetteur-récepteur asynchrone universel en français) pour une communication en série de niveau TTL (5V) et qui est disponible sur les broches 0 (RX) et 1 (TX). Un circuit intégré Atmega8U2 sur la carte assure la connexion entre cette communication série de l’un des ports série de l’Atmega 2560 vers le port USB de l’ordinateur qui apparaît comme un port COM virtuel pour les logiciels de l’ordinateur. Le code utilisé pour programmer l’Atmega8U2 utilise le driver standard USB COM, et aucun autre driver externe n’est nécessaire.


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 transférer les programmes de communiquer avec la carte Arduino

Le logiciel Arduino intègre également un TERMINAL SERIE (fenêtre séparée) qui permet d’afficher des messages textes reçus de la carte Arduino et d’envoyer des caractères vers la carte Arduino. Cette fonctionnalité permet une mise au point facilitée des programmes, permettant d’afficher sur l’ordinateur l’état de variables, de résultats de calculs ou de conversions analogique-numérique : un élément essentiel pour améliorer, tester et corriger ses programmes.

2.1.2. Libelium

La société Libelium propose Waspmote, une plateforme Zigbee basée sur Arduino et destinée à recevoir une multitude de capteurs industriels :

Gaz : CO, CO2, CH4, SH2, NH3, etc. Evènements : luminosité, poids, inclinaison, accélération, niveau de liquide,

accélération, GPS, etc.


Avec une consommation en veille de 0,7 uA seulement, Waspmote pourra facilement utiliser des sources d’énergies 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 portées sont de 40 km maximum sur 868 MHz.

Ces Waspmotes sont programmables en C++ via le logiciel Waspmote IDE. Ils doivent être connectés à l’ordinateur par USB pour la programmation. Une fois programmés et allumés, ils peuvent communiquer entre eux de la façon souhaitée.

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

2.2. Capteurs

Afin d’optimiser notre travail et récolter le maximum de données possibles, nous avons procèdé à l’essai des capteurs suivants :

Capteur de température Capteur de présence Capteur de CO2 Capteur de qualité d’air


Il faut noter que le capteur de CO2 (TGS4161) a un temps de réponse plus long que les autres capteurs, d’où la nécessité de délai d’une durée supérieure au minimum à 30 secondes.

Le Figaro TGS2600 (capteur de qualité d’air) est un capteur qui calcule le taux de concentration de plusieurs gaz. Parmi ces gaz, on retrouve à titre d’exemple :

Ethanol (CH3 Isobutane (C4H10). Monoxyde de Carbone (CO). Méthane (CH4).

Ce capteur permet également de calculer le taux de concentrations de l’Hydrogène (H2).

D’amples précisions 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 embarquées offrant une connectivité sans fils aux terminaux finaux. Ces modules exploitent le protocole IEEE 802.15.4 pour une mise en réseau point-à-multipoint ou point-à-point rapide. Ils conviennent aux applications de hauts débits nécessitant une faible latence et des délais de communications prévisibles.

b. Waspmote Gateway :

En cas d’utilisation d’une carte Libelium, les Waspmote

Gateway permettent de faire le lien entre l’ordinateur et le réseau, en plus des Wapmote. Un Waspmote Gateway est une interface qui se connecte à l’ordinateur par port USB. On y branche un modem avec une antenne pour recevoir les messages du réseau envoyés à cette interface. Tous les messages reçus sont envoyés dans le port USB et peuvent être lu avec un logiciel (comme Eclipse).

Figure 3 : Gateway


2.4. Collecte de données La collecte de données est une préoccupation de plus en plus majeure pour les

entreprises, tant sur les individus que sur l’environnement. Elles permettent ainsi d’étudier la nature ou de surveiller un espace sur des caractéristiques précises, ou d’être vendues directement à d’autres entreprises.

2.5. Base de données et Webservices

La base de données est un service qui propose de stocker des données structurées 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 d’interagir avec une base de données est d’utiliser les web services. Ce sont des applications développées dans un langage tel que Java ou Php, elles font le lien entre une application externe et une base de données, permettant ainsi d’accéder au contenu tout en la gardant en sécurité. Car le fait de pouvoir accéder à une base de données depuis l’extérieur directement peut être risqué.

2.6. Android

Android os a été créé par une société portant le même nom, celle ci fut rachetée par Google en 2007. Depuis, ce système d’exploitation pour mobile basé sur le noyau Linux est proposé aux constructeurs afin qu’ils puissent l’intégrer à leurs smartphones. Android est aussi une plateforme ouverte proposant aux développeurs tiers de le modifier ou d’y développer une application qui pourra être proposée au public via un market « Google play ». Ces applications sont développées en Java et interprétées par une machine virtuelle


nommée Dalvik qui est implémentée directement dans Android. Le fait d’utiliser le langage Java pour la création d’application permet aux développeurs de profiter de la librairie Android mise en place par Google mais aussi de toute la librairie Java standard. De plus l’interface des applications est construite à l’aide d’un fichier XML, ce qui permet d’avoir un SDK qui propose une aide graphique pour la construction de celles ci.


Chapitre 3 :

Application réalisée


Voici la liste des outils et logiciels utilisés durant ce travail :

Carte Arduino et Libelium Logiciels Arduino, Waspmote et X-CTU Capteurs de température, présence et gaz Modules Xbee Base de données MySQL Eclipse

Notre travail consiste en 3 étapes distinctes :

- La collecte des données depuis les capteurs - Le transfert de ces données vers une base de données - La récupération de ces données sur l’Android

Il peut être représenté via ce schéma : Carte Arduino et capteurs Machine Webservices Base de données distante Application Android

Figure 4 : Schéma d’utilisation via Webservices

Radio

Interne


3.1 Cartes embarquées

3.1.1 Récupération des données depuis les capteurs :

Nous avons dans un premier temps utilisé la carte Arduino pour calculer la température ambiante. Le capteur de température MCP9700A lit des données qu’on convertit en valeurs utilisables selon la mesure requise.

Pour cela, nous avons besoin du logiciel open-source Arduino, téléchargeable sur le site officiel. Après avoir installé le driver correspondant, il faudra également sélectionner la carte et le port avant utilisation depuis l’onglet ‘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 transféré vers la carte Arduino (via USB), on peut accéder aux résultats du programme via le terminal incorporé au logiciel. Ici un extrait du code utilisé pour relever les valeurs de température depuis le capteur de température :

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 relevée par le capteur de température grâce à la fonction analorgRead(). Cette valeur est ensuite convertie en voltage grâce à une formule. Puis, on convertit le voltage en température degré Celsius grâce à une formule linéaire entre ces deux entités que l’on retrouve dans ce schéma :

Figure 6 : Relation linéaire Température-Voltage

Il suffira ensuite de mettre ce code dans une boucle loop() pour recevoir ces données après un délai (au choix) d’1 seconde.

Pour la carte Libélium qui offre l’opportunité de tester des capteurs de gaz comme le CO2, le principe reste le même, si ce n’est que les capteurs de gaz demandent une durée minimale de 30 secondes pour chauffer avant de transmettre la valeur souhaitée.


Pour pouvoir récupérer les données des capteurs, nous avons besoin de l’API Waspmote IDE afin de pouvoir compiler et transférer les programmes vers la carte Libélium.

Figure 7 : Interface du logiciel Waspmote IDE

Il faut savoir également qu’on peut récupérer plusieurs données (de différents

capteurs) durant le même envoi de données. Pour cela, il suffit de concaténer ces données sous forme de chaine de caractères à envoyer après un délai fixe.

Ci-dessous un exemple de code pour relever les taux de CO2 :

Le résultat du programme renvoie la concentration du CO2 en PPM après chaque 30

secondes.

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); }


Pour ce qui est du capteur présence, il faut mettre en place une interruption qui va réveiller la carte et envoyer un signal lorsque le capteur est activé.

3.1.2. Réception des données

Une fois la valeur de température acquise, il faudra désormais l’envoyer vers notre machine de travail pour pouvoir la stocker dans une base de données MySQL. Pour cela, nous allons utiliser la connexion Radio qui relie 2 modules Xbee via le protocole 802.15.4. En effet, l’ordinateur reçoit les valeurs envoyées par la carte Arduino qui seront ensuite lues et traitées sur Eclipse grâce à la librairie RXTX, une librairie open-source externe qui permet au JDK de communiquer avec d’autres objets. Cette librairie nous offre la possibilité de lire sur le port sélectionné (ici USB), de la même manière qu’un port série. Dans un premier temps, il faut ouvrir la connexion sur une fréquence et ensuite créer les ouputStream et inputStream qui nous permettrons de lire et écrire sur le port série.

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);

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(); } }


Ensuite cette librairie nous offre la possibilité de ré-implémenter une méthode qui va être appelée lorsqu’un message est reçu sur le port série. Ce qui nous permet ainsi de pouvoir effectuer un traitement précis sur les données qui ont été transmise.

3.1.3. Transfert de ces données vers une base de données :

Le programme Java se chargera de créer une liaison et de convertir les données reçues

dans un format correspondant. Vient ensuite l’étape des Webservices : Le code Java appelle un script PHP auquel il

passera les valeurs relevées sous forme de paramètres. Le script PHP se charge alors d’insérer ces dernières dans une base de données.

Ci-dessous un extrait du code Java sur Eclipse qui permet d’envoyer les données reçues depuis la carte Libélium :

Ainsi qu’un extrait du script PHP en question :

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();

@Override public synchronized void serialEvent(SerialPortEvent oEvent) {

if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) { try { int chunk = input.read();//Lecture sur le port série if (chunk == '0') {//nouvelle carte libelium alumé System.out.println("demarrage d'une carte"); }

} catch (Exception e) { System.err.println(e.toString()); } } }


Le résultat peut être visualisé directement sur la base de données :

Figure 8 : Extrait de la base de données MySQL

3.1.4. Transfert de ces données avec une socket

C’est une méthode qui permet un échange de données en direct entre les deux

services, ici le programme java qui contrôle les cartes libélium et le smartphone Android. Ce qui permet d’avoir la réception de l’information au moment où elle a été émise.

<?php $req =mysql_query("INSERT INTO libelium(HEURE,CELSIUS,CARBONE,CONCENT,AIR) VALUES('".$_GET["data1"]."','".$_GET["data2"]."','".$_GET["data3"]."','".$_GET["data4"]."','".$_GET["data5"]."')"); ?>


Carte Libélium et capteurs Machine Application Android

Figure 9 : Schéma d’utilisation via sockets

Sur la machine host qui fait le lien entre la carte et le smartphone, il faut mettre en place une socket serveur d’écoute sur un port précis, qui va attendre l’arrivée d’un nouveau client afin de lui envoyer les informations sur l’état du capteur.

Internet Radio Socket

Socket

ServerSocket s = new ServerSocket(3434,0,InetAddress.getLocalHost()); Socket cli = s.accept();//attende d’un 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 d’un 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 données sans avoir à relier le matériel grâce a un câble.

Les cartes Libelium Waspmote intègrent en effet cette technologie, et permettent la programmation de ces cartes sans-fil via le protocole 802.15.4 accessible grâce aux XBee. Parmi les fonctionnalités 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 : Schéma d’utilisation de la programmation OTA

Le principe de l’OTA consiste à envoyer un nouveau programme sur une carte SD

insérée au niveau de la carte Libelium grâce à des commandes réalisées sur un terminal. Cette dernière se chargera ensuite de copier ce programme dans sa mémoire Flash depuis la carte SD.

b. Application :

Pour mettre au point la technologie Over The Air, il faut d’abord :


- Un Waspmote Gateway pour diffuser le nouveau programme. - Un réseau de cartes Waspmote équipées de cartes SD. - Un terminal pour envoyer les commandes.

D’abord, il faut s’assurer que la carte SD est compatible avec l’OTA. Une carte SD

contient en général des blocs défectueux qui ne peuvent être ignorés lors de l’utilisation de la programmation OTA, c’est pour cela que les seules cartes SD garanties à fonctionner sont celles distribuées par Libelium, ayant comme capacité 1,86 Go.

Ensuite, il faut vérifier que les cartes Waspmote aient une configuration identique. Pour cela, nous avons utilisé le logiciel X-CTU, qui permet de modifier la configuration d’une carte Waspmote.

Figure 11 : Interface du logiciel X-CTU

Pour utiliser l’OTA, il faut avoir : - La même version API (1 pour les cartes Waspmote, 2 pour le Waspmote

Gateway). - Le même canal. - Le même PAN ID.


Une fois cela fait, il faudra télécharger l’API open-source OTA disponible sur le site

officiel Libelium, et renseigner la configuration citée 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 prêts. otap -start_new_program : Pour charger le nouveau programme sur les cartes

Waspmote.

D’autres options sont disponibles pour la programmation OTA, notamment le choix de l’envoi du programme (UNICAST, MULTICAST, BROADCAST, …).

Figure 12 : Interface du terminal


3.2. Android

3.2.1. Installation et utilisation de l’environnement de travail

La conception de l’application Android s’est déroulée sur 3 étapes distinctes :

- Création de la structure de l’application en Java. - Ouvrir une connexion entre l’application et la base de données. - Ouvrir une connexion directe entre l’application et le pc

Nous avons commencé par installer un environnement Java, avec Eclipse (version

Indigo). Afin de pouvoir lire et modifier les données reçues depuis les cartes et leurs capteurs, il est impératif d’utiliser la libraire RXTX pour de pouvoir lancer le programme. Vient ensuite l’étape d’installation du SDK Android, à savoir l’environnement de travail consacré à la programmation pour Android. Celui-ci propose une édition d’interface en graphique et permet d’utiliser les librairies requises pour la conception d’une application.

Figure 13 : Interface d’Eclipse

L’un des avantages du SDK Android sur Eclipse est la disponibilité d’avoir un émulateur

permettant ainsi de vérifier le fonctionnement des applications ainsi que leur rendu avant de les tester sur du matériel.


Figure 14 : Interface de l’émulateur Android

Pour créer une application Android, il suffit de commencer un nouveau projet Android et

indiquer l’API minimum requise pour son utilisation, ce qui permet choisir la version minimum d’Android.

Durant le démarrage d’une application sur Android, il y a un cycle de procédure à

respecter. Ce qui permet au démarrage de choisir l’interface à mettre en place ainsi que les fonctionnalités des éléments de celle ci. Le cycle de vie d’une application permet aussi de pouvoir libérer l’espace durant une autre activité.


Figure 15 : Cycle de vie d’une application Android

3.2.2. Accès a la base de données depuis Android :

L’application Android, offre un menu à son ouverture afin de pouvoir choisir les données

à afficher. La connexion avec la base de données se fait sous forme d’une requête HTTP afin

d’appeler un script PHP, hébergé sur un serveur externe « WebService ». Ci-dessous un extrait du code Java pour l’appel du script:


Ci-dessous un extrait du script PHP utilise pour extraire les données. Ce dernier va convertir les données reçues via la requête SELECT en format JSON compatible avec Android:

Le résultat retourné par cette requête est alors en format JSON :

L’application convertira en un premier temps ces données en chaine de caractères avant

de récupérer les données JSON pour les afficher selon le format souhaité.

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(); }

[{"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":"802","1":"13:45:30","HEURE":"13:45:30","2":"21.29","CELSIUS":"21.29"}, … ]

<?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 résultat final est une liste des données enregistrées.

3.2.3. Récupération des données d’un socket

Pour ce qui est du client « Android », c’est la création d’un socket sur une adresse IP et un numéro de port qui va créer 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 présence if(car == '1'){ //envoi un message au handler handler.sendEmptyMessage(INFO_CAPTEUR); } b = new byte[512];

} }

Intent


Ainsi le client reste dans la boucle de lecture « while » afin de recevoir les données envoyées par le serveur. Pour ne pas bloquer l’ensemble du programme sur la lecture du socket, il faut placer cette partie dans un autre Thread.

Sur Android l’IHM est la propriété du thread principal, il est donc impossible de

modifier ou de lancer une autre interface via le thread qui gère le socket. C’est pourquoi il faut utiliser un Handler, qui va permettre l’échange de messages entre les Threads avec la fonction handler.sendEmptyMessage(INFO_CAPTEUR). Celui-ci en fonction de la valeur passée en paramètre va effectuer une action dans le Thread principal.

Procédure de connexion et communication avec le serveur :

Application IHM

Thread principal

Thread socket

Matériel

Signal

Socket

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;

} } };


Socket

Intent

Connexion Envoi données capteur

Socket Figure 16 : Schéma d’utilisation de l’application Android


Conclusion

Ce travail était une occasion de nous approfondir dans le monde de la programmation des systèmes embarqués, et une opportunité de tester les différents capteurs disponibles au laboratoire de façons différentes.

Notre travail s’est déroulé en 3 étapes distinctes : On a d’abord

commencé par nous familiariser avec le sujet, à savoir les différents capteurs, leurs modes de communication et l’environnement Android, avant de passer à la pratique et étudier chaque outil, d’abord la carte Arduino puis la carte Libelium, pour enfin concevoir une application Android capable de gérer toutes ces données, chacun apportant les connaissances qu’il a ainsi pu acquérir auprès de l’outil qu’il étudiait.

Nous espérons que ce rapport permet de répondre aux questions qu’on

pourrait se poser en se penchant sur ce sujet et que notre travail est à la hauteur de vos espérances.


Références é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 réalisé : http://pagesperso.univ-brest.fr/~e21105243/Tuto.html


Annexes


Annexe 1 : Matériel utilisé

Logo :

Nom : Arduino Produit : Arduino Mega 2560 Microcontrôleur : ATmega2560 Mémoire Programme Flash : 256 KB Mémoire SRAM : 8 KB Mémoire EEPROM : 4 KB Vitesse d'horloge : 16 MHz

Tableau 1 : Fiche technique de la carte Arduino

Logo :

Nom : Libelium Produit : Waspmote v1.1 Microcontrôleur : ATmega1281 Mémoire Programme Flash : 128 KB Mémoire SRAM : 8 KB Mémoire 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 Température: -10°C ~ +40°C Temps de réponse : 30 secondes Nom : MCP9700A

Capteur :

Fonction : Capteur de température Nombre de broches : 3 Précision : ±1°C Température Max : 125°C Température Min : -40°C Tension d’alimentation : 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 Température: -10°C ~ +50°C Temps de réponse : 1.5 minute Consommation : 50mA Nom : PIR


Capteur :

Fonction : Capteur de présence Hauteur : 24.3mm Longueur : 28.0mm Consommation : 100μA Détection : 6-7m

Documents

Interface Android pour la consultation de données envoyées par un