Réseaux de capteurs XBee

Etudiants M2PGI PM2M: DIAGNE EL-HADJI Malick, ZAKARI TOURE Ismaël

Documents : Rapport - Transparents - Flyer - Video

Contexte

Dans le cadre de notre formation Master 2 Pro. Génie Informatique, nous sommes amenés à concevoir un système informatique d'interaction "Machine -to-Machine". Ce système mettra en oeuvre l'exploitation de capteurs, embarqués sur un système distant alimenté par une batterie. Ce système devra par conséquent être minimal et transmettra les données capturées à un autre système plus important via les modules radios Xbee fournis pour réaliser ce projet.

Objectif du projet

Nous avons choisi de mettre en oeuvre un système de surveillance (des plantes) d'un jardin. Ce système mettra en oeuvre plusieurs capteurs listés ci-dessous. Il permettra d'avoir un aperçu des niveaux de luminosité, d'humidités (du sol et de l'air) et pluviométrie de notre jardin. L'objectif est de réduire au minimum le développement/écriture de code, au profit de la coopération de systèmes existants à travers leur configuration. A cet effet, nous utiliserons les technologies sous-mentionnées, notamment la platforme InfluxData pour la collecte, le stockage et le rendu de données séries capturées.

Matériel utilisé

2 modules XBee: 1x module S1 et 1x module Pro
1x "Breakout board" Xbee USB Explorer pour programmer les Xbee
1x Arduino FIO
1x "Breakout board" FTDI pour programmer la FIO
1x photo-résistance, 2x capteurs d'humidité (air et sol) et 1x capteur de pluie

Technologies utilisées

Mosquitto, un broker MQTT
Node-RED, avec le noeud node-red-node-serialport (à installer) pour lire les données reçues par le module Xbee "local"
AWS EC2
Telegraf
InfluxDB
Chronograf

Plan de développement

Architecture - Conception générale

Ci-dessous, un schéma de l'architecture de notre projet.

Architecture – Conception générale

Système embarqué

Configuration des modules Xbee

Afin que les modules puissent communiquer entre eux, nous devons les configurer. Pour ce faire, nous disposons d'une "breakout board" USB Explorer Xbee.
Les 2 modules utiliseront les paramètres suivants:

baud rate : 57600
flow control: none
data bit: 8
parity: none
stop bits: 1

Voici les paramètres que nous avons configuré pour chacun de nos modules:

	Xbee Emetteur	Xbee Recepteur
Adresse du réseau	1111	1111
Adresse du module dans le réseau	1	0
Adresse du destinataire dans le réseau	0	1
Autoriser l'émission des I/O	1	0
Autoriser la réception des I/O	0	1

Nous pouvons configurer les modules soit en utilisant un terminal série comme minicom ou screen, soit avec X-CTU.
En bas de page, quelques références<ref>exploring-xbees-and-xctu</ref><ref>Xbee communication</ref><ref>Getting started with Xbee</ref> qui sont d'une grande aide à la configuration de modules.

Montage

Ci-contre, voici le schéma de montage de notre ArduinoFIO:

Schéma de montage - Arduino FIO

Branchements:

-Pin A0: Capteur de luminosité

-Pin A1: Capteur d'hygrométrie

-Pin A2: Capteur d'humidité du sol

-Pin A3: Détecteur de pluie

Programmation du ArduinoFIO

Nous allons maintenant programmer notre ArduinoFIO afin de lire les valeurs mesurées sur les pins A0, A1, A2 et A3, les mettre en forme et les envoyer via les modules Xbee à notre machine "locale". Le code arduino compilé dans notre ArduinoFIO est le suivant:

 1#include <SoftwareSerial.h>
 2SoftwareSerial xbee(2, 3);
 3int count;
 4int lightPin = A0;
 5int rainPin = A1;
 6int grdHumPin = A2;
 7int airHumPin = A3; 
 8float lightValue = 0;
 9float rainValue = 0; 
10float grdHumValue = 0; 
11float airHumValue = 0; 
12float maxR = 0; 
13float maxG = 0; 
14float maxA = 0;
15float minR = 1024; 
16float minG = 1024; 
17float minA = 1024; 
18 
19void setup()
20{
21    
22    xbee.begin(57600);                 
23    Serial.begin(57600);                     
24    count = 0;
25}
26 
27/***************************************
28*  MAIN LOOP
29***************************************/
30 
31void loop()
32{
33
34  // Lecture des valeurs des capteurs
35  lightValue = analogRead(lightPin);
36  rainValue = analogRead(rainPin);
37  grdHumValue = analogRead(grdHumPin);
38  airHumValue = analogRead(airHumPin);
39
40  // Mise à jour des max et min
41  if(rainValue < minR) minR=rainValue;
42  if(grdHumValue < minG) minG=grdHumValue;
43  if(airHumValue < minA) minA=airHumValue;
44  
45  if(rainValue > maxR) maxR=rainValue;
46  if(grdHumValue > maxG) maxG=grdHumValue;
47  if(airHumValue > maxA) maxA=airHumValue;
48
49  // Calcul des pourcentages des mesures
50  float a = 0;
51  // Pourcentage de luminosité assez simple:
52  lightValue = lightValue/10.24;
53  //Pourcentage de pluviométrie
54  a = 100/(minR-maxR);
55  rainValue = a*rainValue-maxR*a;
56  //Pourcentage de l'humidité du sol
57  a = 100/(minG-maxG);
58  grdHumValue = a*grdHumValue-maxG*a;
59  //Pourcentage de l'humidité de l'air
60  a = 100/(minA-maxA);
61  airHumValue = a*airHumValue-maxA*a;
62
63  // Création de la donnée mesurée ("JSONobject string")
64  String Light_Str = "\"light\": ";
65  String Rain_Str = "\"rain\": ";
66  String GrdHum_Str = "\"grdhum\": ";
67  String AirHum_Str = "\"airhum\": ";
68  
69  Light_Str += (int)lightValue;
70  Rain_Str += (int)rainValue;
71  GrdHum_Str += (int)grdHumValue;
72  AirHum_Str += (int)airHumValue;
73
74  String phrase = "{"+Light_Str+", "+Rain_Str+", "+GrdHum_Str+", "+AirHum_Str+"}";
75 
76  // Affichage et Envoi de la donnée via Xbee
77  Serial.println(phrase);
78  xbee.println(phrase);
79  
80  delay(1000);
81}

Serveur Node-RED ("local")

Installation de Node-RED

Nous utiliserons npm pour installer Node-Red sur notre machine locale. Dans un terminal, entrer:

 sudo npm install node-red

Nous aurons besoin de créer un noeud "serialport" pour recevoir les données du module Xbee distant. Nous aurons besoin du module node-red-serialport

 cd ~/.node-red
 sudo npm install node-red

Création des noeuds Node-RED

Noeuds Node-RED

Lancer le serveur node-red. Dans un terminal, entrer:

 node-red

Il est maintenant accessible sur le port 1880 de notre machine locale ("localhost").
Ci-contre, une capture d'écran de nos noeuds Node-RED et les configurations qui leurs sont associées.

Serveur AWS ("distant")

Pour la suite nous avons créé un compte AWS ainsi qu'une instance EC2-Linux.
Après avoir lancé notre instance EC2, nous pouvons maintenant nous y connecter et y installer et configurer les services TICK ("Telegraf-InfluDB-Chronograf-Kapacitor").
Mais avant cela, commençons par installer le broker MQTT Mosquitto.

Installation de Mosquitto

Dans le terminal connecté à l'instance EC2, entrer:

 // Installation de Mosquitto
 sudo apt-get install mosquitto

 // Lancer mosquitto
 mosquitto

Mosquitto est ainsi actif sur notre instance EC2 (port 1883).

Installation de InfluxDB, Telegraf et Chronograf

Pour installer ces services, entrer dans le terminal (celui connecté à l'instance EC2):

 // Téléchargement et installation de Telegraf
 wget http://get.influxdb.org/telegraf/telegraf_0.12.0-1_amd64.deb
 sudo dpkg -i telegraf_0.12.0-1_amd64.deb

 // Téléchargement et installation de InfluDB
 wget https://s3.amazonaws.com/influxdb/influxdb_0.12.1-1_amd64.deb
 sudo dpkg -i influxdb_0.12.1-1_amd64.deb

 // Téléchargement et installation de Chronograf
 wget https://s3.amazonaws.com/get.influxdb.org/chronograf/chronograf_0.12.0_amd64.deb
 sudo dpkg -i chronograf_0.12.0_amd64.deb

Une fois ces services installés, nous allons maintenant les configurer.

Configuration de Telegraf

Nous allons commencer par créer un fichier de configuration pour notre service.

telegraf -sample-config -input-filter mqtt_consumer -output-filter influxdb > telegraf.conf

Avec cette commande, nous avons créé un fichier "telegraf.conf" à partir de la configuration par défaut de telegraf mais uniquement avec les sections qui nous intéressent :

en "input", le service "mqtt_consumer" pour intercepter les entrées émises via le broker MQTT Mosquitto de notre instance EC2
en "output", le service "influxdb" pour mettre en forme ces entrées et les stocker dans InfluxDB. Il faut noter que Telegraf y créera par défaut une table "telegraf" que nous exploiterons.

La section "INPUT PLUGINS" sera modifiée de la sorte:

 1###############################################################################
 2#                            INPUT PLUGINS                                    #
 3###############################################################################
 4
 5
 6###############################################################################
 7#                            SERVICE INPUT PLUGINS                            #
 8###############################################################################
 9
10# Read metrics from MQTT topic(s)
11[[inputs.mqtt_consumer]]
12  servers = ["EC2-Public-Address:1883"]
13  ## MQTT QoS, must be 0, 1, or 2
14  qos = 0
15
16  ## Topics to subscribe to
17  topics = [ "topic/m2pgi" ]
18
19  # if true, messages that can't be delivered while the subscriber is offline
20  # will be delivered when it comes back (such as on service restart).
21  # NOTE: if true, client_id MUST be set
22  persistent_session = false
23  # If empty, a random client ID will be generated.
24  client_id = ""
25
26  ## username and password to connect MQTT server.
27   username = "m2pgi"
28   password = "m2pgi"
29
30  ## Optional SSL Config
31  # ssl_ca = "/etc/telegraf/ca.pem"
32  # ssl_cert = "/etc/telegraf/cert.pem"
33  # ssl_key = "/etc/telegraf/key.pem"
34  ## Use SSL but skip chain & host verification
35  # insecure_skip_verify = false
36
37  ## Data format to consume.
38  ## Each data format has it's own unique set of configuration options, read
39  ## more about them here:
40  ## https://github.com/influxdata/telegraf/blob/master/docs/DATA_FORMATS_INPUT.md
41  data_format = "json"

Nous n'avons pas besoin de modifier la section "OUTPUT PLUGINS" car telegraf est configuré par défaut pour stocker les entrées séries dans InfluxDB (notamment dans la table "telegraf").

Note : Il ne serait pas inutile de se documenter un peu plus sur la configuration détaillée de telegraf.

Configuration de InfluxDB

Nous n'avons pas besoin de configuration particulière à effectuer pour InfluxDB, la configuration par défaut suffit amplement.

Chronograf

La configuration et l'utilisation de Chronograf n'est pas compliquée. Elles sont d'autant plus simple que nous avons gardé les configuration par défaut de Telegraf et InfluxDB.
Le lien suivant détaille parfaitement la procédure à suivre pour configurer Chronograf et créer nos visualisations et "Dashboard".
Petit rappel : nous avons gardé la configuration initiale de Telegraf. Nous exploiterons la database "telegraf" de InfluxDB, créée par défaut par Telegraf.
Note : Pour accéder à chronograf depuis l'extérieur de notre instance EC2, penser à modifier son fichier de configuration à cet effet (par défaut "/opt/chronograf/config.toml").

Lancement de nos services

Il ne nous reste plus qu'à lancer nos services Telegraf, InfluxDB et Chronograf:

 // Lancer InfluDB
 sudo service influxdb start

 // Lancer Chronograf
 sudo service chronograf start

 // Lancer Telegraf
 sudo service influxdb start

 // Lancer la capture des entrées Xbee par Telegraf (en utilisant notre fichier de configuration édité précédemment)
 telegraf -config myTelegraf.conf

Une fois les services lancés, la capture des données commence. Il ne nous reste plus qu'à visualiser ces données avec Chronograf.
Chronograf est accessible sur le port :10000 de notre instance EC2.

Expérimentations et Résultats

Voici quelques captures d'écran de notre dashboard:

Caption 1
Caption 2

Photos et Vidéo

Fichier vidéo ".zip" à télécharger File:Video xbee.zip

Lien vidéo youtube ICI.

Références

PM2M-2016-XBee/Suivi

Contents