Serveur d'impression

LoRa avec Raspberry Pi – Communication Peer to Peer avec Arduino – Bien choisir son serveur d impression

Le 1 février 2022 - 17 minutes de lecture


LoRa devient de plus en plus populaire avec l'avènement de l'IoT, des voitures connectées, du M2M, de l'industrie 4.0, etc. En raison de sa capacité à communiquer sur de longues distances avec très peu d'énergie, il est de préférence utilisé par les concepteurs pour envoyer/recevoir des données à partir d'une chose alimentée par batterie. Nous avons déjà discuté des bases de LoRa et de l'utilisation de LoRa avec Arduino. Bien que la technologie soit initialement destinée à ce qu'un nœud LoRa communique avec une passerelle LoRa, il existe de nombreux scénarios dans lesquels un nœud LoRa doit communiquer avec un autre nœud LoRa pour échanger des informations sur de longues distances.

Donc, dans ce tutoriel, nous allons apprendre comment utiliser un module LoRa SX1278 avec Raspberry pi pour communiquer avec un autre SX1278 connecté à un microcontrôleur comme Arduino. Cette méthode peut être utile à de nombreux endroits puisque l'Arduino pourrait agir en tant que serveur pour récupérer les données des capteurs et les envoyer à Pi sur une longue distance via LoRa, puis le Pi agissant en tant que client peut recevoir ces informations et les télécharger sur le pourrait puisqu'il a accès à Internet. Cela semble intéressant, non ? Alors, commençons.

Matériaux nécessaires

  • Module LoRa SX1278 433 MHz – 2 numéros
  • Antenne LoRa 433MHz – 2Nos
  • Arduino UNO- ou autre version
  • Framboise Pi 3

On suppose que votre Raspberry Pi est déjà flashé avec un système d'exploitation et est capable de se connecter à internet. Si ce n'est pas le cas, suivez le didacticiel Premiers pas avec Raspberry Pi avant de continuer. Ici, nous utilisons Rasbian Jessie a installé Raspberry Pi 3.

Avertissement: Utilisez toujours votre module LoRa SX1278 avec des antennes 433 MHz ; sinon le module pourrait être endommagé.

Connecter Raspberry Pi avec LoRa

Avant d'aborder les progiciels, préparons le matériel. le SX1278 est un 16 broches Module Lora qui communique en utilisant SPI sur 3.3V Logic. Le Raspberry pi fonctionne également au niveau logique 3,3 V et dispose également d'un port SPI intégré et d'un régulateur 3,3 V. Nous pouvons donc connecter directement le module LoRa avec le Raspberry Pi. Le tableau de connexion est présenté ci-dessous

Tarte aux framboises Lora – Module SX1278
3.3V 3.3V
Terre Terre
GPIO 10 MOSI
GPIO 9 MISO
GPIO 11 SCK
GPIO 8 Nss / Activer
GPIO 4 DIO 0
GPIO 17 DIO 1
GPIO 18 DIO 2
GPIO 27 DIO 3
GPIO 22 TVD

Vous pouvez également utiliser le schéma de circuit ci-dessous pour référence. Notez que le schéma de circuit a été créé à l'aide de la Module RFM9x qui ressemble beaucoup à la Module SX1278, par conséquent, l'apparence peut différer dans l'image ci-dessous.

Schéma du circuit de connexion du module Raspberry Pi LoRa

Les connexions sont assez simples, le seul problème que vous pourriez rencontrer est que le SX1278 n'est pas compatible avec la planche à pain, vous devez donc utiliser des fils de connexion directement pour établir les connexions ou utiliser deux petites planches à pain comme indiqué ci-dessous. De plus, peu de gens suggèrent d'alimenter le module LoRa avec un rail d'alimentation séparé de 3,3 V, car le Pi pourrait ne pas être en mesure de fournir suffisamment de courant. Cependant Lora étant un module basse consommation devrait fonctionner sur le rail 3.3V de Pi, j'ai testé la même chose et j'ai trouvé qu'il fonctionnait sans aucun problème. Mais, prenez-le toujours avec une pincée de sel. Ma configuration de connexion de LoRa avec Raspberry pi ressemble à ceci ci-dessous

Matériel de circuit pour connecter Raspberry Pi avec LoRa" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Circuit-Hardware-for-Connecting-Raspberry-Pi-with-LoRa.png" style= "hauteur : 496 px ; largeur : 650 pixels

Connecter Arduino avec LoRa

La connexion pour le module Arduino reste la même que celle que nous avons utilisée dans notre précédent tutoriel. La seule différence sera qu'au lieu d'utiliser la bibliothèque de Sandeep Mistry, nous utiliserons la bibliothèque Rspreal basée sur Radio head dont nous parlerons plus tard dans ce projet. Le circuit est donné ci-dessous

Schéma du circuit de connexion du module Arduino LoRa" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Circuit-Diagram-for-Connecting-Arduino-with-LoRa.png" style="height:455px ; largeur : 750 pixels

Encore une fois, vous pouvez utiliser la broche 3,3 V sur Arduino Uno ou utiliser un régulateur 3,3 V séparé. Dans ce projet, j'ai utilisé le régulateur de tension embarqué. Le tableau de connexion des broches est donné ci-dessous pour vous aider à effectuer facilement les connexions.

Module LoRa SX1278 Carte Arduino UNO
3.3V 3.3V
Terre Terre
An/Nss D10
G0/DIO0 D2
SCK D13
MISO D12
MOSI D11
TVD D9

Étant donné que le module ne rentre pas dans une planche à pain, j'ai utilisé les fils de connexion directement pour effectuer les connexions. Une fois la connexion établie Arduino LoRa la configuration ressemblera à ceci ci-dessous

Configuration matérielle du module Arduino LoRa" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Circuit-Hardware-for-Connecting-Arduino-with-LoRa.png" style="height:452px ; largeur : 650 pixels

pyLoRa pour Raspberry Pi

Il existe de nombreux packages python que vous pouvez utiliser avec LoRa. De plus, le Raspberry Pi est couramment utilisé comme LoRaWAN pour obtenir des données de plusieurs nœuds LoRa. Mais, dans ce projet, notre objectif est de faire une communication Peer to Peer entre deux modules Raspberry Pi ou entre un Raspberry Pi et un Arduino. J'ai donc décidé d'utiliser le package pyLoRa. Il dispose de modules rpsreal LoRa Arduino et rpsreal LoRa Raspberry pi qui peuvent être utilisés sur l'environnement Arduino et Raspberry Pi. Pour l'instant, concentrons-nous sur l'environnement Raspberry Pi.

Configuration du module Raspberry Pi pour LoRa

Comme indiqué précédemment, le module LoRa fonctionne avec la communication SPI, nous devons donc activer SPI sur Pi, puis installer le pylore paquet. Suivez les étapes ci-dessous pour faire de même, après avoir ouvert la fenêtre du terminal de Pi. Encore une fois, j'utilise du mastic pour me connecter à mon Pi, vous pouvez utiliser votre méthode pratique.

Étape 1: Entrez dans le fenêtre de configuration à l'aide de la commande suivante. Pour obtenir la fenêtre ci-dessous

sudo raspi-config

Configurer Pi pour LCD" src="https://circuitdigest.com/sites/default/files/inlineimages/u/Configure-Pi-for-LCD.png

Modifier la configuration de connexion dans Pi" src="https://circuitdigest.com/sites/default/files/inlineimages/u/Change-Login-Configuration-in-Pi.png

Étape 2: Accédez aux options d'interface et activez SPI comme indiqué dans l'image ci-dessous. Nous devons activer l'interface SPI car comme nous en avons discuté, l'écran LCD et le PI communiquent via le protocole SPI

Activation de l'interface SPI dans Raspberry Pi pour Lora" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Enabling-SPI-Interface-In-Raspberry-Pi-for-Lora.png" style= "hauteur : 424 px ; largeur:592px

Étape 3: Enregistrez les modifications et revenez à la fenêtre du terminal. Assurez-vous que pip et python sont mis à jour, puis installer le RPi.GPIO paquet à l'aide de la commande suivante.

    pip installer RPi.GPIO

Cette classe de package nous aidera à contrôler la broche GPIO sur le Pi. S'il est installé avec succès, votre écran ressemblera à ceci

Installation du package GPIO dans Pi pour Lora" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Installig-GPIO-Package-in-Pi-for-Lora.png" style="height : 377 pixels ; largeur : 600 pixels

Étape 4: Procédez de la même manière à l'installation du spidev paquet à l'aide de la commande suivante. Spidev est une liaison python pour Linux qui peut être utilisée pour effectuer une communication SPI sur Raspberry Pi.

    pip installer spidev   

Si l'installation réussit, le terminal devrait ressembler à ceci ci-dessous.

Installation du package SPIDEV dans Pi pour Lora" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Installing-SPIDEV-Package-in-Pi-for-Lora.png" style="height : 376 pixels ; largeur : 600 pixels

Étape 5 : Suivant laisse installer le paquet pyLoRa à l'aide de la commande pip suivante. Ce package installe les modèles Radio associés à LoRa.

pip installer pyLoRa

Si l'installation est réussie, vous verrez l'écran suivant.

Installation du package PyLora dans Pi pour Lora" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Installing-PyLora-Package-in-Pi-for-Lora.png" style="height : 379 pixels ; largeur : 600 pixels

Le package PyLoRa prend également en charge la communication cryptée qui peut être utilisée avec Arduino et Raspberry Pi de manière transparente. Cela améliorera la sécurité des données dans votre communication. Mais vous devez installer un package séparé après cette étape, ce que je ne fais pas car le cryptage n'est pas dans le cadre de ce tutoriel. Vous pouvez suivre les liens github ci-dessus pour plus de détails.

Après cette étape, vous pouvez ajouter les informations de chemin du package à pi et essayer avec le programme python donné à la fin. Mais je n'ai pas pu ajouter le chemin avec succès et j'ai donc dû télécharger manuellement la bibliothèque et l'utiliser directement pour mes programmes. J'ai donc dû procéder aux étapes suivantes

Étape 6 : Télécharger et installez le package python-rpi.gpio et le package spidev en utilisant la commande ci-dessous.

sudo apt-get install python-rpi.gpio python3-rpi.gpio
sudo apt-get install python-spidev python3-spidev

La fenêtre du terminal devrait afficher quelque chose comme ça après les deux installations.

Package GPIO installé dans Pi pour Lora" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Installed-GPIO-Package-in-Pi-for-Lora.png" style="height : 372 pixels ; largeur : 600 pixels

Package SPIDEV installé dans Pi pour Lora" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Installed-SPIDEV-Package-in-Pi-for-Lora.png" style="height : 375 pixels ; largeur : 600 pixels

Étape 7 : Installez également git puis utilisez-le pour cloner le répertoire python de notre Raspberry Pi. Vous pouvez le faire en utilisant les commandes suivantes.

sudo apt-get install git
sudo git clone https://github.com/rpsreal/pySX127x

Installation de git dans Pi pour Lora" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Installing-git-in-Pi-for-Lora.png" style="height:377px; largeur : 600 pixels

Une fois cette étape terminée vous devriez trouver le sous-répertoire SX127x dans le dossier d'accueil de Raspberry Pi. Cela contiendra tous les fichiers requis associés à la bibliothèque.

Programmation Raspberry Pi pour LoRa

Dans une communication LoRa peer to peer, le module qui transmet les informations est appelé un serveur et le module qui reçoit les informations est appelé un client. Dans la plupart des cas, l'Arduino sera utilisé sur le terrain avec un capteur pour mesurer les données et le Pi sera utilisé pour recevoir ces données. J'ai donc décidé d'utiliser le Raspberry Pi en tant que client et l'Arduino en tant que serveur dans ce tutoriel. le le programme complet du client Raspberry Pi se trouve au bas de cette page. Ici, je vais essayer d'expliquer les lignes importantes du programme.

Mise en garde: Assurez-vous que le fichier programme se trouve dans le même répertoire où se trouve le dossier de la bibliothèque SX127x. Vous pouvez copier ce dossier et l'utiliser n'importe où si vous souhaitez porter le projet.

Le programme est assez simple il faut configurez le module LoRa pour qu'il fonctionne en 433 Mhz, puis écoutez les paquets entrants. Si nous recevons quelque chose, nous les imprimons simplement sur la console. Comme toujours, nous commençons le programme en important les bibliothèques python requises.

à partir de l'heure d'importation du sommeil
à partir de l'importation SX127x.LoRa *
depuis SX127x.board_config importer BOARD
BOARD.setup()

Dans ce cas, le package horaire est utilisé pour créer des retards, le package Lora est utilisé pour la communication LoRa et le board_config est utilisé pour régler la carte et les paramètres LoRa. Nous avons aussi configurer la carte à l'aide de BOARD.setup() une fonction.

Ensuite nous créer la classe python LoRa avec trois définitions. Étant donné que nous indentons uniquement pour faire fonctionner le programme en tant que client framboise, la classe n'a que trois fonctions, à savoir la classe init, la classe start et on_rx_done classer. La classe init initialise le module LoRa en 433 MHz avec une bande passante de 125 kHz comme défini dans le set_pa_config méthode. Ensuite c'est aussi met le module en mode veille pour économiser la consommation d'énergie.

# Les valeurs par défaut de la plage moyenne après l'initialisation sont 434,0 MHz, Bw = 125 kHz, Cr = 4/5, Sf = 128 puces/symbole, CRC sur 13 dBm
lora.set_pa_config(pa_select=1)

                def __init__(self, verbose=False):
                                super(LoRaRcvCont, self).__init__(verbeux)
                                self.set_mode(MODE.SLEEP)
                                self.set_dio_mapping([0] * 6)

La fonction de démarrage est l'endroit où nous configurer le module en tant que récepteur et obtenir comme RSSI (indicateur de force du signal de réception), état, fréquence de fonctionnement, etc.. Nous configurons le module pour qu'il fonctionne en mode récepteur continu (RXCONT) à partir du mode veille, puis utilisons une boucle while pour lire des valeurs telles que RSSI et l'état du modem. Nous vidons également les données du tampon série sur le terminal.

                def start(self):
                                self.reset_ptr_rx()
                                self.set_mode(MODE.RXCONT)
                                tandis que Vrai :
                                                dormir (.5)
                                                rssi_value = self.get_rssi_value()
                                                statut = self.get_modem_status()
                                                sys.stdout.flush()

Finalement, le on_rx_done la fonction est exécutée après la lecture du paquet entrant. Dans cette fonction, les valeurs reçues sont déplacées dans une variable appelée charge utile à partir du tampon Rx après avoir défini le drapeau de réception sur haut. Ensuite, les valeurs reçues sont décodées avec utf-8 pour imprimer des données lisibles par l'utilisateur sur le shell. Nous remettons également le module en mode veille jusqu'à ce qu'une autre valeur soit reçue.

                def on_rx_done(self):
                                print("nReçu : ")
                                self.clear_irq_flags(RxDone=1)
                                charge utile = self.read_payload(nocheck=True)
                                print(bytes(payload).decode("utf-8",'ignorer'))
                                self.set_mode(MODE.SLEEP)
                                self.reset_ptr_rx()
                                self.set_mode(MODE.RXCONT)

La partie restante du programme consiste simplement à imprimer les valeurs reçues sur la console et terminer le programme à l'aide d'une interruption clavier. Nous avons à nouveau mis la carte en mode veille même après la fin du programme pour économiser de l'énergie.



essayer:
    lora.start()
sauf KeyboardInterrupt :
    sys.stdout.flush()
    imprimer("")
    sys.stderr.write("KeyboardInterruptn")
finalement:
    sys.stdout.flush()
    imprimer("")
    lora.set_mode(MODE.SLEEP)
    BOARD. démontage()

Code Arduino pour LoRa pour communiquer avec Raspberry Pi

Comme je l'ai mentionné plus tôt, le rpsréel prend en charge Arduino et Pi et donc la communication entre Arduino et Pi est possible. Il fonctionne sur la base de la bibliothèque Radiohead d'AirSpayce. Donc tu dois installez d'abord la bibliothèque de têtes radio sur votre IDE Arduino.

Pour ce faire, visitez la page Github et téléchargez la bibliothèque dans le dossier ZIP. Placez-le ensuite dans le dossier de la bibliothèque de votre IDE Arduino. Maintenant, redémarrez l'IDE Arduino et vous trouverez des exemples de fichiers pour la bibliothèque de têtes radio. Ici, nous allons programmer l'Arduino pour qu'il fonctionne comme un serveur LoRa pour envoyer des paquets de test comme 0 à 9. Le Le code complet pour faire la même chose peut être trouvé en bas de cette page comme toujours. Ici, je vais vous expliquer quelques lignes importantes du programme.

Nous commençons le programme en important la bibliothèque SPI (installée par défaut) pour utiliser le protocole SPI, puis la bibliothèque RH_RF95 de Radio head pour effectuer la communication LoRa. Ensuite, nous définissons à quelle broche d'Arduino nous avons connecté la broche de sélection de puce (CS), de réinitialisation (RST) et d'interruption (INT) du LoRa avec Arduino. Enfin, nous définissons également que le module doit fonctionner en fréquence 434 MHz et initialiser le module LoRa.

#inclure  //Importer la bibliothèque SPI
#inclure  // RF95 de la bibliothèque RadioHead

#define RFM95_CS 10 //CS si Lora est connecté à la broche 10
#define RFM95_RST 9 //RST de Lora connecté à la broche 9
#define RFM95_INT 2 //INT de Lora connecté à la broche 2

// Passez à 434.0 ou à une autre fréquence, doit correspondre à la fréquence de RX !
#define RF95_FREQ 434.0

// Instance singleton du pilote radio
RH_RF95 rf95(RFM95_CS, RFM95_INT);

À l'intérieur de mettre en place fonction, nous allons réinitialiser le Module LoRa en tirant sa broche de réinitialisation vers le bas pendant 10 millisecondes pour repartir à zéro. Ensuite nous l'initialiser avec le module que nous avons créé précédemment à l'aide de la bibliothèque Radio head. Ensuite nous définir la fréquence et la puissance d'émission du serveur LoRa. Plus la transmission est élevée, plus vos paquets parcourront de distance mais consommeront plus d'énergie.

void setup()

//Initialiser le moniteur série
        Série.begin(9600);

// Réinitialiser le module LoRa
        pinMode(RFM95_RST, SORTIE);
        digitalWrite(RFM95_RST, BAS);
        retard(10);
        digitalWrite(RFM95_RST, HIGH);
        retard(10);

//Initialiser le module LoRa
        tandis que (!rf95.init()) 
                Serial.println("Échec de l'initialisation de la radio LoRa");
                tandis que (1);
        


    //Définir la fréquence par défaut 434.0MHz

        si (!rf95.setFrequency(RF95_FREQ)) 
                Serial.println("setFrequency a échoué");
                tandis que (1);
        
        rf95.setTxPower(18); //Puissance d'émission du module Lora

A l'intérieur de l'infini boucler fonction, nous devons simplement envoyer le paquet de données via le module LoRa. Ces données peuvent être quelque chose comme la valeur du capteur de la commande utilisateur. Mais pour plus de simplicité, nous enverrons la valeur char de 0 à 9 pour chaque intervalle de 1 seconde, puis initialiserons la valeur à 0 après avoir atteint 9. Notez que les valeurs ne peuvent être envoyées que dans un format de tableau de caractères et que le type de données doit être unit8_t qui est de 1 octet à la fois. Le code pour faire la même chose est montré ci-dessous

boucle vide ()

        Serial.print("Envoyer : ");
        char radiopaquet[1] = char(valeur) ;
        rf95.send((uint8_t *)paquet radio, 1);

        retard(1000);
        valeur++ ;
        si (valeur > '9')
        valeur = 48 ;
}

Test de la communication LoRa entre Raspberry Pi et Arduino

Maintenant que nous avons à la fois notre matériel et notre programme prêts, nous devons simplement télécharger le code Arduino sur la carte UNO et le croquis python devrait être lancé sur pi. Ma configuration de test avec le matériel connecté ressemble à ceci ci-dessous

Test de la communication LoRa entre Raspberry Pi et Arduino" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/Testing-LoRa-Communication-between-Raspberry-Pi-and-Arduino.jpg" style= "hauteur : 520 px ; largeur : 600 pixels

Une fois le sketch du client python lancé sur le Pi (utilisez uniquement python 3), si tout fonctionne correctement, vous devriez voir les paquets Arduino reçus dans pi via la fenêtre du shell. Vous devriez remarquer "Reçu : 0" à 9 comme indiqué dans l'image ci-dessous.

Communication LoRa entre Raspberry Pi et Arduino" src="http://circuitdigest.com/sites/default/files/inlineimages/u1/LoRa-Communication-between-Raspberry-Pi-and-Arduino.jpg" style="height : 577 pixels ; largeur:555px

Le code complet de Raspberry pi avec toutes les bibliothèques requises peut être téléchargé à partir d'ici.

Vous pouvez maintenant déplacer le serveur Arduino et vérifier la portée du module ; il est également possible d'afficher la valeur RSSI sur le shell si nécessaire. le Le travail complet du projet peut être trouvé dans la vidéo liée ci-dessous. Maintenant que nous savons comment établir une communication LoRa longue distance à faible consommation entre Arduino et Raspberry pi, nous pouvons procéder à l'ajout d'un capteur côté Arduino et d'une plate-forme cloud côté Pi pour créer un package IoT complet.

J'espère que vous avez compris le projet et que vous avez aimé le construire. Si vous rencontrez des problèmes pour le faire fonctionner, utilisez la section des commentaires ci-dessous ou les forums pour d'autres questions techniques.

Commentaires

Laisser un commentaire

Votre commentaire sera révisé par les administrateurs si besoin.