LoRa

Présentation

Objectifs

Le principal objectif de ce TP était de mettre en place un proof-of-concept de communication entre des modules utilisant le protocole LoRa ou LoRaWan. Actuellement nous nous basons sur l'utilisation d'un Raspberry Pi qui servira de gateway pour nos devices LoRa et gérer les données de notre application via les APIs dédiées.

Tutoriel

Prérequis

Il faut pour que le POC fonctionne que vous disposiez d'un compte mbed sur le site https://www.mbed.com/ (cela sera plus simple pour le développement et la compilation des binaires d'utiliser l'environnement de développement en ligne Mbed dédié).

Matériel nécessaire

- un ordinateur

- un microcontrolleur Nucleo F401RE muni d'un module mbed SemTech LoRa SX1276

- un microcontrolleur Nucleo L073RZ muni d'un module mbed SemTech LoRa SX1272

- un Raspberry PI 3 (qui servira de serveur en backend)

- une carte SD de 8GO minimum

Logiciel nécessaire

Dans le cas où vous êtes sur Windows :

- Les drivers nécessaires pour votre device (il est généralement utile de consulter le site constructeur afin de trouver des informations spécifiques à l'équipement utilisé).

- Pour les microcontrolleurs Nucleo, les drivers sont disponibles à cette adresse : https://developer.mbed.org/teams/ST/wiki/ST-Link-Driver

Les différentes technologies qui seront utilisées sur le Raspberry Pi sont les suivantes :

   Docker
   Node.js and NPM
   Node-RED and node contributions
   Mosquitto
   InfluxDB
   Grafana
   Spark

Installation de Raspbian sur le Raspberry Pi

Pour la configuration du Raspberry Pi, on se base sur une image Raspbian disponible à l'adresse suivante: https://downloads.raspberrypi.org/raspbian_latest

Une fois téléchargé, dezipper l'archive dans le dossier de votre choix: unzip <YYYY-MM-DD-raspbian-jessie.zip> -d <dossier_destination>

Pour l'installation de l'image sur la carte SD, vous pouvez suivre le tutoriel Raspbian disponible à l'adresse suivante (pour Linux, Windows et Mac) :https://www.raspberrypi.org/documentation/installation/installing-images/README.md

Une fois installé, débrancher et rebrancher votre carte SD pour voir apparaitre les différentes partitions créées sur la carte SD.

Configuration du SSH

SSH est préinstallé dans la distribution Raspbian, mais n'est pas activé par défaut. Pour l'activer, il suffit de créer un dossier ssh dans le dossier /boot/ du Raspberry Pi.

Vous pouvez maintenant insérer votre carte dans le Raspberry Pi, et vous connecter en SSH dessus via son adresse IP (login: pi, mot de passe: raspberry).

Installation des composants sur le Raspberry Pi

Installation Docker

 # Installer Docker
 curl -sSL get.docker.com | sh

 # Pouvoir lancer docker sans sudo
 sudo usermod -aG docker pi

Il est nécessaire de relancer une nouvelle session ssh si on veut pouvoir utiliser Docker sans sudo.

Installation NPM

 sudo apt-get update
 # Si vous utilisez une distribution Raspbian Wheezy, vous devez installer nodejs
 sudo apt-get install nodejs
 # Pour Raspbian Jessie ou Wheezy
 sudo apt-get install npm
 npm -v

Installation Node-RED

 sudo apt-get update 
 sudo apt-get install nodered

 # Pour automatiser le démarrage de Node-RED au boot
 sudo systemctl enable nodered.service

 # Pour arrêter Node-RED
 node-red-stop

 # Pour démarrer Node-RED
 node-red-start

Installation des modules Node-RED via NPM

 # Installer les modules supplémentaires dans Node-RED
 cd ~/.node-red
 sudo npm install -g node-red-node-serialport
 sudo npm install -g node-red-contrib-influxdb
 sudo npm install -g node-red-contrib-timeseries

 # Vérifier que les modules sont présents dans Node-RED
 node-red-admin list | grep serial
 node-red-admin list | grep influxdb

Installation de Mosquitto

 # Installer mosquitto
 sudo apt-get install mosquitto
 sudo apt-get install mosquitto-clients
 
 # Define localhost as a Mosquitto broker
 BROKER=localhost

 # Inscription à un topic 
 mosquitto_sub -d -h $BROKER -t 'sensors/#' &

Installation de Grafana (v2.6)

 wget http://ftp.us.debian.org/debian/pool/main/g/grafana/grafana_2.6.0+dfsg-3_armhf.deb
 sudo dpkg -i grafana_2.6.0+dfsg-3_armhf.deb
 sudo systemctl enable grafana

Installation de InfluxDB (v.0.10.0)

Via Docker

 # On clone le repository github rpi-influxdb
 git clone https://github.com/sbiermann/rpi-influxdb
 # Vous pouvez choisir le numéro de la version dans le Dockerfile du repository.
 # Après la ligne ENV INFLUXDB_VERSION du Dockerfile, assurez-vous d'avoir la valeur 0.9.6
 grep -Rni "0.9.6" Dockerfile
 # Si non, modifiez le Dockerfile en conséquence
 # Si oui, On crée ensuite une image à partir du Dockerfile
 docker build -t $USER/rpi-influxdb
 # On démarre un conteneur InfluxDB
 docker run -d -p 8083:8083 -p 8086:8086 $USER/rpi-influxdb:latest

Configuration de InfluxDB

On va créer une nouvelle base de données dans InfluxDB. Pour cela, connecter vous en SSH sur le Raspberry, et démarrer le binaire influx. Un nouveau prompt devrait s'afficher. Vous pouvez créer la base avec les requêtes suivantes :

 CREATE DATABASE iotdb
 # Vérifier la création de la base
 SHOW DATABASE
 CREATE retention policy one_day_iot_demo ON iotdb duration 1d replication 1 DEFAULT
 # Vérifier la création de la politique de rotation des données
 SHOW retention policies ON iotdb

 SHOW measurements
 SELECT * from rssi

Collecte des données entre les deux modules LoRa

On va maintenant configurer les deux modules LoRa (SX1272 et SX1276) pour qu'il puisse communiquer. L'un sera en mode transmission (TX), tandis que l'autre sera en mode réception (RX).

Pour la partie réception, on choisira de mettre le module SX1276 en mode réception à l'aide du programme suivant : https://developer.mbed.org/users/donsez/code/SX1276Receiver/.

Dans ce premier repository, verifiez que la ligne #define MODE à bien la valeur RX_MODE dans le fichier main.c

Choisissez la plateforme sur laquelle vous voulez compiler (F401RE ou L073RZ), et compilez le code du repository via le bouton Compile, qui devrait vous donner un fichier binaire. Brancher le microcontrolleur correspondant sur votre ordinateur. Une partition est montée, un simple Drag'n Drop du fichier sur celle-ci permettra de flasher le code sur le microcontrolleur.

Pour la partie transmission, on va donc mettre le module SX1272 en mode transmission à l'aide du programme suivant : https://developer.mbed.org/users/jerem28/code/SX1272Receiver/

Dans le deuxième repository, verifiez que la ligne #define MODE à bien la valeur TX_MODE dans le fichier main.c

Compiler le code sur l'autre plateforme, et flashez le binaire sur l'autre microcontrolleur.

Enfin, il faudra relier le module récepteur sur le Raspberry PI. Le module émetteur peut être branché sur n'importe quel port USB (Raspberry PI ou votre ordinateur).

Utilisation de Node-RED

On va créer 2 flows différents pour la récupération des données.

- Le premier nous servira à récuperer depuis le port série du microcontrolleur en mode réception les différentes trames successives envoyées par le module de l'autre microcontrolleur en mode émission. On redirigera ces données vers le serveur MQTT Mosquitto mis en place précédemment.

- Le second récupère du serveur Mosquitto les données des frames LoRa du module émetteur, et les parse pour récupérer les valeurs RSSI (Received Signal Strength Indication) qui vont être transformées en "time series". Enfin ces nouvelles données seront insérées dans notre base de données InfluxDB, afin d'être récupérées ultérieurement pour leur visualisation via Grafana.

Premier flow

- Ajouter un node serialport à votre flow, avec les paramètres suivants:

 Device: /dev/ttyACM0
 Baud rate: 115200
 Data bits: 8 bits
 Parity: N
 Stop bits: 1

- Ajouter un node function "Extract RX Data" avec le code suivant:

   var prefix="RX;";
   var m=msg.payload;
   var i=m.indexOf(prefix);
   if(i===0) {
       msg.payload=m.substr(prefix.length);
       setTimeout(function() { node.status({}); }, 500)
       node.status({fill:"green",shape:"dot",text:"updated"});
       return [msg, msg];
   } else {
       return null;
   }

- Ajouter un node debug afin de voir la sortie de la fonction avec comme output msg.payload

- Ajouter un noeud MQTT out avec les paramètres suivants:

 Broker: localhost:1883 (c'est le broker MQTT Mosquitto installé et défini précédemment)
 Topic /sensor/rssi

Relier les quatres nodes de la manière suivante :

Second flow

On va utiliser MQTT pour collecter les différentes données recues des frames LoRa

D'abord, vérifier que les données des frames sont bien publiées sur le topic du Broker Mosquitto :

 BROKER=localhost
 mosquitto_sub -d -h $BROKER -t 'sensor/#' &

Une fois vérifié, on peut passer à la programmation visuelle sous Node-RED :

- Ajouter un noeud MQTT in pour vous abonner au serveur MQTT. Les paramètres sont les suivants:

 Broker: localhost:1883
 Topic: /sensor/rssi

- Ajouter un noeud fonction "Collect RSSI" pour formater le payload du message et uniquement récupéré le RSSI. La fonction a créer est la suivante :

 // Collect rssi value
 msg.payload = msg.payload.split(";")[2];
 return msg;

- Ajouter un noeud influxdb out "IOT Database" avec les paramètres suivants :

 Server: IOT Database
 Host: 127.0.0.1
 Port: 8086

- Ajouter un node debug afin de voir la sortie de la fonction avec comme output msg.payload

Relier les quatres nodes de la manière suivante :

Configuration de Grafana

Il ne nous reste plus qu'à afficher nos données via Grafana. Pour cela, aller à l'adresse localhost:3000. Connectez vous avec les credentials admin:admin

On va créer un nouveau Dashboard :

Pour la configuration des Data Sources, on va récuperer les données de notre base iot dans InfluxDB :

 Name: LoRa measures
 Cocher la case Default
 Type: InfluxDB 0.9.x
 URL: http://<adresse_ip_raspberry_pi>:8086
 Access: Direct
 Database: iotdb
 User: root
 Password: root

Tester que la base de données est bien accessible à l'aide du bouton Test connection et sauvegarder votre nouvelle configuration.

Retourner sur le dashboard créé précédemment, aller dans la partie Query

La suite des données devraient s'afficher sur le nouveau graphique déployé.

Sauvegarder votre nouveau dashboard

Conclusion

On peut étendre ce projet assez aisément avec plusieurs modules LoRa, et récupérer d'autres valeurs comme celle de capteur de température ou encore d'humidité par exemple.