Projet d'approfondissement

1. Projet d’approfondissement
Application réseau de capteurs sans fil
Spécialité : Télécommunications (IoT)
Présenté par : Chaieb Ghassene
Encadrant : Mr. Ezzedine Tahar
Année universitaire : 2015/2016

2. Table des matières
Introduction Générale...........................................................................................................................3
I. Technologies utilisées ................................................................................................................4
1. Technologies matérielle ................................................................................................................4
2. Les technologies Logiciels .............................................................................................................4
a. MQTT:...........................................................................................................................................4
b. Node JS : .......................................................................................................................................6
c. Paho :............................................................................................................................................6
d. MQTT. JS :.....................................................................................................................................7
II. Architecture de l’application......................................................................................................8
III. Réalisation .......................................................................................................................................9
1. Application Waspmote:..............................................................................................................9
2. Publisher (Raspberry)..............................................................................................................10
3. Subscriber : Client JAVA ...........................................................................................................11
a. Base de données MySQL ......................................................................................................11
b. Capture d’écran de l’application ..........................................................................................12

3. Introduction Générale
Depuis leur création, les réseaux de communication sans fil ont connu un succès sans
cesse croissant au sein des communautés scientifiques et industrielles. Grâce à ses divers
avantages, cette technologie a pu s'instaurer comme acteur incontournable dans les architectures
réseaux actuelles. Le média hertzien offre en effet des propriétés uniques, qui peuvent être
résumées en trois points :
• la facilité du déploiement
• l'ubiquité de l'information
• le coût réduit d'installation.
Au cours de son évolution, le paradigme sans fil a vu naître diverses architectures
dérivées, telles que : les réseaux cellulaires, les réseaux locaux sans fils et autres. Durant cette
dernière décennie, une architecture nouvelle a vu le jour : les réseaux de capteurs sans fil. Ce
type de réseaux résulte d'une fusion de deux pôles de l'informatique moderne : les systèmes
embarqués et les communications sans fil. Un réseau de capteurs sans fil (RCSF), ou "Wireless
Sensor Network" (WSN), est composé d'un ensemble d'unités de traitements embarquées,
appelées "motes", communiquant via des liens sans fil.
Le but général d'un WSN est la collecte d'un ensemble de paramètres de l'environnement
entourant les motes, telles que la température ou la pression de l'atmosphère, afin de les
acheminer vers des points de traitement.
En effet, le besoin d'un suivie continu d'un environnement donné est assez courant dans diverses
activités de la société. Les processus industriels, les applications militaires de tracking, le
monitoring d'habitat, ainsi que l'agriculture de précision ne sont que quelques exemples d'une
panoplie vaste et variée d'applications possibles du suivi continu offert par les RCSF.

4. I. Technologies utilisées
1. Technologies matérielle
Waspmote : Waspmote est une plate-forme de capteurs sans fil open source inspiré par Arduino
destiné pour des applications de réseau de capteurs.
Caractéristiques :
 Puissance ultra faible (0.7uA)
 100+ capteurs disponibles
 17 Radio Technologies :
 longue portée : 3G / GPRS / LoRaWAN / LoRa / Sigfox / 868 /
900MHz
 Moyenne portée : ZigBee / 802.15.4 / WiFi
 Courte portée : RFID / NFC / Bluetooth 4.
 Les bibliothèques de chiffrement (AES, RSA)
2. Les technologies Logiciels
a. MQTT:
MQTT (Message Queuing Telemetry Transport) est un protocole de messagerie publish-
subscribe basé sur le protocole TCP/IP.l a été initialement développé par IBM.
 Client MQTT : (Publisher, Subscriber): Les clients souscrivent aux Topic
pour publier ou recevoir des messages.
Figure 1 Carte WaspMote

5.  Topic : S’appuie le modèle publish-subscribe pour les clients. En Fait, les
Topics permettent aux clients d'échanger des informations avec la sémantique
définies. Exemple sujet: les données des capteurs de température d'un bâtiment.
 Broker MQTT: C’est le serveur des topics, il reçoit les souscriptions des
clients sur des Topics, ou reçoit des messages des clients et transmettre ceux-ci
basé sur les abonnements des clients) aux clients intéressés.
Figure 2 Principe de fonctionnement du protocole MQTT
Mosquito
Mosquito est un Message broker open source
(sous licence BSD) qui met en œuvre les
versions de protocole MQTT 3.1 et 3.1.1.
Mosquitto fournit une implémentation serveur
allégée des protocoles MQTT et MQTT-SN,
écrit en C. La raison pour écrire en C est de
permettre au serveur de fonctionner sur des
machines qui ne disposent pas encore des
capacités pour la gestion d'une JVM. Les
capteurs et les actionneurs, qui sont souvent les sources et les destinations de messages MQTT
et MQTT-SN, peuvent être très petites et manquent de puissance. Mosquitto peut fonctionner
également pour les machines embarquées à laquelle ils sont connectés ainsi que d'accepter les
connexions des applications client MQTT, mosquitto a un pont qui permet de se connecter à
d'autres serveurs MQTT, y compris d'autres instances de mosquitto. Ceci permet les réseaux de
serveurs MQTT à construire, en passant messages MQTT de toute localisation dans le réseau à
un autre, en fonction de la configuration des ponts.
ActiveMQ
Mosquitto
RabbitMQ
JoramMQ

6. b. Node JS :
Node.js est une plateforme permettant
la construction des applications de réseau et qui
implémente sous licence MIT. Elle a été inventée en
2009 par Ryan Dahl, et une équipe développeurs
travaillant à Joyent. Les applications Node.js sont
écrites en JavaScript et sont exécutées dans
l’environnement d’exécution de Node. Cette
plateforme représente un moyen d’exécution
de JavaScript en dehors du navigateur web. En général, les développeurs utilisent le langage de
programmation JavaScript pour la programmation des interfaces de sites Web faisant de
JavaScript un langage utilisé juste au niveau de client, alors que Node.js permet d’appliquer ce
langage de programmation dans de nombreux contextes, en particulier sur des serveurs web en
offrant un environnement côté serveur qui fonctionne avec JavaScript pour générer des pages
web. Depuis la sortie de Google Chrome à la fin de 2008, les performances JavaScript est
améliorée à un rythme rapide en raison de la forte concurrence entre les fournisseurs de
navigateurs (Mozilla, Microsoft, Apple, Opera et Google). Les performances de ces ma- chines
virtuelles modernes de JavaScript ont permis de changer les types d’applications qu’on peut
construire sur le web. Node utilise " V8 JavaScript engine " développé par Google et qui est
notamment utilisé dans les navigateurs Google chrome et Chromuim, pour la programmation
côté serveur. V8 permet à Node d’avoir de bonnes performances. En effet, Ce moteur utilise
des techniques très récentes au niveau de la technologie de compilateur permet- tant souvent à
un code écrit en un langage haut niveau tel que JavaScript de s’exécuter d’une manière similaire
à un code écrit dans un langage de bas niveau, tels que C. Node permet à V8 de mieux travailler
dans des contextes autres que le navigateur web. La plupart du temps en fournissant des API
supplémentaires qui sont optimisés pour des cas d’utilisation spécifiques. Alors que la plupart
des cadres de côté serveur existants utilisent une architecture synchrone, Node.js utiliser un
architecture asynchrone grâce au fait que JavaScript est un langage orienté évènement Cela
signifie que le serveur réagit aux événements et en voie des événements (messages), Node
utilise ce fait pour son avantage afin de produire des serveurs hautement "scalables".
c. Paho :
Paho offre une implémentation open-source de protocoles
de messagerie MQTT destiné à des applications
Machine-to-Machine (M2M) et internet des objets (IoT).
Le projet Eclipse Paho a devenu rapidement une source de
quelques grands clients MQTT. Actuellement, il contient
des implémentations en C, Java, Javascript, Python
(contribution du projet de mosquitto), Lua C ++, C.

7. d. MQTT. JS :
MQTT.js est une bibliothèque client pour le protocole
MQTT, écrit en JavaScript pour node.js. MQTT.js fournit
une bibliothèque riche en fonctionnalités Javascript pour le
protocole MQTT. Il peut fonctionner dans le navigateur et
dans node.js (> = 0.8), y compris Intel Edison et Raspberry
PI. Il peut prendre en charge les clients avec une
connectivité inégale. Il a une mémoire sur le disque en option pour la messagerie hors ligne
locale.

8. II. Architecture de l’application
Figure 3 Architecture de l'application
Scénario :
1. Chaque WaspMote est lié à un capteur (temperature, pression). Il envoie
périodiquement la valeur mesurée à sa passerelle (Raspberry).
2. Via le protocole MQTT, la passerelle publie les valeurs mesurées dans un topic sur un
broker Mosquito située dans le cloud (CloudMqtt)
3. Le client s’inscrire aux topics pour récupérer les valeurs.

9. III. Réalisation
1. Application Waspmote:
Dans la fonction setup on commence par définir la communication avec le port serial.
void setup()
{ //Intialisation de USB
USB.ON();
delay(100);
}
On définit aussi une fonction qui va nous lire la valeur du capteur utilisé.
float getTemperatureValue() {
//Initialisation du capteur temperature
SensorAgrv20.setSensorMode(SENS_ON, SENS_AGR_SENSIRION);
//Récuperation de la valeur de la temperature
temperatureValue = SensorAgrv20.readValue(SENS_AGR_SENSIRION, SENSIRION_TEMP);
delay(3000);
//Mesure via USB
USB.print(temperatureValue);
USB.println(F("ºC"));
USB.println();
//Fermeture du capteur
SensorAgrv20.setSensorMode(SENS_OFF, SENS_AGR_SENSIRION);
return temperatureValue;
}
Dans la fonction loop(), il suffit d’appeler la fonction getTemperatureValue().
void loop()
{
getTemperatureValue() ;
delay(10000000);
}

10. 2. Publisher (Raspberry)
Dans cette application, on aura besoin de deux modules node.js, l’un pour lire les valeurs qui
arrivent sur le port série, et l’autre pour utiliser le protocole MQTT.
On va utiliser donc les deux modules mqtt.js et serialport.
On installe ces deux modules à l’aide de la commande suivante :
npm install mqtt serialport
Dans le fichier app.js, on configure le protocole mqtt de la manière suivante:
var mqtt = require('mqtt'), url = require('url');
var mqtt_url = url.parse(process.env.CLOUDMQTT_URL || 'mqtt://adresse_de_brocker');
var auth = ['utilisateur','mot_de_passe'];
console.log(auth[0]);
console.log(auth[1]);
// Creation du client mqtt
var client = mqtt.createClient(mqtt_url.port, mqtt_url.hostname, {
username: auth[0],
password: auth[1]
});
Pour la communication avec le port série:
var serialport = require("serialport");
var SerialPort = serialport.SerialPort;
var serialPort = new SerialPort("/dev/ttyUSB0", {
baudrate: 115200,
parser: serialport.parsers.readline("n")
});
Afin d’envoyer les valeurs récupérées de la carte waspmote, on utilise le code suivant:
//Récuperation des valeurs du capteur
serialPort.on('data', function(data) {
console.log(data);
client.on('connect', function() {
// publier les valeurs dans le topic « temperature »
client.publish('temperature', data, function() {
console.log("Message is published");
});
});
});

11. Figure 1 Publication de la tempérture dans le topic "Temperature"
Dans ce lien, vous trouverez publisher.txt
On peut valider le bon fonctionnement du publisher à l’aide d‘un subscriber node.JS developper avec
le module MQTT.JS dont le code est subscriber_MQTT JS.txt
Figure 2 Réception de la température par le subscriber
3. Subscriber : Client JAVA
Dans ce lien vous trouverez le code du client JAVA WaspMote
a. Base de données MySQL
Table « temperature »

12. b. Capture d’écran de l’application
Figure 3 Interface d'authentification
Figure 4 Interface choix de capteur
Figure 5 Interface « température en temps réel »