Déploiement d'un réseau LoRaWAN

De Wiki d'activités IMA


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
  • 3 ST-NUCLEO-F401RE : composé d'un microcontrôleur STM32F4 et d'une connectivité type Arduino Uno Revision 3
  • 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 :

GPIO Raspberry Pi 3 Model B

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 qu'y 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. Connectez le concentrateur comme indiquez ci-dessous:

Aperçu des composants du concentrateur




Correspondance des PINS IC880A <> RaspBerry Pi 3
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 Forward de Semtech

Au préalable, il faut installé 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.

  1. 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
  2. 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
  3. 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
  4. Sélectionner le Device-profile que vous venez de créer
    Onglet : JOIN(OTAA/ABP)
    Cocher : Device supports OTAA
    Sélectionner : UPDATE DEVICE-PROFILE
  5. 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
  6. 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
  7. 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.

Pins DHT11

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:

Récupérée de « https://wiki-ima.plil.fr/mediawiki//index.php?title=Déploiement_d%27un_réseau_LoRaWAN&oldid=50305 »