Flux, temps réel, IoT

Voici les étapes détaillées pour connecter un routeur Dragino en utilisant le WiFi Mesh, expliquées en français :

Mise en place du routeur LoRaWAN :

Branchement du routeur :
- Branchez le routeur Dragino sur secteur en utilisant un câble USB-C (5V/2A).
- Une fois allumé, un réseau Wi-Fi intitulé dragino-XXXXXX devrait apparaître dans la liste des réseaux Wi-Fi disponibles. Le XXXXXX correspond à un identifiant unique.
Connexion au réseau Wi-Fi :
- Connectez-vous au réseau Wi-Fi dragino-XXXXXX.
- Lorsque vous y êtes connecté, vous devrez entrer le mot de passe par défaut dragino+dragino pour vous authentifier.
Accès à l’interface web du routeur :
- Ouvrez votre navigateur internet et entrez l’adresse IP 10.130.1.1 dans la barre d’adresse.
- Une fenêtre vous demandera de vous connecter avec un identifiant et un mot de passe. Par défaut, utilisez root comme identifiant et dragino comme mot de passe.
Connexion en tant que client Wi-Fi Mesh :
- Une fois connecté à l’interface web, vous pouvez configurer le mode Wi-Fi Mesh.
- Cela permettra au routeur Dragino de se connecter en tant que client à un réseau Wi-Fi existant, comme celui de votre smartphone ou de votre box internet.
- Suivez les instructions de l’interface pour configurer le mode Mesh et connecter le routeur Dragino au réseau Wi-Fi de votre choix.

Ces étapes vous permettent de configurer facilement le routeur Dragino pour qu’il fonctionne comme un client dans un réseau Wi-Fi Mesh, étendant ainsi la couverture de votre réseau.

Créer un compte TheThingsNetwork (TTN)

Rendez-vous sur le site de TheThingsNetwork : https://www.thethingsnetwork.org.
Créez un compte en vous inscrivant gratuitement. Vous aurez besoin d’une adresse e-mail valide pour la création du compte.

Obtenir le Gateway EUI

Une fois connecté à votre interface réseau, accédez à l’onglet LoRa dans la section dédiée à la gestion de votre passerelle (Gateway).
Vous trouverez le Gateway EUI, qui est un identifiant unique de votre passerelle LoRa.

Choisir TheThingsNetwork v3 - Dans l’interface de configuration de la passerelle, vous devez choisir TheThingsNetwork v3 dans le menu déroulant prévu à cet effet. - Important : La version v2 de TheThingsNetwork est obsolète pour les nouvelles passerelles, c’est pourquoi il faut sélectionner la version v3.

Adresse du serveur - Dans le deuxième menu déroulant, vous devez choisir eu1.cloud.thethings.network. Cela correspond au serveur de TheThingsNetwork situé en Europe (eu1). - Ce serveur est utilisé pour la communication avec la passerelle et pour envoyer les paquets LoRa vers le réseau TTN.

Finaliser la configuration

Une fois ces paramètres configurés (Gateway EUI, version v3, serveur eu1), vous devrez sauvegarder les modifications.
Cela permettra à votre passerelle LoRa de se connecter à TheThingsNetwork et de commencer à transmettre les paquets LoRa vers le réseau TTN.

Vérification - Après avoir configuré la passerelle, vous pouvez vérifier la connexion en accédant à votre tableau de bord TheThingsNetwork. Vous devriez y voir la passerelle apparaître et être prête à relayer les paquets LoRa.

Cela vous permet de connecter votre passerelle LoRa à TheThingsNetwork pour faire transiter les paquets LoRa vers le réseau.

Voici les étapes pour finaliser la configuration de votre passerelle sur TheThingsNetwork (TTN) après avoir configuré la passerelle LoRa (comme décrit précédemment) :

Choisir un GatewayID unique

Le GatewayID est un identifiant que vous choisissez pour votre passerelle. Il doit être unique au sein de TheThingsNetwork.
Vous pouvez vérifier la disponibilité de votre GatewayID dans le tableau de bord TTN, et si ce dernier est déjà utilisé, vous devrez en choisir un autre.
Il est conseillé de donner un nom logique à ce GatewayID (par exemple, un identifiant lié à la localisation ou à l’application de votre passerelle).

Nom de la passerelle

Le nom de la passerelle peut être choisi librement. Ce nom apparaît dans l’interface TTN et permet de vous repérer facilement parmi plusieurs passerelles. Par exemple, vous pouvez l’appeler “MaPasserelleLoRa” ou tout autre nom pertinent.

Enregistrer la passerelle

Après avoir rempli toutes les informations nécessaires (Gateway EUI, GatewayID, nom de la passerelle et serveur), cliquez sur Enregistrer.
Votre passerelle devrait maintenant être connectée à LoRaWAN via TheThingsNetwork (TTN).

Vérification

Une fois votre passerelle enregistrée, vous pouvez accéder à votre tableau de bord TTN pour vérifier qu’elle est bien en ligne et qu’elle transmet les données correctement.
Vous y verrez des informations telles que l’état de la passerelle, les paquets reçus et envoyés, et d’autres détails utiles.

Récapitulatif des étapes :

Remplir le Gateway EUI identique à celui de votre configuration Dragino.
Choisir un GatewayID unique.
Nommer la passerelle de manière libre (facultatif).
Configurer Gateway Server Address sur eu1.cloud.thethings.network.
Laisser les autres options par défaut et enregistrer.

Votre passerelle LoRa est désormais connectée à LoRaWAN via TheThingsNetwork et prête à recevoir et envoyer des paquets !

Mise en place de l’objet connecté :

Préparation du Raspberry Pi (l’objet connecté) :

Le Raspberry Pi est un mini-ordinateur de la taille approximative d’une carte bancaire, offrant des performances similaires à celles d’un smartphone et disposant de broches d’E/S (entrées/sorties) électriques. Le système d’exploitation de ce matériel est souvent installé sur une carte micro-SD (bien qu’il puisse aussi être lancé via Netboot, USB/HDD ou eMMC).

Méthodologie pour créer la carte SD :

Télécharger Raspi Imager : Rendez-vous sur https://www.raspberrypi.com/software/ et téléchargez le logiciel Raspberry Pi Imager.

Pour l’installer sur une version d’Ubuntu supérieure à 20.04, ouvrez un terminal (Ctrl+Alt+T) et tapez la commande suivante :
```
sudo snap install rpi-imager
```
Téléchargement du système d’exploitation Debian Bullseye : Une fois Raspi Imager installé, lancez-le et sélectionnez le système d’exploitation Debian Bullseye.
Configurer l’OS : Lors de la configuration, vous aurez plusieurs options à définir :
- Activer SSH : Choisissez “Activer SSH” avec le nom d’utilisateur pi et le mot de passe raspberry (recommandé).
- Configurer le Wi-Fi : Sélectionnez votre réseau Wi-Fi et entrez le mot de passe correspondant (si vous souhaitez que le Raspberry Pi se connecte à Internet via Wi-Fi).
- Nom d’hôte (optionnel) : Vous pouvez définir le nom d’hôte comme raspberry.local pour simplifier la connexion SSH.
Sélectionner le support de stockage : Ensuite, sélectionnez la carte SD (ou un autre support) sur lequel vous souhaitez installer l’OS. Une fois cela fait, lancez l’écriture de l’OS sur la carte SD.
Démarrer le Raspberry Pi : Insérez la carte SD dans le Raspberry Pi, branchez-le à un écran HDMI (ou connectez-le à votre réseau local si vous n’avez pas d’écran HDMI). Vous pouvez également accéder à votre Raspberry Pi via SSH.
Trouver l’adresse IP du Raspberry Pi : Si vous n’avez pas d’écran HDMI et si vous souhaitez accéder au Raspberry Pi via SSH, vous devez connaître son adresse IP. Si votre réseau local utilise un sous-réseau 192.168.1.0/24, vous pouvez utiliser la commande suivante depuis votre machine hôte pour scanner le réseau et trouver l’IP du Raspberry Pi :
```
nmap 192.168.1.1-254 -p 22
```
Alternativement, vous pouvez essayer la commande suivante pour voir les appareils connectés :
```
sudo arp -a
```
Se connecter via SSH : Une fois l’adresse IP du Raspberry Pi trouvée, vous pouvez vous y connecter en SSH avec la commande suivante :
```
ssh pi@<adresse_IP_trouvée>
```
Si vous avez configuré le nom d’hôte en raspberry.local, vous pouvez également vous connecter ainsi :
```
ssh pi@raspberrypi.local
```
Mettre à jour le système : Une fois connecté au Raspberry Pi via SSH, il est conseillé de mettre à jour les paquets du système. Tapez les commandes suivantes pour effectuer la mise à jour :
```
sudo apt update && sudo apt upgrade
```

Cela vous permettra de préparer votre Raspberry Pi et d’avoir une installation fonctionnelle prête à l’emploi.

Ce processus est un ensemble de commandes pour configurer un Raspberry Pi avec un récepteur GPS, en utilisant des outils et des bibliothèques spécifiques pour récupérer et traiter les données GPS. Voici une explication détaillée de chaque étape :

Mise en place du module GPS sur le raspberry :

1. Installation des paquets nécessaires

sudo apt install git device-tree-compiler git python3-crypto python3-nmea2 python3-rpi.gpio python3-serial python3-spidev python3-configobj gpsd libgps-dev gpsd-clients python3-pip

Cette commande installe plusieurs paquets nécessaires à l’utilisation de GPS avec le Raspberry Pi. Voici un résumé des paquets installés : - git : Outil pour récupérer des dépôts Git. - device-tree-compiler : Utilisé pour compiler des fichiers Device Tree (DT) pour le Raspberry Pi. - python3-crypto : Librairie Python pour les opérations cryptographiques. - python3-nmea2 : Pour la manipulation des données NMEA, un format de données utilisé pour les informations GPS. - python3-rpi.gpio : Librairie Python pour interagir avec les GPIO du Raspberry Pi. - python3-serial : Librairie pour la communication série. - python3-spidev : Pour utiliser le bus SPI (Serial Peripheral Interface) sur le Raspberry Pi. - python3-configobj : Librairie pour travailler avec des fichiers de configuration. - gpsd, libgps-dev, gpsd-clients : Paquets nécessaires pour interagir avec le démon GPS (gpsd) et les clients GPS. - python3-pip : Gestionnaire de paquets Python pour installer des bibliothèques Python supplémentaires.

2. Installation d’une bibliothèque Python

pip3 install simplecayennelpp

Cela installe la bibliothèque Python simplecayennelpp, qui est utilisée pour l’intégration avec Cayenne (une plateforme IoT) en utilisant le protocole LPP (Low Power Payload). Cette bibliothèque est probablement utilisée pour envoyer les données GPS collectées vers la plateforme IoT.

3. Téléchargement et compilation de libgps

git clone https://github.com/bbaranoff/libgps
cd libgps
make
sudo make install
sudo ldconfig

Ces commandes permettent de télécharger et de compiler une bibliothèque GPS à partir de GitHub (libgps). Ensuite, elle est installée sur le système avec les commandes make install et ldconfig pour s’assurer que la bibliothèque est correctement liée au système.

4. Configuration de gpsd

Ensuite, vous devez configurer le démon gpsd, qui est responsable de la gestion des données GPS :

nano /etc/default/gpsd

Cela ouvre le fichier de configuration du démon gpsd. Vous devez y faire les modifications suivantes : - START_DAEMON=“true” : Démarrer automatiquement le démon gpsd au démarrage du Raspberry Pi. - USBAUTO=“false” : Désactive l’ajout automatique des appareils USB au démon. - DEVICES=“/dev/ttyAMA0” : Définir le périphérique GPS à utiliser (ici, le port série /dev/ttyAMA0). - GPSD_OPTIONS=“-n” : Cette option permet au gpsd de fonctionner sans avoir besoin d’attendre la connexion d’un client.

5. Modification des fichiers de configuration système

sudo nano /boot/config.txt

Ajoutez les lignes suivantes à la fin de ce fichier pour activer certaines interfaces matérielles sur le Raspberry Pi : - enable_uart=1 : Active le port série UART pour la communication avec le module GPS. - dtoverlay=miniuart-bt : Utilise une version miniature du UART pour la gestion Bluetooth (utile pour libérer un UART pour le GPS). - dtoverlay=spi-gpio-cs : Active l’overlay SPI pour la gestion du périphérique SPI (si nécessaire).

Ensuite, modifiez /boot/cmdline.txt pour qu’il ressemble à ceci :

dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait

Cela désactive l’optimisation LPM (Low Power Mode) pour le contrôleur USB, ce qui est souvent nécessaire pour le bon fonctionnement de certains périphériques comme le GPS.

6. Téléchargement et configuration de Dragino

git clone https://github.com/computenodes/dragino
cd dragino/overlay
dtc -@ -I dts -O dtb -o spi-gpio-cs.dtbo spi-gpio-cs-overlay.dts
sudo cp spi-gpio-cs.dtbo /boot/overlays/
sudo reboot

Ces commandes téléchargent un projet GitHub appelé dragino, qui semble être un ensemble de scripts et de configurations pour travailler avec des périphériques IoT. Vous compilez un overlay (un fichier de configuration pour le matériel) pour activer la communication SPI, puis vous l’ajoutez au répertoire /boot/overlays/ pour qu’il soit pris en compte lors du démarrage du Raspberry Pi. Enfin, vous redémarrez le système pour appliquer les changements.

7. Création du script GPS Cron

#!/bin/bash
sudo python3 /home/pi/dragino/test_cayenne.py

Vous créez un script bash appelé gpscron dans le répertoire /home/pi. Ce script exécute un script Python qui semble être utilisé pour envoyer des données GPS vers la plateforme Cayenne (probablement pour la visualisation et le traitement des données IoT). Le script Python qui est exécuté ici est test_cayenne.py, et il utilise le module simplecayennelpp pour envoyer les données.

Résumé général :

Ces étapes permettent de préparer le Raspberry Pi pour utiliser un récepteur GPS, collecter des données via un port série (UART), et envoyer ces données à une plateforme IoT comme Cayenne. Les principales étapes comprennent l’installation de dépendances, la configuration du démon GPS (gpsd), la modification des fichiers de configuration système, l’installation de bibliothèques supplémentaires, et l’exécution d’un script pour envoyer les données GPS vers Cayenne.

Voici une explication détaillée du script Python test_cayenne.py, qui est utilisé pour envoyer des coordonnées GPS collectées à une plateforme IoT via LoRaWAN, en utilisant la bibliothèque CayenneLPP pour le format de données.

Mise en place du module LoRa sur le raspberry :

1. Importation des modules nécessaires

#!/usr/bin/env python3
"""
Test harness for dragino module - sends hello world out over LoRaWAN 5 times
"""
import logging
from datetime import datetime
from time import sleep
import RPi.GPIO as GPIO
from dragino import Dragino
#import subprocess
import gpsd
from simplecayennelpp import CayenneLPP
import binascii

logging : Permet de générer des logs pour suivre l’exécution du script.
datetime : Pour obtenir des horodatages pour le calcul de la durée d’exécution et des logs.
time.sleep : Utilisé pour faire des pauses dans l’exécution du script.
RPi.GPIO : Librairie pour interagir avec les broches GPIO du Raspberry Pi (non utilisée ici, mais incluse pour un usage potentiel).
Dragino : Bibliothèque utilisée pour interagir avec les modules LoRaWAN Dragino.
gpsd : Bibliothèque pour se connecter au démon GPS (gpsd) et obtenir les coordonnées.
CayenneLPP : Librairie pour le format LPP (Low Power Payload), utilisé pour envoyer des données IoT.
binascii : Utilisé pour la conversion de données en format binaire et hexadécimal.

2. Connexion au démon GPS (`gpsd`) et récupération des coordonnées

# Connect to the local gpsd
gpsd.connect()
packet = gpsd.get_current()

# See the inline docs for GpsResponse for the available data
print(packet.position())
lat = packet.lat
lon = packet.lon
alt = packet.alt

print (lat, lon, alt)

La fonction gpsd.connect() se connecte au démon gpsd, qui est responsable de la gestion des données GPS.
gpsd.get_current() récupère les informations GPS actuelles.
packet.position() renvoie un ensemble de données de position.
Le script extrait ensuite les latitude (lat), longitude (lon) et altitude (alt) des données du paquet GPS et les affiche.

3. Emballage des données GPS dans le format LPP

lpp = CayenneLPP()
lpp.addGPS( 1, lat, lon, alt)
text = binascii.hexlify(lpp.getBuffer()).decode()
sent = list(binascii.unhexlify(text))

print(text)

Le script crée un objet CayenneLPP.
La méthode addGPS(1, lat, lon, alt) ajoute les coordonnées GPS au CayenneLPP avec un identifiant de capteur (ici, 1).
Ensuite, lpp.getBuffer() retourne un tampon de données sous forme binaire, que binascii.hexlify() convertit en une chaîne hexadécimale. La chaîne hexadécimale est ensuite décodée en texte.
binascii.unhexlify(text) convertit la chaîne hexadécimale de retour en une forme binaire que le module LoRaWAN peut envoyer.

4. Configuration des logs

logLevel = logging.DEBUG
logging.basicConfig(filename="test.log", format='%(asctime)s - %(funcName)s - %(lineno)d - %(levelname)s - %(message)s', level=logLevel)

Cette ligne configure la gestion des logs, spécifiant que les logs seront stockés dans un fichier test.log et qu’ils auront un niveau de détail DEBUG.
Le format des logs inclut l’horodatage, le nom de la fonction, le numéro de ligne et le niveau de log.

5. Initialisation du module LoRaWAN Dragino

D = Dragino("/home/pi/dragino/dragino.ini", logging_level=logLevel)
D.join()
while not D.registered():
    print("Waiting for JOIN ACCEPT")
    sleep(2)

L’objet Dragino est créé en spécifiant le fichier de configuration dragino.ini. Ce fichier contient les informations nécessaires pour configurer le module LoRaWAN.
D.join() initie la procédure de “join” pour connecter le module LoRaWAN au réseau.
La boucle while not D.registered() attend que le module soit enregistré et qu’il ait reçu un “JOIN ACCEPT” du réseau. Si ce n’est pas le cas, le script attend 2 secondes et recommence.

6. Envoi des données GPS via LoRaWAN

for i in range(0, 2):
    D.send_bytes(sent)
    start = datetime.utcnow()
    while D.transmitting:
        pass
    end = datetime.utcnow()
    print("Sent GPS coordinates ({})".format(end-start))
    sleep(1)

La boucle for i in range(0, 2): envoie les données GPS deux fois.
D.send_bytes(sent) envoie les données (les coordonnées GPS encodées en format LPP) au réseau LoRaWAN.
start = datetime.utcnow() et end = datetime.utcnow() mesurent le temps qu’il faut pour envoyer les données.
D.transmitting est une condition qui attend que la transmission soit terminée.
Une fois la transmission terminée, le script affiche le temps qu’il a fallu pour envoyer les coordonnées.
sleep(1) fait une pause d’une seconde avant d’envoyer les données à nouveau.

Résumé du fonctionnement du script :

Le script se connecte au démon GPS gpsd pour récupérer les coordonnées GPS.
Les coordonnées (latitude, longitude et altitude) sont ensuite encodées dans un format compatible avec CayenneLPP.
Le script crée un objet Dragino pour la gestion des communications LoRaWAN.
Il envoie les données GPS deux fois via LoRaWAN.
Les informations sont envoyées à une plateforme IoT (Cayenne) via LoRaWAN, et les logs sont générés pour suivre l’exécution du script.

Ce script permet ainsi de collecter et d’envoyer des données GPS sur un réseau LoRaWAN à des fins de surveillance ou de suivi.

1. Modification du fichier de configuration `dragino.ini`

Vous avez mentionné qu’il faut modifier le fichier dragino.ini.default et le renommer en dragino.ini dans le répertoire /home/pi/dragino/. Voici une explication détaillée de la configuration de ce fichier pour votre module LoRaWAN et GPS.

gps_baud_rate = 9600
gps_serial_port = /dev/ttyS0
gps_serial_timeout = 1
gps_wait_period = 10

# LoRaWAN configuration
spreading_factor = 7
max_power = 0x0F
output_power = 0x0E
sync_word = 0x34
rx_crc = True
fcount_filename = .lora_fcount

# Authentication settings (ABP or OTAA)
auth_mode = otaa
devaddr = 0x01, 0x02, 0x03, 0x04  # Device Address (for ABP mode)
deveui = 0xFF, 0xFE, 0xFD, 0xFC, 0xFC, 0xFD, 0xFE, 0xFF  # DevEUI (OTAA)
appeui = 0x70, 0xB3, 0xD5, 0x00, 0x00, 0xD5, 0xB3, 0x70  # AppEUI (unique on TTN)
appkey = 0x3D, 0x83, 0xC3, 0x16, 0x2C, 0xAD, 0x44, 0xB7, 0xB0, 0x50, 0x6C, 0x3C, 0xA1, 0x54, 0x36, 0xB7  # AppKey (OTAA)

Explication des paramètres :

gps_baud_rate = 9600 : La vitesse de communication série pour le GPS. Cette valeur doit correspondre à celle de votre module GPS.
gps_serial_port = /dev/ttyS0 : Le port série auquel le GPS est connecté. Il s’agit du port /dev/ttyS0 sur le Raspberry Pi.
gps_serial_timeout = 1 : Le délai d’attente pour obtenir une réponse du GPS.
gps_wait_period = 10 : Le temps d’attente (en secondes) entre les tentatives pour récupérer des données GPS.

Configuration LoRaWAN :

spreading_factor = 7 : Facteur d’étalement utilisé pour la modulation LoRa. Une valeur de 7 est souvent utilisée pour un bon compromis entre portée et vitesse de transmission.
max_power = 0x0F et output_power = 0x0E : Ces paramètres définissent la puissance de sortie du module LoRaWAN.
sync_word = 0x34 : Mot de synchronisation utilisé pour identifier un réseau LoRa spécifique.
rx_crc = True : Activer ou désactiver la vérification de la somme de contrôle CRC sur les paquets reçus.
fcount_filename = .lora_fcount : Nom du fichier où est stocké le compteur de trames (utilisé pour le suivi des paquets envoyés).

Authentification :

auth_mode = otaa : Mode d’authentification OTAA (Over The Air Activation). Vous devez fournir des identifiants uniques pour la connexion au réseau LoRaWAN.
devaddr : L’adresse de l’appareil, utilisée dans le mode ABP (Activation By Personalization). Ce champ est commenté ici car vous utilisez OTAA.
deveui : L’ID unique de votre appareil pour l’activation OTAA.
appeui : L’ID de l’application pour l’activation OTAA.
appkey : La clé d’application pour l’activation OTAA.

Ces paramètres d’authentification sont spécifiques à The Things Network (TTN), qui est un réseau LoRaWAN populaire.

2. Exécution du script Python toutes les minutes via cron

Pour exécuter votre script gpscron toutes les minutes, vous devez configurer le planificateur de tâches cron. Voici les étapes pour y parvenir :

a. Ouvrir le fichier crontab :

Exécutez la commande suivante pour modifier les tâches cron :

sudo crontab -e

Cela ouvrira le fichier cron avec l’éditeur par défaut.

b. Ajouter une ligne pour exécuter le script toutes les minutes :

Dans le fichier cron, ajoutez cette ligne à la fin du fichier :

* * * * * /home/pi/gpscron

Cette ligne signifie : “Exécuter le script gpscron chaque minute.” Le format de cron est le suivant :

* * * * * : Représente respectivement la minute, l’heure, le jour du mois, le mois, et le jour de la semaine. Les astérisques signifient que le script sera exécuté pour chaque valeur possible.
/home/pi/gpscron : Le chemin du script à exécuter.

c. Sauvegarder et fermer l’éditeur :

Après avoir ajouté la ligne, sauvegardez et quittez l’éditeur (en fonction de l’éditeur, cela peut être Ctrl+X puis Y pour nano).

Maintenant, le script gpscron sera exécuté toutes les minutes par cron.

3. Vérification côté réseau (LoRaWAN)

Après avoir configuré le Raspberry Pi et l’avoir connecté au réseau LoRaWAN, il est temps de vérifier que les données sont bien envoyées et reçues sur le réseau.

a. Vérification sur TTN (The Things Network) :

Connectez-vous à votre compte sur The Things Network (TTN) à https://console.thethingsnetwork.org/.
Allez dans la console Applications, puis sélectionnez l’application à laquelle votre appareil est connecté.
Vérifiez que votre appareil est bien enregistré et que des données sont reçues. Vous pouvez voir les données envoyées par votre appareil (latitude, longitude, altitude) sous forme de payload dans l’interface TTN.

b. Suivi des paquets LoRaWAN :

Si vous avez un gateway LoRaWAN connectée, vous pouvez vérifier si elle reçoit et transmet correctement les paquets LoRaWAN.
Vérifiez également les logs pour voir s’il y a des erreurs dans la transmission des paquets ou des problèmes de connexion.

Conclusion :

Avec ces configurations, votre Raspberry Pi est maintenant prêt à envoyer des données GPS via LoRaWAN. Le script sera exécuté toutes les minutes pour collecter les données GPS et les envoyer au réseau LoRaWAN. Vous pouvez suivre l’activité de votre appareil via The Things Network ou toute autre plateforme compatible avec LoRaWAN.

Si vous rencontrez des problèmes avec la transmission ou la réception des données, assurez-vous que la configuration des identifiants de sécurité (DevEUI, AppEUI, AppKey) est correcte et que la passerelle LoRaWAN est opérationnelle.

Voici un guide pour connecter un appareil LoRaWAN avec le Dragino RPi Hat à The Things Network (TTN) et visualiser les données GPS en direct sur Cayenne.

1. Configurer une application TTN et ajouter un appareil

Créer une application sur TTN :
- Connectez-vous à la console TTN.
- Allez dans l’onglet Applications et cliquez sur + Create Application.
- Remplissez les détails nécessaires (nom de l’application, ID, etc.).
Ajouter un appareil :
- Une fois l’application créée, accédez à l’onglet End Devices.
- Cliquez sur + Add End Device.
Configurer les paramètres de l’appareil :
- Récupérez les paramètres définis sur votre Raspberry Pi dans le fichier /home/pi/dragino/dragino.ini :
  - AppEUI : 0x70, 0xB3, 0xD5, 0x00, 0x00, 0xD5, 0xB3, 0x70
  - DevEUI : 0xFF, 0xFE, 0xFD, 0xFC, 0xFC, 0xFD, 0xFE, 0xFF
  - AppKey : 0x3D, 0x83, 0xC3, 0x16, 0x2C, 0xAD, 0x44, 0xB7, 0xB0, 0x50, 0x6C, 0x3C, 0xA1, 0x54, 0x36, 0xB7
- Entrez ces valeurs dans les champs correspondants lors de l’ajout de l’appareil.

2. Allumer le Raspberry Pi et initialiser le GPS

Mettre à jour l’heure (truc pour activer le GPS) :
- Ouvrez un terminal sur le Raspberry Pi.
- Exécutez la commande :
```
sudo ntpdate fr.pool.ntp.org
```
Activer le GPS :
- Placez le Raspberry Pi à l’extérieur pour une meilleure réception GPS.
- Retirez le jumper Tx du Dragino RPi Hat.
- Attendez que la LED verte du Dragino clignote (indiquant un fixe 3D pour le GPS).
- Rebranchez le jumper Tx à chaud.

Votre appareil devrait maintenant être connecté à TTN.

3. Format de charge utile (Payload)

Choisissez le format CayenneLPP pour les données transmises.
Sur la console TTN, vérifiez que l’appareil envoie des données et que vous voyez les coordonnées dans l’application.

4. Surveillance des données avec Cayenne

Créer un compte Cayenne :
- Rendez-vous sur myDevices et créez un compte.
Intégrer TTN à Cayenne :
- Sélectionnez The Things Network comme source d’intégration.
- Ajoutez un nouveau dispositif.
- Choisissez Dragino RPi Hat et entrez le DevEUI de l’appareil.
Voir les données GPS en direct :
- Une fois configuré, vous devriez voir les données GPS de votre appareil apparaître en direct sur votre tableau de bord Cayenne.

Résultat

Vous avez maintenant un appareil connecté via LoRaWAN, capable de transmettre des coordonnées GPS en direct à TTN et Cayenne pour la visualisation et le suivi en temps réel. 🎉

Module Heltec LoRa V3 :

Le Heltec LoRa V3 est un module de développement basé sur le ESP32, intégrant un module LoRa SX1262, un écran OLED, ainsi qu’une connectivité Wi-Fi et Bluetooth. Il est principalement utilisé pour des applications IoT (Internet of Things) nécessitant une communication longue portée avec une faible consommation d’énergie.

🔹 Caractéristiques principales

Microcontrôleur : ESP32 (double cœur, Wi-Fi et Bluetooth intégré)
Module LoRa : SX1262 (sub-GHz, meilleure sensibilité et portée par rapport au SX1276)
Écran OLED : 0,96 pouces (128×64 pixels)
Bande de fréquence : 433 MHz / 868 MHz / 915 MHz (selon la version)
Alimentation : USB Type-C ou batterie LiPo avec chargeur intégré
Connectivité :
- Wi-Fi 802.11 b/g/n
- Bluetooth 4.2 (BLE)
GPIOs : 26 broches disponibles pour capteurs et actionneurs
Antenne : connecteur IPEX pour antenne externe
Mémoire : 8 MB Flash
Interface de programmation : Compatible Arduino IDE, PlatformIO, et ESP-IDF

🔹 Avantages du Heltec LoRa V3

✅ Intégration complète : ESP32, LoRa, OLED et gestion de batterie dans un seul module
✅ Longue portée : Grâce au SX1262, offrant une meilleure pénétration et portée que le SX1276
✅ Faible consommation : Idéal pour les capteurs LoRaWAN ou les réseaux privés LoRa
✅ Support logiciel étendu : Compatible avec de nombreuses bibliothèques (Arduino, MicroPython, etc.)

🔹 Utilisations possibles

Réseaux LoRaWAN (Helium, TTN, ChirpStack)
Stations météo connectées
Suivi GPS à longue portée
Communication IoT sans infrastructure Wi-Fi
Surveillance agricole et industrielle

Installation et configuration de l’ESP32 sur l’IDE Arduino

Voici les étapes pour installer et configurer l’ESP32 sur l’IDE Arduino.

1. Installer l’IDE Arduino

Si ce n’est pas encore fait, téléchargez et installez l’IDE Arduino depuis le site officiel :
🔗 Télécharger l’IDE Arduino

2. Ajouter le support de l’ESP32 dans l’IDE Arduino

Ouvrez l’IDE Arduino.
Allez dans Fichier → Préférences.
Dans le champ URL de gestionnaire de cartes supplémentaires, ajoutez cette URL :
```
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
```
Si une URL est déjà présente, séparez-les par une virgule.
Cliquez sur OK.

3. Installer la carte ESP32

Allez dans Outils → Type de carte → Gestionnaire de cartes.
Recherchez ESP32 dans la barre de recherche.
Sélectionnez esp32 by Espressif Systems et cliquez sur Installer.
Attendez la fin de l’installation.

4. Sélectionner la carte ESP32

Branchez votre carte ESP32 à l’ordinateur via un câble USB.
Allez dans Outils → Type de carte, puis sélectionnez votre modèle d’ESP32 (ex: “ESP32 Dev Module”).
Dans Outils → Port, sélectionnez le port USB correspondant à votre ESP32.

5. Installer les pilotes USB (si nécessaire)

Si votre carte ESP32 n’est pas reconnue, installez les pilotes adaptés : - CP210x USB to UART Bridge VCP Drivers (Silicon Labs) : Télécharger ici - CH340 Drivers (si votre carte utilise un CH340) : Télécharger ici

6. Tester l’installation avec un programme de base

Ouvrez Fichier → Exemples → Basics → Blink.

Modifiez la ligne du numéro de la LED intégrée :

int ledPin = 2; // La plupart des cartes ESP32 utilisent le GPIO2 pour la LED intégrée

Cliquez sur Téléverser.
Si tout fonctionne, la LED de votre ESP32 clignotera.

7. Résolution des problèmes courants

Erreur de téléversement ? Maintenez le bouton BOOT de l’ESP32 enfoncé lors du téléversement.
Port série non détecté ? Vérifiez que le câble USB est data+charge (pas uniquement charge).
ESP32 ne répond pas ? Essayez de redémarrer en appuyant sur le bouton EN (RESET).

🎯 Votre ESP32 est maintenant prêt à être utilisé avec l’IDE Arduino !

🔹 Programmation et Bibliothèques

Le module peut être programmé avec Arduino IDE en utilisant la bibliothèque LoRa.h pour gérer la communication LoRa. Pour l’écran OLED, la bibliothèque U8g2 est souvent utilisée.

Exemple simple pour envoyer un message LoRa :

#include <SPI.h>
#include <LoRa.h>

#define SS 18
#define RST 14
#define DIO0 26

void setup() {
  Serial.begin(115200);
  while (!Serial);
  
  Serial.println("Initialisation LoRa...");
  LoRa.setPins(SS, RST, DIO0);

  if (!LoRa.begin(868E6)) {
    Serial.println("Échec de l'initialisation LoRa");
    while (1);
  }

  Serial.println("LoRa initialisé !");
}

void loop() {
  Serial.println("Envoi d'un message...");
  LoRa.beginPacket();
  LoRa.print("Hello LoRa !");
  LoRa.endPacket();
  delay(5000);
}

Voici un programme pour le récepteur LoRa utilisant le module Heltec LoRa V3 avec le SX1262. Ce code permet d’écouter les messages envoyés par un émetteur et de les afficher sur le moniteur série ainsi que sur l’écran OLED du module.

Programme du récepteur LoRa (Heltec LoRa V3)

#include <SPI.h>
#include <LoRa.h>
#include "heltec.h"

// Définition des broches LoRa (ESP32 Heltec LoRa V3)
#define SS    18   // Chip Select LoRa
#define RST   14   // Reset LoRa
#define DIO0  26   // Interrupt Pin

void setup() {
    // Initialisation de la communication série
    Serial.begin(115200);
    while (!Serial);
    
    // Initialisation de l'écran OLED
    Heltec.begin(true /*DisplayEnable*/, true /*LoRaEnable*/, true /*SerialEnable*/);
    Heltec.display->clear();
    Heltec.display->drawString(0, 0, "Initialisation...");
    Heltec.display->display();

    // Initialisation de LoRa
    Serial.println("Démarrage LoRa...");
    LoRa.setPins(SS, RST, DIO0);

    if (!LoRa.begin(868E6)) {  // Adapter la fréquence (433E6 / 868E6 / 915E6)
        Serial.println("Échec de l'initialisation LoRa !");
        while (1);
    }

    Serial.println("LoRa initialisé !");
    Heltec.display->clear();
    Heltec.display->drawString(0, 0, "LoRa RX prêt !");
    Heltec.display->display();
}

void loop() {
    int packetSize = LoRa.parsePacket();
    if (packetSize) {
        Serial.print("Paquet reçu : ");
        
        // Lecture du paquet reçu
        String receivedText = "";
        while (LoRa.available()) {
            receivedText += (char)LoRa.read();
        }

        Serial.println(receivedText);

        // Affichage sur l'OLED
        Heltec.display->clear();
        Heltec.display->drawString(0, 0, "Msg reçu:");
        Heltec.display->drawString(0, 15, receivedText);
        Heltec.display->display();
    }
}

Explication du code :

Initialisation de l’écran OLED : Affiche un message sur l’écran OLED lors de l’initialisation.
Configuration des broches LoRa : Définit les connexions SPI entre le module SX1262 et l’ESP32.
Réception des paquets LoRa :
- Vérifie si un message est reçu.
- Lit le message et l’affiche sur le moniteur série.
- Affiche le message sur l’écran OLED du Heltec LoRa V3.

💡 N’oubliez pas de vérifier que l’émetteur et le récepteur utilisent la même fréquence (ex: 868 MHz pour l’Europe, 915 MHz pour l’Amérique du Nord).

LoRaWAN avec le Heltec LoRa V3 (ESP32 + SX1262)

🔹 Qu’est-ce que LoRaWAN ?

LoRaWAN est un protocole réseau basé sur la technologie LoRa, conçu pour connecter des objets IoT sur de longues distances avec une faible consommation d’énergie. Il fonctionne avec des passerelles (gateways) qui relaient les données entre les nœuds LoRa et les serveurs en ligne.

🔹 Différence entre LoRa et LoRaWAN

Critère	LoRa	LoRaWAN
Type de communication	Point-à-point (P2P)	Réseau avec passerelles
Infrastructure	Pas besoin de passerelle	Nécessite une passerelle LoRaWAN
Sécurité	Pas de chiffrement	Cryptage AES128
Gestion du réseau	Manuelle	Automatique via un serveur LoRaWAN
Cas d’utilisation	Communication directe entre modules	Communication IoT en réseau

1️⃣ Matériel et Pré-requis

Heltec LoRa V3 (ESP32 + SX1262)
Passerelle LoRaWAN (TTN Gateway, Helium, Dragino, etc.)
Compte sur The Things Network (TTN) (serveur LoRaWAN open-source)
Bibliothèques Arduino :
- MCCI LoRaWAN LMIC (pour LoRaWAN)
- ArduinoJson (optionnel, pour le format des données)

2️⃣ Création d’un Compte sur TTN

Créer un compte sur The Things Network
Créer une application
Ajouter un périphérique (nœud LoRa)
- Note les identifiants :
  - DevEUI (ID unique du module)
  - AppEUI (ID de l’application)
  - AppKey (clé de sécurité)
Configurer une passerelle ou utiliser une passerelle publique.

3️⃣ Programme LoRaWAN (OTAA)

Ce programme envoie des messages au réseau LoRaWAN via OTAA (Over-The-Air Activation).

Code LoRaWAN (OTAA) pour Heltec LoRa V3

/* Heltec Automation LoRaWAN communication example
 *
 * Function:
 * 1. Upload node data to the server using the standard LoRaWAN protocol.
 * 2. The network access status of LoRaWAN is displayed on the screen.
 * 
 * Description:
 * 1. Communicate using LoRaWAN protocol.
 * 
 * HelTec AutoMation, Chengdu, China
 * 成都惠利特自动化科技有限公司
 * www.heltec.org
 *
 * this project also realess in GitHub:
 * https://github.com/Heltec-Aaron-Lee/WiFi_Kit_series
 * */

#include "LoRaWan_APP.h"

/* OTAA para*/
uint8_t devEui[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t appEui[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t appKey[] = { 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11 };

/* ABP para*/
uint8_t nwkSKey[] = { 0x15, 0xb1, 0xd0, 0xef, 0xa4, 0x63, 0xdf, 0xbe, 0x3d, 0x11, 0x18, 0x1e, 0x1e, 0xc7, 0xda,0x85 };
uint8_t appSKey[] = { 0xd7, 0x2c, 0x78, 0x75, 0x8c, 0xdc, 0xca, 0xbf, 0x55, 0xee, 0x4a, 0x77, 0x8d, 0x16, 0xef,0x67 };
uint32_t devAddr =  ( uint32_t )0x007e6ae1;

/*LoraWan channelsmask*/
uint16_t userChannelsMask[6]={ 0x00FF,0x0000,0x0000,0x0000,0x0000,0x0000 };

/*LoraWan region, select in arduino IDE tools*/
LoRaMacRegion_t loraWanRegion = ACTIVE_REGION;

/*LoraWan Class, Class A and Class C are supported*/
DeviceClass_t  loraWanClass = CLASS_C;

/*the application data transmission duty cycle.  value in [ms].*/
uint32_t appTxDutyCycle = 15000;

/*OTAA or ABP*/
bool overTheAirActivation = true;

/*ADR enable*/
bool loraWanAdr = true;


/* Indicates if the node is sending confirmed or unconfirmed messages */
bool isTxConfirmed = true;

/* Application port */
uint8_t appPort = 2;
/*!
* Number of trials to transmit the frame, if the LoRaMAC layer did not
* receive an acknowledgment. The MAC performs a datarate adaptation,
* according to the LoRaWAN Specification V1.0.2, chapter 18.4, according
* to the following table:
*
* Transmission nb | Data Rate
* ----------------|-----------
* 1 (first)       | DR
* 2               | DR
* 3               | max(DR-1,0)
* 4               | max(DR-1,0)
* 5               | max(DR-2,0)
* 6               | max(DR-2,0)
* 7               | max(DR-3,0)
* 8               | max(DR-3,0)
*
* Note, that if NbTrials is set to 1 or 2, the MAC will not decrease
* the datarate, in case the LoRaMAC layer did not receive an acknowledgment
*/
uint8_t confirmedNbTrials = 4;

/* Prepares the payload of the frame */
static void prepareTxFrame( uint8_t port )
{
    /*appData size is LORAWAN_APP_DATA_MAX_SIZE which is defined in "commissioning.h".
    *appDataSize max value is LORAWAN_APP_DATA_MAX_SIZE.
    *if enabled AT, don't modify LORAWAN_APP_DATA_MAX_SIZE, it may cause system hanging or failure.
    *if disabled AT, LORAWAN_APP_DATA_MAX_SIZE can be modified, the max value is reference to lorawan region and SF.
    *for example, if use REGION_CN470, 
    *the max value for different DR can be found in MaxPayloadOfDatarateCN470 refer to DataratesCN470 and BandwidthsCN470 in "RegionCN470.h".
    */
    appDataSize = 4;
    appData[0] = 0x00;
    appData[1] = 0x01;
    appData[2] = 0x02;
    appData[3] = 0x03;
}

RTC_DATA_ATTR bool firstrun = true;

void setup() {
  Serial.begin(115200);
  Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);

  if(firstrun)
  {
    LoRaWAN.displayMcuInit();
    firstrun = false;
  }

}

void loop()
{
    switch( deviceState )
    {
        case DEVICE_STATE_INIT:
        {
#if(LORAWAN_DEVEUI_AUTO)
            LoRaWAN.generateDeveuiByChipID();
#endif
            LoRaWAN.init(loraWanClass,loraWanRegion);
            //both set join DR and DR when ADR off 
            LoRaWAN.setDefaultDR(3);
            break;
        }
        case DEVICE_STATE_JOIN:
        {
            LoRaWAN.displayJoining();
            LoRaWAN.join();
            break;
        }
        case DEVICE_STATE_SEND:
        {
            LoRaWAN.displaySending();
            prepareTxFrame( appPort );
            LoRaWAN.send();
            deviceState = DEVICE_STATE_CYCLE;
            break;
        }
        case DEVICE_STATE_CYCLE:
        {
            // Schedule next packet transmission
            txDutyCycleTime = appTxDutyCycle + randr( -APP_TX_DUTYCYCLE_RND, APP_TX_DUTYCYCLE_RND );
            LoRaWAN.cycle(txDutyCycleTime);
            deviceState = DEVICE_STATE_SLEEP;
            break;
        }
        case DEVICE_STATE_SLEEP:
        {
            LoRaWAN.displayAck();
            LoRaWAN.sleep(loraWanClass);
            break;
        }
        default:
        {
            deviceState = DEVICE_STATE_INIT;
            break;
        }
    }
}

4️⃣ Explication du Code

Activation OTAA : Le module s’inscrit au réseau LoRaWAN en utilisant DevEUI, AppEUI, et AppKey.
Transmission des données : Un message est envoyé toutes les 60 secondes.
Gestion des événements :
- EV_JOINING : Connexion en cours.
- EV_JOINED : Connexion réussie.
- EV_TXCOMPLETE : Message envoyé.

5️⃣ Visualisation des Données sur TTN

Aller dans TTN > Devices > Live Data.
Vérifier les paquets reçus.
Si vous voulez envoyer ces données vers un serveur, configure un intégrateur (ex: HTTP, MQTT, InfluxDB).

6️⃣ Pourquoi LoRaWAN ?

✅ Grande portée : Jusqu’à 10-15 km en milieu rural.
✅ Faible consommation : Idéal pour les capteurs sur batteries.
✅ Sécurité : Chiffrement AES128.
✅ Réseau public ou privé : Peut être utilisé avec TTN, Helium, ChirpStack.

7️⃣ Alternatives & Améliorations

🔹 Ajout de capteurs : Mesurer la température, l’humidité, ou la pression.
🔹 Utilisation de ABP (Activation By Personalisation) : Pas besoin de joindre le réseau.
🔹 Connexion à une base de données : Stocker les données sur un serveur.

Résumé

👉 LoRa = Communication point-à-point simple.
👉 LoRaWAN = Réseau longue portée avec infrastructure centralisée.
👉 Le Heltec LoRa V3 + TTN est une solution efficace pour l’IoT longue portée ! 🚀

Activation de la licence Heltec LoRa V3 avec la commande AT+CDKEY

Les modules Heltec LoRa V3 nécessitent parfois l’activation d’une clé de licence via des commandes AT. Cela permet de débloquer certaines fonctionnalités avancées, notamment pour LoRaWAN.

1️⃣ Récupérer le Chip ID du module

Avant d’activer la licence, il faut récupérer le Chip ID du module.

Ouvrir un terminal série (ex: Arduino Serial Monitor, PuTTY, Tera Term).
Configurer la connexion série :
- Baudrate : 115200
- Format : 8-N-1 (8 bits, No Parity, 1 Stop Bit)
- Mode : Both NL & CR (nouvelle ligne et retour chariot)
Envoyer la commande suivante :
```
AT+CHIPID
```

2️⃣ Obtenir la clé de licence (CDKEY)

Aller sur le site Heltec :
👉 https://resource.heltec.cn/search
Entrer le Chip ID récupéré précédemment.
Valider et récupérer la clé CDKEY.

3️⃣ Activer la clé CDKEY avec AT+CDKEY

Une fois la clé de licence obtenue : 1. Connecte ton module Heltec LoRa V3 au PC. 2. Ouvre un terminal série avec les mêmes paramètres que précédemment. 3. Envoie la commande suivante (remplace VOTRE_CLÉ_ICI par ta clé CDKEY) : AT+CDKEY=VOTRE_CLÉ_ICI 4. Réponse attendue : licence activated

📌 Résumé

🔹 AT+CHIPID → Récupérer l’ID unique du module
🔹 Demander la licence sur le site Heltec
🔹 AT+CDKEY=xxxx → Activer la licence

❓ Problèmes courants et solutions

Problème	Solution
`ERROR` après AT+CDKEY=xxxx	Vérifie que la clé est bien copiée et valide
`AT+CHIPID` ne répond pas	Vérifie la connexion série et le baudrate (115200)
`+CDKEY: INVALID`	La clé ne correspond pas au Chip ID, revalide sur Heltec

📌 Pourquoi activer la licence Heltec ?

✅ Débloque l’utilisation complète de LoRaWAN
✅ Assure la compatibilité avec le firmware officiel Heltec
✅ Améliore la gestion de l’alimentation et du module SX1262
✅ Permet de recevoir des mises à jour logicielles et du support officiel

Installation et Connexion d’un Objet LoRaWAN sous TTN (The Things Network)

L’ajout d’un device (objet LoRaWAN) sur The Things Network (TTN) se fait en plusieurs étapes : 1. Créer un compte TTN 2. Créer une application 3. Ajouter un device (capteur LoRaWAN) 4. Configurer l’activation (OTAA ou ABP) 5. Vérifier la connexion et les données transmises

1. Créer un Compte et Se Connecter à TTN

Allez sur The Things Network Console.
Créez un compte (si ce n’est pas déjà fait).
Connectez-vous à la console de gestion de votre région (ex : https://eu1.cloud.thethings.network/ pour l’Europe).

2. Créer une Application

Allez dans Applications > Create Application.
Remplissez les champs :
- Application ID : Identifiant unique pour votre application (ex: my-iot-app).
- Description : Ajoutez une description (facultatif).
- Network Server : Laissez par défaut (ex: Europe 1).
Cliquez sur “Create application”.

3. Ajouter un Device (Objet LoRaWAN)

Allez dans votre application et cliquez sur Add end device.
Choisissez l’option Manually (ajout manuel).
Remplissez les informations du device :
- End device ID : Nom unique pour le device (ex: temperature-sensor-01).
- LoRaWAN version : Sélectionnez la version de votre objet (LoRaWAN 1.0.2, 1.0.3, etc.).
- Regional Parameters version : Sélectionnez selon votre région (ex: PHY V1.0.2 REV B pour l’Europe).
- Frequency Plan : Sélectionnez votre bande de fréquence (EU_863_870 pour l’Europe, US_902_928 pour les USA).
- Activation Mode : OTAA (recommandé) ou ABP.

4. Configurer l’Activation du Device

Option 1 : OTAA (Over-The-Air Activation) - Recommandé

L’OTAA permet une activation dynamique et sécurisée via une requête de join envoyée par l’objet.

Renseignez les clés :
- DevEUI : Unique pour chaque device (fourni par le fabricant).
- AppEUI : Peut être généré automatiquement.
- AppKey : Clé de sécurité de 16 octets.
Cliquez sur Register end device.

Option 2 : ABP (Activation By Personalization)

L’ABP est une activation statique où les clés sont configurées directement sur l’appareil.

Renseignez les clés :
- DevAddr (Device Address).
- AppSKey (Application Session Key).
- NwkSKey (Network Session Key).
Activez l’option Disable frame counter checks si nécessaire.
Cliquez sur Register end device.

5. Vérifier la Connexion du Device

Allumez votre device et assurez-vous qu’il est bien configuré avec TTN.
Allez dans Live Data pour voir les paquets envoyés.
Si l’objet est bien connecté, vous verrez :
- Un message Join Request (OTAA).
- Une réponse Join Accept de TTN.
- Des uplinks (messages envoyés par l’objet).

6. Intégrer les Données du Device

Vous pouvez récupérer les données envoyées par l’objet via MQTT, Webhooks ou HTTP API.

Allez dans Integrations et sélectionnez un protocole comme :
- HTTP Webhook pour envoyer les données à une API.
- MQTT pour les recevoir sur un serveur MQTT.
- AWS, Azure ou Google Cloud pour intégration avec un service cloud.

Résumé

✅ Compte TTN créé
✅ Application ajoutée
✅ Device LoRaWAN enregistré
✅ Connexion et réception des données vérifiées

Votre objet est maintenant connecté à TTN et prêt à transmettre ses données LoRaWAN ! 🚀

Installation et Configuration d’un objet sous ChirpStack

L’installation de ChirpStack via Docker est la méthode la plus simple et la plus portable. Cette procédure vous guidera depuis l’installation jusqu’à la connexion d’un objet LoRaWAN via une passerelle.

1. Installation de Docker et Docker Compose

Avant d’installer ChirpStack, assurez-vous que Docker et Docker Compose sont installés.

Installer Docker

sudo apt update && sudo apt upgrade -y
sudo apt install docker.io -y

Installer Docker Compose

sudo apt install docker-compose -y

Vérifier l’installation

docker --version
docker-compose --version

2. Télécharger et Configurer ChirpStack

ChirpStack fournit un fichier docker-compose.yml permettant de lancer tous les services nécessaires.

Télécharger le projet ChirpStack

git clone https://github.com/chirpstack/chirpstack-docker.git
cd chirpstack-docker

3. Modifier la configuration (Facultatif)

Le fichier docker-compose.yml contient la configuration des services (PostgreSQL, Redis, ChirpStack). Vous pouvez le modifier pour ajuster la configuration selon votre réseau.

Si vous devez configurer une fréquence spécifique, modifiez :

nano config/chirpstack-network-server/chirpstack-network-server.toml

Exemple pour l’Europe (868 MHz) :

[network_server]
  [network_server.network_settings]
  enabled_uplink_channels=[0,1,2]

  [network_server.band]
  name="EU868"

4. Démarrer ChirpStack

Lancez les conteneurs avec :

docker-compose up -d

Vous pouvez vérifier que les conteneurs sont bien lancés :

docker ps

5. Accéder à l’Interface Web

L’interface ChirpStack est accessible via : - URL : http://localhost:8080 - Identifiants par défaut : - Utilisateur : admin - Mot de passe : admin

6. Ajouter une Passerelle (Gateway)

1. Trouver l’EUI de la Passerelle

Si vous utilisez une passerelle comme RAK, Kerlink, LPS8, vous devez récupérer son Gateway EUI.

cat /sys/class/net/eth0/address

Ou, pour certaines passerelles :

ifconfig eth0 | grep ether

2. Ajouter la Passerelle dans ChirpStack

Accédez à ChirpStack UI (http://localhost:8080).
Allez dans Gateways > Create.
Remplissez les informations :
- Gateway EUI : L’EUI de votre passerelle.
- Network Server : Sélectionnez votre serveur LoRaWAN.
- Gateway Profile : Laissez par défaut ou configurez un profil spécifique.
Enregistrez et assurez-vous que la passerelle envoie bien des paquets.

7. Ajouter un Objet LoRaWAN (Device)

1. Ajouter une Application

Allez dans Applications > Create.
Nommez l’application (my-iot-app).

2. Ajouter un Device (Objet)

Dans l’application, allez dans Devices > Create.
Device EUI : Utilisez l’EUI de votre objet LoRa.
Device Profile : Sélectionnez ou créez un profil correspondant à votre appareil (ex : OTAA / ABP).

3. Configurer la Clé OTAA

Si votre appareil utilise OTAA (Over The Air Activation) : - Ajoutez l’AppEUI et l’AppKey fournis par le fabricant.

8. Vérifier la Connexion de l’Objet

Démarrer l’objet LoRa et attendre qu’il envoie une request join.
Allez dans ChirpStack > Live LoRaWAN Frames et observez les messages join request et join accept.
Si l’appareil est bien connecté, vous devriez voir les uplinks (données envoyées par le capteur).

9. Tester la Transmission des Données

Si l’objet envoie des données, vous pouvez les voir dans ChirpStack UI sous Device Data.

Envoyer une Commande au Device

Dans Device > Queue, vous pouvez envoyer une downlink (commande vers l’objet), par exemple :

{
  "data": "AQIDBA=="
}

Où AQIDBA== est une valeur Base64.

Résumé

Docker et Docker Compose ont été installés.
ChirpStack a été lancé avec docker-compose up -d.
Passerelle LoRaWAN a été ajoutée.
Objet LoRaWAN a été enregistré et connecté.
Données sont visibles dans l’interface ChirpStack.

Différence entre ChirpStack et The Things Network (TTN)

ChirpStack et The Things Network (TTN) sont deux solutions utilisées pour déployer et gérer un réseau LoRaWAN. Cependant, elles présentent plusieurs différences fondamentales en termes de philosophie, infrastructure et mode de gestion.

1. Présentation Générale

Caractéristique	ChirpStack	The Things Network (TTN)
Type de Plateforme	Auto-hébergée (On-Premise)	Cloud public
Mode de Gestion	Privé (contrôle total)	Mutualisé (géré par la communauté)
Hébergement	Sur vos propres serveurs ou en Docker	Hébergé sur le cloud TTN
Accès aux données	Complet (base de données locale)	Via API TTN
Personnalisation	Très flexible	Standardisé
Coût	Infrastructure à gérer soi-même	Gratuit (Fair Use Policy) ou payant (TTN Enterprise)
Sécurité	Contrôlable à 100%	Dépend de TTN

2. Détail des Différences

📍 1. Hébergement et Contrôle

ChirpStack :
- Système on-premise (installé sur ses propres serveurs).
- Contrôle total sur les données, la sécurité et la personnalisation.
- Nécessite des compétences en administration serveur et DevOps.
TTN :
- Plateforme gérée dans le cloud public.
- Partage de l’infrastructure avec d’autres utilisateurs.
- Moins de contrôle sur la gestion des passerelles et des données.

📌 À savoir : Si vous voulez un réseau privé pour des applications industrielles ou critiques (Smart City, Agriculture, IoT sécurisé), ChirpStack est préférable.

📡 2. Gestion des Passerelles

ChirpStack :
- Fonctionne avec toutes les passerelles compatibles LoRaWAN.
- Possibilité d’héberger son propre Network Server.
- Peut fonctionner sans connexion internet (réseau LoRaWAN local).
TTN :
- Utilise un réseau partagé avec des passerelles publiques.
- Vous pouvez ajouter vos propres passerelles, mais elles doivent être reliées au cloud TTN.

📌 À savoir : TTN est pratique pour tester un projet sans infrastructure, mais si vous avez un réseau privé avec plusieurs passerelles, ChirpStack est plus adapté.

🔑 3. Sécurité et Données

ChirpStack :
- Les données restent sous votre contrôle.
- Peut fonctionner en local sans accès à internet.
- Permet un chiffrement personnalisé.
TTN :
- Les données passent par le cloud TTN.
- Risque de latence et de perte de données si TTN a des pannes.
- Accès aux données uniquement via API.

📌 À savoir : Pour des applications critiques (industrie, smart city), ChirpStack est préférable.

💰 4. Coût et Licence

ChirpStack :
- Gratuit et open-source.
- Nécessite des serveurs et du stockage.
- Coût d’installation et de maintenance.
TTN :
- Gratuit avec une Fair Use Policy (usage limité).
- Version TTN Enterprise payante pour usage industriel.
- Pas besoin de gérer un serveur.

📌 À savoir : TTN est bien pour un projet à petite échelle, mais ChirpStack est mieux si vous voulez un réseau 100% privé sans dépendre d’un service externe.

3. Quel Choix Faire ?

Besoin	ChirpStack	TTN
Réseau Privé	✅ Oui	❌ Non
Gestion des Données	✅ Contrôle total	❌ Dépend de TTN
Facilité d’installation	❌ Complexe	✅ Simple
Fiabilité	✅ Haute (si bien configuré)	❌ Dépend du cloud TTN
Sécurité Avancée	✅ Personnalisable	❌ Standardisée
Coût	💰 Serveurs à gérer	✅ Gratuit
Support et Maintenance	🔧 À gérer soi-même	📞 Support TTN

📌 Recommandation :

TTN si vous voulez une solution rapide, gratuite et hébergée.
ChirpStack si vous voulez un réseau LoRaWAN privé avec un contrôle total.

Conclusion

ChirpStack est idéal pour un réseau LoRaWAN privé, sécurisé et entièrement maîtrisé, tandis que TTN est une solution clé en main idéale pour des projets expérimentaux ou des petites applications IoT. 🚀

Programmer le Heltec LoRa V3 pour ChirpStack

Une fois ChirpStack configuré, il faut flasher le Heltec LoRa V3 avec le bon code.

📌 Étape 1 : Installer les bibliothèques

Dans Arduino IDE ou PlatformIO, installe : - MCCI LoRaWAN LMIC (gestion LoRaWAN) - ArduinoJson (pour formater les messages) - Heltec ESP32 (pilotes Heltec)

📌 Étape 2 : Configurer le code LoRaWAN (OTAA)

#include <lmic.h>
#include <hal/hal.h>
#include <SPI.h>

// 🔹 Identifiants OTAA récupérés dans ChirpStack
static const u1_t PROGMEM DEVEUI[8] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11 };
static const u1_t PROGMEM APPEUI[8] = { 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 };
static const u1_t PROGMEM APPKEY[16] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
                                         0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00 };

// 🔹 Broches LoRa pour Heltec V3
const lmic_pinmap lmic_pins = {
    .nss = 18,
    .rxtx = LMIC_UNUSED_PIN,
    .rst = 14,
    .dio = {26, 35, 34},
};

// 🔹 Fonction d'envoi de données vers ChirpStack
void do_send(osjob_t* j) {
    if (LMIC.opmode & OP_TXRXPEND) {
        Serial.println(F("Envoi en attente..."));
    } else {
        static uint8_t payload[4] = {0x01, 0x02, 0x03, 0x04};
        LMIC_setTxData2(1, payload, sizeof(payload), 0);
        Serial.println(F("Paquet envoyé vers ChirpStack !"));
    }
}

// 🔹 Gestion des événements LoRaWAN
void onEvent(ev_t ev) {
    switch(ev) {
        case EV_JOINING:
            Serial.println(F("Connexion LoRaWAN..."));
            break;
        case EV_JOINED:
            Serial.println(F("Connecté à ChirpStack !"));
            break;
        case EV_TXCOMPLETE:
            Serial.println(F("Données envoyées."));
            os_setTimedCallback(&sendjob, os_getTime() + sec2osticks(60), do_send);
            break;
        default:
            Serial.println(F("Événement LoRa inconnu."));
            break;
    }
}

void setup() {
    Serial.begin(115200);
    while (!Serial);

    Serial.println(F("Démarrage LoRaWAN vers ChirpStack..."));
    os_init();
    LMIC_reset();
    LMIC_startJoining();
}

void loop() {
    os_runloop_once();
}

Ajouter le Device dans ChirpStack

Accède à ChirpStack
Ajoute un nouvel appareil
- Device EUI : Colle le DEVEUI du Heltec
- Application EUI & AppKey : Colle ceux du code Arduino
Associe l’appareil à un profil LoRaWAN
Lance ton Heltec et observe les logs dans ChirpStack

Vérifier la communication LoRaWAN

Dans ChirpStack : ✅ Le Heltec LoRa V3 doit rejoindre le réseau LoRaWAN
✅ Les données doivent apparaître sous “Live Device Data”
✅ Les logs montrent l’activation OTAA et l’envoi de données

Pourquoi utiliser ChirpStack avec Heltec LoRa V3 ?

✅ Réseau LoRaWAN privé : Pas besoin d’un réseau public (comme TTN)
✅ Haute personnalisation : Intégration avec bases de données et APIs
✅ Sécurité : Chiffrement AES-128
✅ Scalabilité : Supporte plusieurs passerelles et des milliers d’appareils

📌 Conclusion

🚀 Le Heltec LoRa V3 est parfait pour un réseau LoRaWAN privé avec ChirpStack
🎯 Avec une passerelle LoRaWAN, tu peux envoyer des données IoT à votre serveur

Intégration des données recueillies

Comparaison entre ThingsBoard et myDevices Cayenne pour l’IoT

ThingsBoard et myDevices Cayenne sont deux plateformes IoT permettant de collecter, visualiser et gérer des données provenant d’objets connectés (LoRaWAN, MQTT, HTTP, etc.). Chacune a ses avantages et est adaptée à des usages spécifiques.

1. Présentation Générale

Caractéristique	ThingsBoard	Cayenne (myDevices)
Type de plateforme	Open-source / Cloud	Cloud (SaaS)
Interface utilisateur	Personnalisable	Simple et intuitive
Protocole supporté	MQTT, HTTP, CoAP, LoRaWAN	LoRaWAN, MQTT, HTTP
Hébergement	Cloud ou on-premise	Cloud uniquement
Tableaux de bord	Personnalisables	Widgets prêts à l’emploi
Facilité d’utilisation	Complexe (config à faire)	Très simple
Automatisation	Règles avancées	Basique (Triggers)
API & Intégration	Avancé (REST API, Webhooks)	API simple
Cas d’utilisation	Industriel, Smart City, Agriculture	IoT rapide, test, POC
Coût	Gratuit en open-source, payant en Cloud	Gratuit pour projets basiques

2. Détail des Fonctionnalités

🔗 Connexion avec LoRaWAN

ThingsBoard :
- Peut se connecter via MQTT à ChirpStack ou TTN.
- Possibilité de connecter plusieurs sources de données.
- Utilisation avancée avec règles métier.
Cayenne :
- Se connecte nativement à TTN et d’autres serveurs LoRaWAN.
- Installation très rapide (plug & play).
- Widgets automatiques pour capteurs LoRaWAN.

📌 À savoir : Si tu veux une intégration rapide de TTN, Cayenne est plus simple.

📊 Visualisation et Tableaux de Bord

ThingsBoard :
- Interface hautement personnalisable.
- Graphiques, cartes, alertes avancées.
- Support des timeseries et stockage long terme.
Cayenne :
- Tableaux de bord simples et préconfigurés.
- Ajout automatique des capteurs avec affichage instantané.
- Bonne solution pour prototypage rapide.

📌 À savoir : ThingsBoard est puissant mais demande plus de configuration. Cayenne est prêt à l’emploi.

⚡ Automatisation et Actions

ThingsBoard :
- Moteur de règles avancé (ex : envoi de SMS, email, webhook en cas d’anomalie).
- Workflow conditionnels (ex : si température > 30°C, activer un relais).
Cayenne :
- Système de triggers simple (ex : “si capteur détecte mouvement, envoyer email”).
- Gestion d’actions sur des GPIO (ex : activer un relais).

📌 À savoir : ThingsBoard est meilleur pour des logiques complexes.

🔌 Intégration et API

ThingsBoard :
- Compatible avec REST API, MQTT, Webhooks, Python, Node-RED.
- Peut être utilisé avec Power BI et bases de données externes.
Cayenne :
- Intégration limitée (mais fonctionne avec TTN, MQTT).
- API simple mais moins flexible.

📌 À savoir : Pour un projet IoT professionnel, ThingsBoard offre plus de flexibilité.

3. Quel Choix Faire ?

Cas d’usage	ThingsBoard	Cayenne
Prototypage rapide IoT	❌ Trop complexe	✅ Oui
Intégration avancée avec LoRaWAN	✅ Oui (via MQTT)	✅ Facile avec TTN
Industrie / Smart City	✅ Oui	❌ Trop limité
Tableaux de bord dynamiques	✅ Oui	❌ Basique
Automatisation avancée	✅ Oui (Workflows)	❌ Simple triggers
Stockage des données	✅ Personnalisable	❌ Limité
Utilisation Cloud only	❌ Possible mais optimisé On-Prem	✅ 100% Cloud

📌 Conclusion : - Utilise ThingsBoard si tu veux une solution avancée et personnalisable. - Utilise Cayenne si tu veux un dashboard rapide et facile pour tester tes capteurs IoT.

🚀 Recommandation

Si vous débutez avec TTN + LoRaWAN, commence avec Cayenne.
Si vous voulez un projet IoT robuste et évolutif, utilise ThingsBoard.

Installation de `xcaddy` et `Go` pour Caddy avec Cloudflare DNS

Afin d’utiliser Caddy avec Cloudflare pour gérer automatiquement les certificats SSL, il faut compiler Caddy avec le module DNS Cloudflare. Cela nécessite d’installer Go et xcaddy.

1. Installer Go

Caddy utilise Go pour être compilé avec des modules supplémentaires. Installe Go sur ton serveur :

sudo apt update
sudo apt install -y golang

Vérifie l’installation :

go version

2. Installer `xcaddy`

xcaddy est un outil qui permet de compiler Caddy avec des plugins personnalisés.

go install github.com/caddyserver/xcaddy@latest

Ajoute xcaddy au PATH :

export PATH=$HOME/go/bin:$PATH

Vérifie que xcaddy est bien installé :

xcaddy version

3. Compiler Caddy avec le module Cloudflare

Par défaut, Caddy ne supporte pas Cloudflare DNS. On doit le recompiler avec le plugin :

xcaddy build --with github.com/caddy-dns/cloudflare

Cela va générer un binaire caddy. Déplace-le dans /usr/bin/ :

sudo mv caddy /usr/bin/caddy

Vérifie l’installation :

caddy version

4. Configurer l’API Cloudflare dans le Système

Caddy doit utiliser un jeton API Cloudflare pour gérer automatiquement les certificats.

Créer un jeton API Cloudflare :
- Va sur Cloudflare Dashboard.
- Accède à My Profile > API Tokens.
- Clique sur Create Token et choisis le template Edit zone DNS.
- Assure-toi qu’il a accès à ton domaine.
- Copie le jeton API.
Ajouter le jeton Cloudflare à l’environnement Linux :

export CLOUDFLARE_API_TOKEN="ton_jeton_api"

Pour le rendre permanent :

echo 'export CLOUDFLARE_API_TOKEN="ton_jeton_api"' >> ~/.bashrc
source ~/.bashrc

5. Configurer `Caddyfile` avec Cloudflare

Édite le fichier de configuration de Caddy :

sudo nano /etc/caddy/Caddyfile

Ajoute les entrées pour ChirpStack et ThingsBoard :

chirpstack.yourdomain.com {
    reverse_proxy localhost:8080
    tls {
        dns cloudflare {env.CLOUDFLARE_API_TOKEN}
    }
}

thingsboard.yourdomain.com {
    reverse_proxy localhost:9090
    tls {
        dns cloudflare {env.CLOUDFLARE_API_TOKEN}
    }
}

Sauvegarde et quitte (CTRL+X, Y, Entrée).

6. Redémarrer Caddy

Recharge la configuration :

sudo systemctl restart caddy

Vérifie que tout fonctionne :

sudo systemctl status caddy

Si tout est OK, Caddy génère les certificats automatiquement via Cloudflare et assure la connexion sécurisée HTTPS pour ChirpStack et ThingsBoard.

7. Tester l’Accès Sécurisé

Ouvre un navigateur et va sur :
- https://chirpstack.yourdomain.com
- https://thingsboard.yourdomain.com
Vérifie que les certificats SSL sont actifs.

8. Automatiser le Chargement du Jeton API (Facultatif)

Ajoute la variable dans systemd pour éviter qu’elle soit supprimée au redémarrage :

sudo nano /etc/systemd/system/caddy.service.d/environment.conf

Ajoute :

[Service]
Environment="CLOUDFLARE_API_TOKEN=ton_jeton_api"

Recharge systemd :

sudo systemctl daemon-reexec
sudo systemctl restart caddy

🚀 Résumé

✅ Installation de xcaddy et Go
✅ Compilation de Caddy avec le module Cloudflare
✅ Configuration d’un jeton API Cloudflare
✅ Mise en place de Caddy comme reverse proxy sécurisé
✅ Connexion HTTPS automatique avec Cloudflare

Votre serveur est maintenant protégé avec SSL automatique, et ChirpStack + ThingsBoard sont accessibles de manière sécurisée ! 🎉

Utilisation de Meshtastic avec le Heltec LoRa V3

🔹 Qu’est-ce que Meshtastic ?

Meshtastic est un réseau maillé (mesh network) open-source basé sur LoRa, permettant la communication longue portée sans infrastructure (Wi-Fi, cellulaire, Internet). Il est utilisé pour : ✅ La communication hors-réseau (randonnée, secours, survie)
✅ L’envoi de messages texte sans réseau mobile
✅ La surveillance à distance et les capteurs IoT

Le Heltec LoRa V3 (ESP32 + SX1262) est compatible avec Meshtastic, permettant de créer un réseau maillé LoRa pour échanger des messages entre appareils.

1️⃣ Matériel requis

Heltec LoRa V3 (ESP32 + SX1262)
Antenne LoRa (obligatoire ! Ne jamais alimenter sans antenne)
PC / Smartphone (pour configurer et envoyer des messages)
Application Meshtastic (Android/iOS)

Installation de `xcaddy` et `Go` pour Caddy avec Cloudflare DNS

Afin d’utiliser Caddy avec Cloudflare pour gérer automatiquement les certificats SSL, il faut compiler Caddy avec le module DNS Cloudflare. Cela nécessite d’installer Go et xcaddy.

1. Installer Go

Caddy utilise Go pour être compilé avec des modules supplémentaires. Installe Go sur ton serveur :

sudo apt update
sudo apt install -y golang

Vérifie l’installation :

go version

2. Installer `xcaddy`

xcaddy est un outil qui permet de compiler Caddy avec des plugins personnalisés.

go install github.com/caddyserver/xcaddy@latest

Ajoute xcaddy au PATH :

export PATH=$HOME/go/bin:$PATH

Vérifie que xcaddy est bien installé :

xcaddy version

3. Compiler Caddy avec le module Cloudflare

Par défaut, Caddy ne supporte pas Cloudflare DNS. On doit le recompiler avec le plugin :

xcaddy build --with github.com/caddy-dns/cloudflare

Cela va générer un binaire caddy. Déplace-le dans /usr/bin/ :

sudo mv caddy /usr/bin/caddy

Vérifie l’installation :

caddy version

4. Configurer l’API Cloudflare dans le Système

Caddy doit utiliser un jeton API Cloudflare pour gérer automatiquement les certificats.

Créer un jeton API Cloudflare :
- Va sur Cloudflare Dashboard.
- Accède à My Profile > API Tokens.
- Clique sur Create Token et choisis le template Edit zone DNS.
- Assure-toi qu’il a accès à ton domaine.
- Copie le jeton API.
Ajouter le jeton Cloudflare à l’environnement Linux :

export CLOUDFLARE_API_TOKEN="ton_jeton_api"

Pour le rendre permanent :

echo 'export CLOUDFLARE_API_TOKEN="ton_jeton_api"' >> ~/.bashrc
source ~/.bashrc

5. Configurer `Caddyfile` avec Cloudflare

Édite le fichier de configuration de Caddy :

sudo nano /etc/caddy/Caddyfile

Ajoute les entrées pour ChirpStack et ThingsBoard :

chirpstack.yourdomain.com {
    reverse_proxy localhost:8080
    tls {
        dns cloudflare {env.CLOUDFLARE_API_TOKEN}
    }
}

thingsboard.yourdomain.com {
    reverse_proxy localhost:9090
    tls {
        dns cloudflare {env.CLOUDFLARE_API_TOKEN}
    }
}

Sauvegarde et quitte (CTRL+X, Y, Entrée).

6. Redémarrer Caddy

Recharge la configuration :

sudo systemctl restart caddy

Vérifie que tout fonctionne :

sudo systemctl status caddy

Si tout est OK, Caddy génère les certificats automatiquement via Cloudflare et assure la connexion sécurisée HTTPS pour ChirpStack et ThingsBoard.

7. Tester l’Accès Sécurisé

Ouvre un navigateur et va sur :
- https://chirpstack.yourdomain.com
- https://thingsboard.yourdomain.com
Vérifie que les certificats SSL sont actifs.

8. Automatiser le Chargement du Jeton API (Facultatif)

Ajoute la variable dans systemd pour éviter qu’elle soit supprimée au redémarrage :

sudo nano /etc/systemd/system/caddy.service.d/environment.conf

Ajoute :

[Service]
Environment="CLOUDFLARE_API_TOKEN=ton_jeton_api"

Recharge systemd :

sudo systemctl daemon-reexec
sudo systemctl restart caddy

🚀 Résumé

Votre serveur est maintenant protégé avec SSL automatique, et ChirpStack + ThingsBoard sont accessibles de manière sécurisée ! 🎉

2️⃣ Installation de Meshtastic sur Heltec LoRa V3

Meshtastic fonctionne avec un firmware spécifique que l’on doit flasher sur le module.

📌 Étape 1 : Téléchargement des outils

Installe Python (si ce n’est pas déjà fait)
🔗 Télécharger Python
Installe les outils de flashage :
```
pip install esptool meshtastic
```
Télécharge le firmware Meshtastic pour Heltec LoRa V3 🔗 https://firmware.meshtastic.org/
- Choisir : Heltec V3 (ESP32-S3 + SX1262)

📌 Étape 2 : Flasher le firmware

Mettre le module en mode flash :
- Connecter le Heltec via USB.
- Maintenir le bouton “BOOT” tout en branchant l’USB.

Vérifier le port série :

meshtastic --port auto

Si non détecté, vérifier avec :

ls /dev/ttyUSB*  (Linux/Mac)

modecom  (Windows - Chercher COMx)

Flasher le firmware :

esptool.py --chip esp32s3 --port /dev/ttyUSB0 erase_flash
esptool.py --chip esp32s3 --port /dev/ttyUSB0 write_flash -z 0x0 meshtastic-heltec-v3.bin

(Remplace /dev/ttyUSB0 par le bon port sur ton PC)

3️⃣ Configuration de Meshtastic

Connecter l’application Meshtastic (Android/iOS)
- Activer Bluetooth
- Ajouter un nouveau nœud
- Se connecter au Heltec LoRa V3
Paramétrer la fréquence LoRa
```
meshtastic --set region EU868
```
Ou pour d’autres régions :
- EU868 (Europe)
- US915 (Amérique)
- AU915 (Australie)
- AS923 (Asie)
Modifier le nom de l’appareil :
```
meshtastic --set-owner "Mon_ESP32_LoRa"
```

Tester l’envoi de messages :

meshtastic --sendtext "Hello réseau Meshtastic!"

4️⃣ Utilisation & Réseau Mesh

📡 Un module seul peut envoyer/recevoir des messages entre modules LoRa.
🌍 Avec plusieurs modules, un réseau maillé est créé pour relayer les messages.
📱 Sur mobile : L’application Meshtastic permet d’envoyer des messages via Bluetooth.

Flash de Meshtastic sur le Heltec LoRa V3 via Meshtastic Web

🔹 Qu’est-ce que Meshtastic Web Flasher ?

Le Meshtastic Web Flasher est une interface web permettant de flasher facilement un firmware Meshtastic sur un module Heltec LoRa V3 directement depuis un navigateur Chrome ou Edge (via Web Serial API).
👉 Aucun besoin d’installer Python ou Esptool !

1️⃣ Pré-requis

✔ Un module Heltec LoRa V3
✔ Un câble USB-C de bonne qualité
✔ Un PC sous Windows, Mac ou Linux
✔ Google Chrome ou Microsoft Edge (obligatoire)

2️⃣ Étapes pour flasher via Meshtastic Web

📌 Étape 1 : Accéder au flasher en ligne

Ouvre Google Chrome ou Edge
Va sur :
🔗 https://flasher.meshtastic.org

📌 Étape 2 : Connexion du Heltec LoRa V3

Branche ton module via USB
Clique sur “Connect”
Une fenêtre apparaît, sélectionne le port USB correspondant (ex: /dev/ttyUSB0 ou COM3)
Clique sur “Connect”

📌 Étape 3 : Sélection du firmware

Dans la section Device Type, choisissez Heltec V3 (ESP32S3 + SX1262)

Clique sur “Install latest stable” (ou “Install custom” pour une version spécifique)
Attends le flashage (cela peut prendre quelques minutes)
Une fois terminé, débranche et rebranche ton module

clea

3️⃣ Vérification après le flash

Après l’installation, Meshtastic est installé sur le Heltec LoRa V3 ! ✅
1. Ouvre l’application mobile Meshtastic (Android/iOS)
2. Active le Bluetooth et recherche ton module
3. Connecte-toi et configure ton réseau LoRa

4️⃣ Commandes Meshtastic via Terminal

Vous pouvez aussi configurer le module via terminal avec :

meshtastic --info   # Vérifier les infos du module
meshtastic --set region EU868   # Régler la fréquence LoRa
meshtastic --sendtext "Hello Meshtastic!"   # Envoyer un message

🔹 Pourquoi utiliser Meshtastic Web Flasher ?

✅ Installation simple et rapide (sans ligne de commande)
✅ Compatible Windows, Mac et Linux
✅ Flasher directement depuis un navigateur
✅ Aucune installation logicielle requise

🛠️ Problèmes courants et solutions

Problème	Solution
Le module n’est pas détecté	Vérifie le câble USB et teste un autre port
Flashage échoué	Essaye un autre navigateur (Chrome/Edge)
Impossible de se connecter après le flash	Redémarre le module et réessaye

🎯 Conclusion

Le Meshtastic Web Flasher est le moyen le plus simple pour installer Meshtastic sur ton Heltec LoRa V3, sans besoin de logiciels compliqués.
Une fois installé, vous pouvez communiquer en LoRa, créer un réseau maillé et échanger des messages hors-réseau !

Mise en place du routeur LoRaWAN :

Créer un compte TheThingsNetwork (TTN)

Obtenir le Gateway EUI

Mise en place de l’objet connecté :

Mise en place du module GPS sur le raspberry :

1. Installation des paquets nécessaires

2. Installation d’une bibliothèque Python

3. Téléchargement et compilation de libgps

4. Configuration de gpsd

5. Modification des fichiers de configuration système

6. Téléchargement et configuration de Dragino

7. Création du script GPS Cron

Résumé général :

Mise en place du module LoRa sur le raspberry :

1. Importation des modules nécessaires

2. Connexion au démon GPS (gpsd) et récupération des coordonnées

3. Emballage des données GPS dans le format LPP

4. Configuration des logs

5. Initialisation du module LoRaWAN Dragino

6. Envoi des données GPS via LoRaWAN

Résumé du fonctionnement du script :

1. Modification du fichier de configuration dragino.ini

Explication des paramètres :

Configuration LoRaWAN :

Authentification :

2. Exécution du script Python toutes les minutes via cron

a. Ouvrir le fichier crontab :

b. Ajouter une ligne pour exécuter le script toutes les minutes :

c. Sauvegarder et fermer l’éditeur :

3. Vérification côté réseau (LoRaWAN)

a. Vérification sur TTN (The Things Network) :

b. Suivi des paquets LoRaWAN :

Conclusion :

1. Configurer une application TTN et ajouter un appareil

2. Allumer le Raspberry Pi et initialiser le GPS

3. Format de charge utile (Payload)

4. Surveillance des données avec Cayenne

Résultat

Module Heltec LoRa V3 :

🔹 Caractéristiques principales

🔹 Avantages du Heltec LoRa V3

🔹 Utilisations possibles

Installation et configuration de l’ESP32 sur l’IDE Arduino

1. Installer l’IDE Arduino

2. Ajouter le support de l’ESP32 dans l’IDE Arduino

3. Installer la carte ESP32

4. Sélectionner la carte ESP32

5. Installer les pilotes USB (si nécessaire)

6. Tester l’installation avec un programme de base

7. Résolution des problèmes courants

🎯 Votre ESP32 est maintenant prêt à être utilisé avec l’IDE Arduino !

🔹 Programmation et Bibliothèques

Programme du récepteur LoRa (Heltec LoRa V3)

Explication du code :

LoRaWAN avec le Heltec LoRa V3 (ESP32 + SX1262)

🔹 Qu’est-ce que LoRaWAN ?

🔹 Différence entre LoRa et LoRaWAN

1️⃣ Matériel et Pré-requis

2️⃣ Création d’un Compte sur TTN

3️⃣ Programme LoRaWAN (OTAA)

Code LoRaWAN (OTAA) pour Heltec LoRa V3

4️⃣ Explication du Code

5️⃣ Visualisation des Données sur TTN

6️⃣ Pourquoi LoRaWAN ?

7️⃣ Alternatives & Améliorations

Résumé

Activation de la licence Heltec LoRa V3 avec la commande AT+CDKEY

1️⃣ Récupérer le Chip ID du module

2️⃣ Obtenir la clé de licence (CDKEY)

3️⃣ Activer la clé CDKEY avec AT+CDKEY

📌 Résumé

❓ Problèmes courants et solutions

📌 Pourquoi activer la licence Heltec ?

Installation et Connexion d’un Objet LoRaWAN sous TTN (The Things Network)

1. Créer un Compte et Se Connecter à TTN

2. Créer une Application

3. Ajouter un Device (Objet LoRaWAN)

4. Configurer l’Activation du Device

Option 1 : OTAA (Over-The-Air Activation) - Recommandé

Option 2 : ABP (Activation By Personalization)

2. Connexion au démon GPS (`gpsd`) et récupération des coordonnées

1. Modification du fichier de configuration `dragino.ini`

Installation de `xcaddy` et `Go` pour Caddy avec Cloudflare DNS

2. Installer `xcaddy`

5. Configurer `Caddyfile` avec Cloudflare

Installation de `xcaddy` et `Go` pour Caddy avec Cloudflare DNS

2. Installer `xcaddy`