Déploiement d'un réseau LoRaWAN
Sommaire
Présentation générale
- Nom du projet : Déploiement d'un réseau LoRaWAN
- Stagiaire : Ibrahim BEN DHIAB
Sujet de stage
Dans le cadre des travaux de recherches menés sur les objets connectés, l'étudiant devra déployer au sein de l'IRCICA un réseau expérimental LoRaWan. Pour cela, il devra installer et configurer une passerelle LoRaWAN pour la réception des données. Puis, il déploiera une dizaine de noeuds. Chaque noeud est composé d'un microcontrôleur STM32F4, d'une radio LoRa I-NUCLEO-LRWAN1 et de capteurs (température, ouverture de porte, ...). L'étudiant devra réaliser la programmation de chaque noeud et mettre en place une solution pour faciliter le redéploiement du code. Les noeuds seront ensuite installés dans différents bureaux.
LoRaWAN
LoRaWAN est un protocole de télécommunication permettant la communication à bas débit, par radio, d'objets à faible consommation électrique communiquant selon la technologie LoRa et connectés à l'Internet via des passerelles, participant ainsi à l'Internet des objets. Ce protocole est utilisé dans le cadre des villes intelligentes, le monitoring industriel ou encore l'agriculture. La technologie de modulation liée à LoRaWAN est LoRa, née à la suite de l'acquisition de la startup grenobloise Cycléo par Semtech en 2012. Semtech promeut sa plateforme LoRa grâce à la LoRa Alliance, dont elle fait partie. Le protocole LoRaWAN sur la couche physique LoRa permet de connecter des capteurs ou des objets nécessitant une longue autonomie de batterie (comptée en années), dans un volume (taille d'une boite d'allumettes ou d'un paquet de cigarettes) et un coût réduits.
LoRaWAN est l'acronyme de Long Range Wide-area network que l'on peut traduire par « réseau étendu à longue portée ».
Matériel fourni
- 1 Raspberry Pi 3 Model B + carte SD minimum 8go : utilisé pour héberger le serveur LoRaWAN et la passerelle
- 1 Concentrateur IC880A-LoRaWAN : utilisé comme passerelle
- 3 ST-NUCLEO-F401RE : composé d'un microcontrôleur STM32F4 et d'une connectivité type Arduino Uno Revision 3
- 3 Shield USI I-NUCLEO-LRWAN1 WM-SG-42 : shield radio LoRa
- Capteurs... (DHT11 pour la température et l'humidité, PIR pour détection de mouvement infrarouge)
- Lecteur de carte SD
- Câble USB vers série
Configuration du Rasperry Pi
Installation de l'OS et configuration initiale
Tout d'abord, télécharger Raspbian Stretch Lite, Lite car l'interface graphique n'est pas utile pour notre utilisation. Ensuite, il s'agit simplement de suivre le guide d'installation de l'image sur la carte SD qui sera ensuite insérée dans le Pi.
Avant d'insérér la carte, pensé à ajouter la ligne enable_uart=1 à la fin du fichier config.txt situé dans la partition BOOT de la carte pour activer la liaison série du Raspberry. Une fois insérer, connecter le câble USB vers série sur le PC et les fils TX et RX sur les pins RX et TX du Pi respectivement. Les pins 8 et 10 de la liaison série du Pi sont visibles ci-dessous :
Le Pi peut maintenant être alimenté, et on peut y accéder via un terminal à l'aide de la commande minicom -8 -b 9600 -o -D /dev/ttyUSB0. Les logins par défaut sont pi : raspberry .
Maintenant, il est nécessaire de connecter l'appareil à Internet, relier le ainsi par Ethernet, et il devrait se configurer automatiquement par DHCP. Par la suite, on souhaite se connecter par SSH au Pi, il est ainsi nécessaire de mettre en place une IP statique, pour cela, il faut au préalable récupérer des informations.
Lancer ip -4 addr show | grep global qui retournera ce genre de résultat inet 192.168.42.12/24 brd 192.168.42.255 scope global eth0. On connaît maintenant l'adresse IP du Pi, mais l'IP statique qu'on lui attribuera sera 192.168.42.250 pour s'assurer qu'aucun autre appareil utilise la même IP.
Ensuite, trouver l'adresse du routeur (ou de la gateway) avec ip route | grep default | awk '{print $3}', dans notre cas on obtient 192.168.42.1.
Enfin, récupérer l'adresse du serveur DNS à l'aide de cat /etc/resolv.conf et garder en tête l'adresse après nameserver.
La méthode dhcpcd sera utilisée pour définir l'IP statique:
Edité /etc/dhcpcd.conf comme suit à l'aide de l'éditeur de votre choix (dans mon cas nano):
# Example static IP configuration: interface eth0 static ip_address=192.168.42.250/24 #static ip6_address=fd51:42f8:caae:d92e::ff/64 static routers=192.168.42.1 static domain_name_servers=192.168.42.12
Changer le mot de passe du Pi à l'aide de passwd puis rédemarrer le avec sudo halt.
Il est maintenant possible de se connecter en SSH au Pi avec ssh pi@192.168.42.250, il n'est plus nécessaire d'utiliser le câble série.
Configuration du iC880A-SPI
Tout d'abord, on configure les locales pour éviter d'éventuel problèmes, pour cela, taper sudo raspi-config, et naviguer vers Localisation Options/Change Locale. Une fois dans le menu Locale, sélectionner les locales en_GB.UTF-8 et fr_FR.UTF-8 avec la touche espace, puis entrée, et sélectionner fr_FR.UTF-8.
Mettez à jour les pacquettages du Pi avec sudo apt-get update && sudo apt-get upgrade -y.
Il existe un driver open source sur le github de Semtech pour les appareils LoRa basé sur un SX1301, et le concentrateur est justement équipé d'un SX1301. Installez git sur le Pi avec sudo apt-get install git, créé un dossier mkdir -p ~/LoRa/, navigué dedans cd ~/LoRa/ et cloné le git https://github.com/Lora-net/lora_gateway. Pour des raisons de débuguage, il faut modifier au préalable la ligne DEBUG_HAL= 1 dans /lora_gateway/libloragw/library.cfg.
Compilez la librairie et les quelques programmes de test situés dans les sous-dossiers de lora_gateway avec make. Si la compilation est réussie, la librairie libloragw.a a dû être créée et est prête à l'usage par le packet tracer qui sera installé par la suite.
Ce driver nécessite une interface SPI pour fonctionner, et elle doit être activée sur le Pi. Pour cela, retourner dans le menu raspi-config, puis dans Interfacing Options, activer SPI. Maintenant que SPI est activé, il faut préparer le Reset Pin Control, pour contrôler le pin du GPIO qui sera connecté au pin Reset du iC880A. C'est très simple, il existe dans le dossier lora_gateway un fichier shell nommé reset_lgw.sh et il est lancé de cette manière ./reset_lgw.sh {start|stop} [<gpio number>], dans notre cas, 17 est le pin du GPIO. Plus tard, on configurera le lancement de cette commande au démarrage du Pi. Reliez le concentrateur au Pi comme indiquez ci-dessous:
| 21 (VDD) | 2 (+5V) |
| 22 (GND) | 6 (GND) |
| 14 (SPI_CLOCK) | 23 (SPI0_CLOCK) |
| 15 (SPI_MISO) | 21 (SPI0_MISO) |
| 16 (SPI_MOSI) | 19 (SPI0_MOSI) |
| 17 (SPI_NSS) | 24 (SPI0_CE0) |
| 13 (Reset) | 11 (GPIO_17) |
Pour s'assurer que tout fonctionne bien, lancez l'utilitaire util_tx_test avec ./util_tx_test -r 1257 -f 866.5 et vous devriez observer un résultat de ce genre:
Sending -1 LoRa packets on 866500000 Hz (BW 125 kHz, SF 10, CR 1, 16 bytes payload, 8 symbols preamble) at 14 dBm, with 1000 ms between each lgw_board_setconf:427: Note: board configuration; lorawan_public:1, clksrc:1 lgw_rxrf_setconf:488: Note: rf_chain 0 configuration; en:1 freq:866500000 rssi_offset:0.000000 radio_type:2 tx_enable:1 tx_notch_freq:129000 lgw_rxrf_setconf:488: Note: rf_chain 1 configuration; en:1 freq:866500000 rssi_offset:0.000000 radio_type:2 tx_enable:0 tx_notch_freq:129000 lgw_start:823: Note: calibration started (time: 2300 ms) lgw_start:844: Note: calibration finished (status = 159) WARNING: problem in calibration of radio A for TX DC offset Info: Initialising AGC firmware... Info: putting back original RADIO_SELECT value INFO: concentrator started, packet can be sent Sending packet number 1 ...INFO: tx_start_delay=1495 (1495.500000) - (1497, bw_delay=1.500000, notch_delay=0.000000) INFO: Enabling TX notch filter 58.a0.0.0.6a.5.1.2.0.9a.10.0.0.8.0.0.54.45.53.54.0.1.61.62.63.64.65.66.67.68.69.6a.end OK Sending packet number 2 ...INFO: tx_start_delay=1495 (1495.500000) - (1497, bw_delay=1.500000, notch_delay=0.000000) INFO: Enabling TX notch filter 58.a0.0.3.3d.5.1.2.0.9a.10.0.0.8.0.0.54.45.53.54.0.2.61.62.63.64.65.66.67.68.69.6a.end OK
Pour arrêter l'utilitaire, appuyer sur Ctrl+C. Si le test est bien réussi, on peut passer à la mise en place du serveur LoRa.
Configuration du LoRaServer
Packet Forwarder de Semtech
Au préalable, il faut installer le packet forwarder de Semtech, il tournera sur le Pi et permettra de transmettre les paquets RF reçus par le concentrateur vers le serveur LoRa à l'aide d'une liaison IP/UDP.
Comme pour lora_gateway, dans le même dossier, on clone le projet avec git clone https://github.com/Lora-net/packet_forwarder. Il faut maintenant le configurer.
Dans lora_pkt_fwd/cfg/, choisir le global_conf.json adapté à votre utilisation (référez-vous au git du packet_forwarder en cas de doute), global_conf.json.PCB_E286.EU868.basic dans notre cas, renommez-le en global_conf.json avec mv global_conf.json.PCB_E286.EU868.basic global_conf.json, et remplacer le global_conf.json dans lora_pkt_fwd/ par celui que vous venez de renommer avec mv global_conf.json .. si vous êtes situé dans le dossier cfg/.
Lorsque le programme est lancé, il effectue une analyse grammaticale des fichiers json :
- s'il détecte un debug_conf.json, il ignore tout autre fichier de configuration
- si c'est un global_conf.json, il l'analyse et passe au fichier suivant
- si il y a un local_conf.json qui redéfinit des paramètres présents dans le global_conf.json, alors la configuration locale écrase celle globale.
Ainsi, dans le fichier local, ajouter les lignes comme suit :
"gateway_conf": {
"serv_port_down": 1700, // port de réception
"serv_port_up": 1700, // port d'envoi
"server_address": "localhost", // adresse du serveur, localhost comme il est hébergé directement sur le Pi
"gateway_ID": "<ID de votre concentrateur>" // l'ID peut être obtenu en utilisant le shell update_gwid.sh fournit dans lora_pkt_fwd/,
// utiliser la commande ./update_gwid.sh local_conf.json et le gateway_ID devrait
// être automatiquement mis à jour, et doit ressembler à B827EBFFFE87BD11
}
Attention, si vous souhaitez un réseau privé, il faut modifier la variable lorawan_public en false à la 3ième ligne du fichier global_conf.json.
Vous pouvez maintenant compiler le programme avec make dans le dossier packet_forwarder/ et lancer l'exécutable avec ./lora_pkt_fwd/lora_pkt_fwd. Si tout fonctionne correctement, le programme affiche la configuration puis la réception et l'envoi de données.
Installation LoRaServer
L'installation du LoRaServer est simple, en effet, il existe un guide bien détaillé à ce sujet : https://www.loraserver.io/guides/debian-ubuntu/
N'hésitez pas à utiliser un autre mot de passe que celui par défaut (dbpassword) pour la base de données, et dans ce cas là, pensez à modifier loraserver.toml et lora-app-server.toml.
Une fois l'installation terminée, vous devriez être capable d'accéder à l'interface web de LoRa App Server à partir de n'importe quel ordinateur sur le même réseau à l'adresse <IP du Pi>:8080. Les identifiants par défaut sont admin:admin, il est maintenant possible d'ajouter votre première passerelle ainsi qu'un noeud.
- Sélectionner le menu : Network-servers
- Appuyer sur : ADD
- Onglet : GENERAL
- Network-server name : <nom quelconque>
- Network-server server : localhost:8000
- Onglet : GATEWAY DISCOVERY
- Décocher : Enable gateway discovery (à activer si vous utilisez plusieurs gateways)
- Sélectionner : ADD NETWORK-SERVER
- Sélectionner le menu : Service-profiles
- Appuyer sur : CREATE
- Service-profile name : <nom quelconque>
- Network-server : sélectionner le Network-server créé précédemment
- Cocher : Add gateway meta-data
- Décocher : Enable network geolocation
- Device-status request frequency : 0
- Minimum allowed data-rate : 0
- Maximum allowed data-rate : 5
- Sélectionner : CREATE SERVICE-PROFILE
- Sélectionner le menu : Device-Profiles
- Appuyer sur : CREATE
- Device-profile name : <nom quelconque>
- Network-server : sélectionner le Network-server créé précédemment
- LoRaWAN MAC version : 1.0.1 (est obtenue avec la commande AT: AT+VER lorsque vous êtes connecté en série au module I-NUCLEO-LRWAN1)
- LoRaWAN Regional Parameters revision : A
- MAX EIRP : 0
- Sélectionner : CREATE DEVICE-PROFILE
- Sélectionner le Device-profile que vous venez de créer
- Onglet : JOIN(OTAA/ABP)
- Cocher : Device supports OTAA
- Sélectionner : UPDATE DEVICE-PROFILE
- Sélectionner le menu : Gateways
- Appuyer sur : CREATE
- Gateway name : <nom quelconque>
- Gateway description : <description quelconque>
- Gateway ID : <ID du concentrateur> (se trouve dans /LoRa/packet_forwarder/lora_pkt_fwd/local_conf.json)
- Network-server : sélectionner le network-server créé précédemment
- Gateway altitude : altitude où est située la gateway
- Gateway location : placé le marqueur où sera localisé la gateway
- Appuyer sur : CREATE GATEWAY
- Sélectionner le menu : Applications
- Appuyer sur : CREATE
- Application name : <nom quelconque>
- Application description : <description quelconque>
- Service-profile : sélectionner le service-profile créé précédemment
- Appuyer sur : CREATE APPLICATION
- Sélectionner l'application qui vient d'être créée
- Onglet : Devices
- Appuyer sur : Create
- Device name : <nom du noeud>
- Device description : <description quelconque>
- Device EUI : est obtenu avec la commande AT: AT+EUI lorsque vous êtes connecté en série au module I-NUCLEO-LRWAN1, par exemple e24f43abce39cb7d
- Device-profile : sélectionner le device-profile créé précédemment
- Cocher : Disable frame-counter validation
- Appuyer sur : CREATE DEVICE
- Onglet : KEYS (OTAA)
- Application key : générer une clé
- Gen application key : générer une clé
- Appuyer sur : SET DEVICE-KEYS
Votre passerelle et un nœud sont maintenant configurés, on peut passer à la programmation du NUCLEO-F401RE.
Création systemd
Pour ne plus avoir besoin d'effectuer ces manipulations manuellement par terminal, le concentrateur doit être reset et le programme lora_pkt_fwd doit être lancé lors du démarrage du Pi. Pour cela, il est nécessaire de créer un service qui executera les 2 exécutables au démarrage. Commencez par créer un fichier /etc/systemd/system/pkt_fwd.service :
[Unit] Description=Service packet forwarder & reset concentrateur After=network.target StartLimitIntervalSec=0
[Service] Type=simple Restart=always RestartSec=1 User=pi ExecStartPre=/home/pi/LoRa/lora_gateway/reset_lgw.sh start WorkingDirectory=/home/pi/LoRa/packet_forwarder/lora_pkt_fwd ExecStart=/home/pi/LoRa/packet_forwarder/lora_pkt_fwd/lora_pkt_fwd
[Install] WantedBy=multi-user.target
Démarrer le service avec systemctl start pkt_fwd et automatiser son lancement au démarrage avec systemctl enable pkt_fwd.
Si vous voulez observer les logs, utiliser journalctl -f -n 100 -u pkt_fwd.
Pour la compréhension des lignes de code, référez-vous aux pages man systemd.service & systemd.unit.
Programmation du NUCLEO-F401RE
Le NUCLEO-F401RE permet d'automatiser l'envoi de données, en effet, s'il est connecté en série avec avec le I-NUCLEO-LRWAN1, il peut lui envoyer des commandes AT. Les pins UART TX et RX sur le NUCLEO-F401RE sont PA_11 et PA_12 respectivement sur l'en-tête CN10 et D0 et D1 sur l'en-tête CN9 pour le I-NUCLEO-LRWAN1. Connectez ainsi PA_11 à D1 et PA_12 à D0.
Description en-tête CN10 NUCLEO-F401RE
Description en-tête CN9 I-NUCLEO-LRWAN1
Il faut également connecter le capteur DHT11, placer le sur une mini-breadboard et connecter VCC, GND et DATA aux pins U5V, GND et PC_7 respectivement du NUCLEO-F401RE.
Il est maintenant possible de programmer la board avec le compilateur mbed. Copiez le programme suivant Media:dht11_sm_42.zip sur mbed, compléter les variables globales selon ce qui vous convient (APPKEY est la clé d'application générée plus tôt sur le serveur applicatif, unique à chaque nœud), et compilez le, une fois le fichier .bin télécharger, transférer le vers le dossier NUCLEO qui apparaît lorsque le NUCLEO-F401RE est connecté par USB.
Le micro-contrôleur se redémarre et le module LoRa est prêt à rejoindre le réseau LoRaWAN et envoyer les données du capteur DHT11.
Maintenant il faut mettre en place l'application sur laquelle on lira les résultats.
Implémentation Grafana
Grafana est un logiciel libre sous licence Apache 2 qui permet la visualisation et la mise en forme de données métriques sous des tableaux de bord depuis plusieurs sources dont des bases de données de série temporelle (Time Series Database) comme Graphite, InfluxDB ... Et par chance, LoRaServer permet l'intégration d'une base de données InfluxDB, c'est à dire que lorsque le serveur applicatif reçoit les données des capteurs, il peut directement les stocker dans une base de donnée, et cette base de données peut ensuite être utilisée par Grafana.
Pour configurer l'intégration, il faut revenir sur le LoRa App Server, et suivre les étapes suivantes:
- Sélectionner le menu Applications
- Sélectionner l'application existante
- Onglet : INTEGRATIONS
- Appuyer sur : CREATE
- Integration kind : InfluxDB integration
- API endpoint : http://localhost:8086/write
- Username : admin (dépend des identifiants utilisés pour la base de données)
- Password : admin
- Database name : lora
- Appuyer sur : UPDATE INTEGRATION
L'intégration est maintenant configurée pour rediriger les données vers la base de données nommée lora qui sera créée plus tard. Il faut également programmer le codec Javascript pour décoder les trames reçues des noeuds. Pour cela:
- Sélectionner le menu Device-profiles
- Sélectionner le device-profile existant
- Onglet : CODEC
- Sélectionner : Custom JavaScript codec functions
- Compléter la fonction Decode avec le code ci-dessous :
function Decode(fPort, bytes) {
var decoded = {};
if(bytes[1] == 1) { //le premier octet est l'octet d'identification du type de capteur, et 1 correspond au DHT11
decoded.t = bytes[2]; //la température est envoyée sur le 2nd octet (voir mbed)
decoded.h = bytes[3]; //humidité 3ème octet
return decoded; //envoi les valeurs t et h vers influxdb et il ne reste plus qu'à les lire sur grafana
}
}
Dorénavant, si vous souhaitez utiliser d'autres types de capteur, selon la manière que vous encodez les trames que les noeuds envoient, il est nécessaire d'ajouter au codec une condition pour le décodage de la dite trame.
Passons maintenant à l'installation de Grafana sur le Raspberry Pi. Reconnectez-vous au Pi par SSH si vous ne l'êtes pas déjà, et tapez
wget https://dl.grafana.com/oss/release/grafana_6.2.4_armhf.deb
sudo dpkg -i grafana_6.2.4_armhf.deb
pour installer Grafana. La version 6.2.4 était la version la plus récente lors de la rédaction de ce wiki, n'hésitez pas à utilisez l'hyperlien précédent pour obtenir la version la plus récente.
Il faut également installer InfluxDB, pour cela, utiliser les commandes suivantes :
wget -qO- https://repos.influxdata.com/influxdb.key | sudo apt-key add -
test $VERSION_ID = "7" && echo "deb https://repos.influxdata.com/debian wheezy stable" | sudo tee /etc/apt/sources.list.d/influxdb.list
test $VERSION_ID = "8" && echo "deb https://repos.influxdata.com/debian jessie stable" | sudo tee /etc/apt/sources.list.d/influxdb.list
test $VERSION_ID = "9" && echo "deb https://repos.influxdata.com/debian stretch stable" | sudo tee /etc/apt/sources.list.d/influxdb.list
sudo apt-get update && sudo apt-get install influxdb
sudo systemctl unmask influxdb.service
sudo systemctl start influxdb
sudo systemctl enable influxdb
Pour accéder à l'interface InfluxDB, utiliser influx -precision rfc3339 et créer la base de donnée lora avec CREATE DATABASE lora. Pour plus d'informations sur l'utilisation de InfluxDB, rendez vous à ce lien.
Identifiez vous à l'adresse <IP du Pi>:3000 pour accéder à l'interface Grafana, sur la première page, appuyer sur Create your first data source et choisissez InfluxDB. Ajoutez http://localhost:8086 dans URL, et lora dans Database. Revenez maintenant à l'interface Grafana pour créer le tableau de bord qui permettra d'observer les données de température et d'humidité du capteur DHT11.
- Ajout d'un panneau Grafana
La prise en main de Grafana est simple, n'hésitez pas à explorer les différentes options disponibles. Ci-dessous un aperçu d'un tableau de bord pour des capteurs DHT11 et PIR :
