Comment module Lora SX1278 avec Arduino, ESP32 et ESP8266

Introduction au SX1278

SX1278 est un transceiver sans fil de pointe de la série de Semtech, qui englobe également les transceivers SX1276/77/79. Cette technologie est renommée pour son intégration avec le modem à longue portée LoRa®, une caractéristique qui facilite la communication par spectre étalé à ultra-longue portée. Cela garantit non seulement une haute immunité aux interférences, mais parvient également à minimiser la consommation de courant, le rendant un modèle d’efficacité.

Une caractéristique remarquable du SX1278 est la technique de modulation LoRa brevetée par Semtech. Cette méthode permet au SX1278 d’atteindre une sensibilité exceptionnelle de plus de -148dBm, un exploit rendu possible même avec un cristal bon marché et une liste de matériaux modeste. De plus, sa haute sensibilité, associée à un amplificateur de puissance intégré de +20dBm, résulte en un budget de liaison leader dans l’industrie, optimal pour les applications exigeant à la fois portée et robustesse.

Le module LoRa SX1278 433Mhz par OEM, judicieusement nommé Ra-02, témoigne des capacités du SX1278. Ce module, spécifiquement basé sur le transceiver sans fil SX1278 de SEMTECH, exploite la technologie avancée de spectre étalé LoRa. Cela garantit une distance de communication stupéfiante allant jusqu’à 10 000 mètres. De plus, il possède une solide capacité anti-brouillage et une fonction de réveil aérien.

Dans le domaine de la communication sans fil, le SX1278 et ses dérivés, comme le Ra-02, se distinguent par leur équilibre entre portée, immunité aux interférences et consommation d’énergie. Ces avantages, associés à leur potentiel dans des applications telles que les maisons intelligentes, la lecture de compteurs et les équipements d’alarme antivol, les distinguent réellement sur le marché.

Introduction au Lora

LoRa, signifiant “Longue Portée”, n’est pas simplement un autre nom dans l’univers en constante expansion des technologies de communication sans fil. Se distinguant par ses capacités de longue portée, LoRa sert principalement le paysage de l’Internet des Objets (IoT). Contrairement aux systèmes sans fil à courte portée traditionnels, il est conçu pour transmettre de petites quantités de données sur de grandes distances, en utilisant un minimum d’énergie.

Spécifications Techniques du module Lora SX1278

• Modem : LoRa™ avec un budget de liaison maximal de 168dB.
• Sortie RF : +20dBm – 100mW constant par rapport à l’alimentation V.
• Amplificateur de Puissance : +14dBm haute efficacité.
• Débit Binaire : Programmable jusqu’à 300kbps.
• Sensibilité : Jusqu’à -148dBm.
• Front End : IIP3 = -11dBm.
• Courant RX : 9,9mA avec une rétention de registre de 200nA.
• Synthétiseur : Entièrement intégré avec une résolution de 61Hz.
• Modulations Supportées : FSK, GFSK, MSK, GMSK, LoRa et OOK.
• Fonctionnalités Intégrées : Synchronisateur de bits pour la récupération d’horloge, détection de préambule, capteur de température et indicateur de batterie faible.
• RSSI : Plage Dynamique de 127dB.
• Détection RF : Automatique avec AFC ultra-rapide.
• Moteur de Paquets : Jusqu’à 256 octets avec CRC.

Applications du module Lora SX1278

Intégration de l’ESP8266 & LoRa SX1278 : Création d’un Système de Communication IoT Robuste

Mise en place de l’ESP8266 pour la communication LoRa

Mise sous tension : Commencez par connecter la broche 3,3V de l’ESP8266 à la broche 3,3V du module LoRa SX1278. Il est crucial de noter que le module LoRa fonctionne à 3,3V et non à 5V ; dépasser cette valeur peut endommager le module. Établissement de la masse : Reliez le GND de l’ESP8266 au GND du module LoRa.

Communication SPI : L’ESP8266 communique avec le module LoRa via SPI. Connectez les broches suivantes :

• HSCLK de l’ESP8266 à SCK du module LoRa
• HMISO de l’ESP8266 à MISO du module LoRa
• HMOSI de l’ESP8266 à MOSI du module LoRa
• HCS de l’ESP8266 à NSS du module LoRa

Interfaçage du DHT11 avec l’ESP8266

Le DHT11 est un capteur numérique de température et d’humidité. Voici comment le connecter à l’ESP8266 :

Source d’alimentation : Connectez le VCC du DHT11 au 3.3V de l’ESP8266.

Mise à la terre : Reliez le GND du DHT11 au GND de l’ESP8266.

Transmission du signal : Connectez la broche DATA du DHT11 à un GPIO de l’ESP8266, disons D2 pour ce guide.

Élaboration du code pour la lecture et la transmission des données

Côté émetteur (ESP8266 avec DHT11 et LoRa SX1278)

#include <LoRa.h> 
#include "DHT.h" 
#define DHTPIN D2 
#define DHTTYPE DHT11 
DHT dht(DHTPIN, DHTTYPE); 
void setup() { 
Serial.begin(9600); 
dht.begin(); 
if (!LoRa.begin(433E6)) { 
Serial.println("Échec de l'initialisation LoRa !"); 
return; } Serial.println("Initialisation LoRa réussie"); 
} 
void loop() { 
float humidité = dht.readHumidity(); 
float température = dht.readTemperature(); 
LoRa.beginPacket(); 
LoRa.print("Humidité : ");
LoRa.print(humidité); 
LoRa.print(", Température : "); 
LoRa.print(température); 
LoRa.endPacket(); 
delay(1000); 
}

Côté récepteur (ESP8266 avec LoRa SX1278)

#include <LoRa.h> 
void setup() { 
Serial.begin(9600);
 if (!LoRa.begin(433E6)) { 
Serial.println("Échec de l'initialisation LoRa !"); 
return; 
} 
Serial.println("Initialisation LoRa réussie"); 
}
void loop() { 
int tailleDuPaquet = LoRa.parsePacket();
 if (tailleDuPaquet) {
 String entrant = ""; 
while (LoRa.available()) { 
entrant += (char)LoRa.read(); 
}
 Serial.println(entrant); 
}
}

Décodage du code

• Des bibliothèques comme LoRa et DHT sont essentielles. Elles facilitent la communication avec les modules respectifs.
• La fonction setup initialise la communication série, le module LoRa et le capteur DHT11.
• La boucle dans le code de l’émetteur lit les valeurs du capteur DHT11 et les envoie à l’aide du module LoRa.
• Du côté du récepteur, le code vérifie les paquets LoRa entrants et imprime les données reçues.

Cette intégration de l’ESP8266, LoRa SX1278 et DHT11 ouvre la voie à des projets IoT avancés, élargissant les horizons de la détection à distance et de la transmission de données.

ESP32, LoRa SX1278/76 et OLED :

Étapes pour le branchement de l’ESP32 et LoRa SX1278

Gestion de l’Alimentation : Tout d’abord, alignez la broche 3,3V de l’ESP32 sur la broche 3,3V du LoRa SX1278/76. N’oubliez pas que le module LoRa est un dispositif 3,3V.

Connexion à la Terre : Associez le GND de l’ESP32 avec le GND du module LoRa.

Interface SPI : L’ESP32 et le module LoRa communiquent via SPI. Faites les connexions suivantes :

• GPIO18 de l’ESP32 à SCK du LoRa
• GPIO19 de l’ESP32 à MISO du LoRa
• GPIO23 de l’ESP32 à MOSI du LoRa
• GPIO5 de l’ESP32 à NSS du LoRa

Intégration de l’Affichage OLED avec l’ESP32

Le Rôle de l’OLED

Les écrans OLED, de par leur netteté et leur faible consommation d’énergie, sont devenus populaires dans les dispositifs IoT compacts. Ils sont particulièrement utiles pour afficher des données en temps réel, comme des lectures de capteurs ou des messages entrants.

Étapes pour l’Intégration

Alimentation : Connectez le VCC de l’affichage OLED au 3.3V de l’ESP32.

Mise à la Terre : Reliez le GND de l’OLED au GND de l’ESP32.

Communication I2C : L’ESP32 et l’OLED communiquent via I2C. Voici comment :

• GPIO4 de l’ESP32 à SDA de l’OLED
• GPIO15 de l’ESP32 à SCL de l’OLED

Code : Visualisation des Données sur OLED

Côté Émetteur (ESP32 avec LoRa SX1278)

#include <LoRa.h> 
void setup() { 
Serial.begin(9600); 
if (!LoRa.begin(433E6)) { 
Serial.println("Échec de l'initialisation LoRa !"); 
return; 
} 
Serial.println("Initialisation LoRa réussie"); 
} 
void loop() { 
String message = "Bonjour de l'ESP32 !"; 
LoRa.beginPacket(); 
LoRa.print(message); 
LoRa.endPacket(); 
delay(1000); 
}

Côté Récepteur (ESP32 avec LoRa SX1278/76 et OLED)

#include <LoRa.h> 
#include <Wire.h> 
#include <Adafruit_GFX.h> 
#include <Adafruit_SSD1306.h> 
Adafruit_SSD1306 display = Adafruit_SSD1306(128, 32, &Wire); 
void setup() { 
Serial.begin(9600); 
if(!display.begin(SSD1306_I2C_ADDRESS, OLED_RESET)) { 
Serial.println("Échec de l'initialisation OLED"); 
return; 
} 
display.clearDisplay(); 
if (!LoRa.begin(433E6)) { 
Serial.println("Échec de l'initialisation LoRa !");
 return; 
} 
Serial.println("Initialisation LoRa réussie"); } 
void loop() { 
int tailleDuPaquet = LoRa.parsePacket(); 
if (tailleDuPaquet) { 
String entrant = "";
while (LoRa.available()) { 
entrant += (char)LoRa.read(); } 
display.clearDisplay(); 
display.setCursor(0,0); 
display.print(entrant); 
display.display(); 
} 
}

Compréhension du Code

• Des bibliothèques telles que LoRa, Wire, Adafruit_GFX et Adafruit_SSD1306 sont indispensables. Elles gèrent les opérations des modules respectifs.
• La fonction setup de l’émetteur initialise la communication série et le module LoRa. La boucle envoie ensuite un message prédéfini.
• Du côté du récepteur, le code initialise à la fois l’affichage OLED et le module LoRa. Les paquets LoRa entrants sont ensuite lus et affichés sur l’OLED.

Cette configuration, mélangeant l’ESP32, LoRa SX1278 et OLED, donne un aperçu de l’avenir de l’IoT. Elle montre comment différents modules peuvent se combiner pour offrir des solutions de communication à distance en temps réel.

ESP32, LoRa et Serveur Web :

Établissement d’un Serveur Web sur ESP32

La Merveille Numérique : Serveur Web ESP32 Un serveur web sur l’ESP32 ne se limite pas à héberger un site. Il s’agit de représentation de données en temps réel, de contrôle à distance des dispositifs et, souvent, il est le pivot des solutions IoT.

Étapes pour Libérer le Serveur Web

Configuration WiFi : L’ESP32 doit être connecté à un réseau local. Définissez votre SSID et mot de passe.

Initialisation du Serveur Web : Configurez un serveur HTTP sur un port spécifique (généralement 80).

Configuration de la Route : Établissez des chemins ou routes pour accéder à des fonctions ou données spécifiques.

Affichage des Données du Capteur du module LoRa vers le Serveur Web

Côté Émetteur :

Initialisation du Capteur : Commencez par initialiser le capteur pour lire les données (par exemple, DHT11 pour la température et l’humidité).

Configuration LoRa : Configurez le module LoRa pour transmettre des données.

Transmission de Données : Lisez périodiquement les données du capteur, emballez-les et envoyez-les via LoRa.

//Libraries for LoRa
#include <SPI.h>
#include <LoRa.h>
 
//Libraries for LoRa
#include "DHT.h"
#define DHTPIN 4          //pin where the dht11 is connected
DHT dht(DHTPIN, DHT11);
 
//define the pins used by the LoRa transceiver module
#define ss 5
#define rst 14
#define dio0 2
 
#define BAND 433E6    //433E6 for Asia, 866E6 for Europe, 915E6 for North America
 
//packet counter
int readingID = 0;
 
int counter = 0;
String LoRaMessage = "";
 
float temperature = 0;
float humidity = 0;
 
 
 
//Initialize LoRa module
void startLoRA()
{
  LoRa.setPins(ss, rst, dio0); //setup LoRa transceiver module
 
  while (!LoRa.begin(BAND) && counter < 10) {
    Serial.print(".");
    counter++;
    delay(500);
  }
  if (counter == 10) 
  {
    // Increment readingID on every new reading
    readingID++;
    Serial.println("Starting LoRa failed!"); 
  }
  Serial.println("LoRa Initialization OK!");
  delay(2000);
}
 
void startDHT()
{
  if (isnan(humidity) || isnan(temperature)) 
  {
  Serial.println("Failed to read from DHT sensor!");
  return;
  }
}
 
void getReadings(){
  humidity = dht.readHumidity();
  temperature = dht.readTemperature();
  Serial.print(F("Humidity: "));
  Serial.print(humidity);
  Serial.print(F("%  Temperature: "));
  Serial.print(temperature);
  Serial.println(F("°C "));
}
 
void sendReadings() {
  LoRaMessage = String(readingID) + "/" + String(temperature) + "&" + String(humidity) ;
  //Send LoRa packet to receiver
  LoRa.beginPacket();
  LoRa.print(LoRaMessage);
  LoRa.endPacket();
  
  Serial.print("Sending packet: ");
  Serial.println(readingID);
  readingID++;
  Serial.println(LoRaMessage);
}
 
void setup() {
  //initialize Serial Monitor
  Serial.begin(115200);
  dht.begin();
  startDHT();
  startLoRA();
}
void loop() {
  getReadings();
  sendReadings();
  delay(5000);
}

Côté Récepteur : Le Serveur Web ESP32

Configuration LoRa : Initialisez le module LoRa pour recevoir des données.

Configuration du Serveur Web : Utilisez la bibliothèque ESPAsyncWebServer pour configurer le serveur.

Réception & Affichage des Données : Recevez des données de LoRa, analysez-les et affichez-les sur le serveur web.

#include <WiFi.h> 
#include <LoRa.h> 
#include <ESPAsyncWebServer.h> 
AsyncWebServer serveur(80); 
void setup() { 
WiFi.begin("SSID", "MOT_DE_PASSE"); 
while (WiFi.status() != WL_CONNECTED) { 
delay(1000); 
} 
LoRa.begin(433E6); // Initialisez LoRa 
serveur.on("/", HTTP_GET, [](AsyncWebServerRequest *requete){ 
String donnees = recevoirDonneesLoRa(); 
requete->send(200, "text/html", donnees); }); 
serveur.begin(); } 
String recevoirDonneesLoRa() { 
String donnees = ""; 
int tailleDuPaquet = LoRa.parsePacket(); 
if(tailleDuPaquet) { 
while(LoRa.available()) { 
donnees += (char)LoRa.read(); 
} 
} 
return donnees; 
} void loop() 
{ // 
... autres opérations 
}

Affinement de la Présentation des Données sur le Serveur Web

Au-delà de la simple affichage des données, une excellente expérience utilisateur implique la mise en forme et potentiellement la visualisation des données. HTML, CSS, et JavaScript peuvent être intégrés directement dans votre code ESP32 pour créer un tableau de bord interactif et visuellement attrayant.

Bibliothèques et Outils Obligatoires

• WiFi.h : Facilite les opérations WiFi sur l’ESP32.
• LoRa.h : Essentiel pour les opérations LoRa.
• ESPAsyncWebServer.h : Cette bibliothèque permet les fonctionnalités de serveur asynchrone sur l’ESP32. Pour incorporer la bibliothèque ESPAsyncWebServer, assurez-vous d’avoir également installé la bibliothèque “ESPAsyncTCP” requise pour ESP32.

En essence, la fusion de l’ESP32, LoRa, et un serveur web est un témoignage des possibilités illimitées de l’IoT. Cette combinaison permet l’acquisition, la transmission et la visualisation en temps réel des données, le tout intégré dans un écosystème singulier.

Communication LoRa Entre Deux Cartes Arduino Utilisant le SX1278

Mise en Place de la Communication LoRa

Établir une communication LoRa entre deux cartes Arduino tourne autour de deux éléments principaux : l’émetteur et le récepteur. Les deux Arduinos seront équipés du module LoRa SX1278, mais l’un enverra des données, tandis que l’autre écoutera et recevra.

Circuit Émetteur

SX1278 à Arduino

3,3V -> 3,3V

GND -> GND

NSS -> D10

DIO0 -> D2

SCK -> D13

MISO -> D12

MOSI -> D11

RST -> D9

Capteur DHT11

VCC -> 3,3V

GND -> GND

DATA -> A0

Circuit Récepteur

SX1278 à Arduino

3,3V -> 3,3V

GND -> GND

NSS -> D10

DIO0 -> D2

SCK -> D13

MISO -> D12

MOSI -> D11

RST -> D9

Affichage LCD 16×2 (Pour la Visualisation des Données)

Suivez le mappage spécifique des broches de votre module LCD.

Principales Considérations pour SX1278 et Arduino

• Niveaux de Tension : Le SX1278 fonctionne à 3,3V. Le connecter directement à une broche 5V sur Arduino endommagera le module.
• Antenne : Toujours attacher une antenne au module SX1278 avant de l’alimenter pour éviter d’éventuels dommages.
• Bibliothèques : Assurez-vous d’avoir la bibliothèque LoRa requise installée dans votre IDE Arduino pour une intégration sans heurt.

Code Émetteur

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

#define DHTPIN A0
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  LoRa.begin(433E6); // Initialize LoRa at 433MHz
  dht.begin();
}

void loop() {
  float humidity = dht.readHumidity();
  float temperature = dht.readTemperature();

  LoRa.beginPacket();
  LoRa.print("Humidity: ");
  LoRa.print(humidity);
  LoRa.print(" Temperature: ");
  LoRa.print(temperature);
  LoRa.endPacket();

  delay(5000); // Send every 5 seconds
}

Code Récepteur

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

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Adjust based on your LCD's pin configuration

void setup() {
  Serial.begin(9600);
  LoRa.begin(433E6);
  lcd.begin(16, 2);
}

void loop() {
  int packetSize = LoRa.parsePacket();
  if (packetSize) {
    String receivedData = "";
    while (LoRa.available()) {
      receivedData += (char)LoRa.read();
    }
    lcd.setCursor(0, 0);
    lcd.print(receivedData); // Display data on LCD
  }
}

Ce guide offre un plan directeur pour établir un canal de communication LoRa entre deux cartes Arduino utilisant le module SX1278. Suivre attentivement les étapes mentionnées garantit une transmission et une réception de données efficaces avec une interférence minimale.

Conclusion

SX1278, avec son intégration du modem à longue portée LoRa®, a redéfini les normes de communication sans fil en offrant une communication par spectre étalé à ultra-longue portée, une haute immunité aux interférences et une consommation d’énergie minimisée. Sa technique de modulation LoRa brevetée le distingue, garantissant une sensibilité inégalée et le positionnant comme leader dans l’industrie en termes de budget de liaison.

Le module LoRa 433Mhz SX1278 amplifie encore ces avantages, étendant la communication jusqu’à 10 000 mètres tout en conservant de solides capacités anti-brouillage. En essence, pour les applications cherchant un mélange harmonieux de portée, de résilience et d’efficacité énergétique, le SX1278 et ses dérivés s’imposent comme le choix incontestable.

Vidéo descriptive

Liens outilles

1. Téléchargement de l’Arduino IDE : https://www.arduino.cc/en/software
2. GitHub Arduino Repository : https://github.com/arduino/Arduino/
3. Pour découvrir plus de tutoriel, vous pouvez consulter notre bloc : https://www.moussasoft.com/tutoriels-electroniques