Système d’irrigation intelligent IoT basé sur ESP8266 et Lora

Introduction

Le projet vise à créer un système d’irrigation intelligent en utilisant le module Wi-Fi ESP8266, les modules transcepteurs LoRa (Reyax RYLR890), l’Arduino Nano et un capteur d’humidité du sol capacitif . Ce système permet aux utilisateurs de surveiller à distance les niveaux d’humidité du sol sur leur téléphone portable sans dépendre de la connectivité internet. Il utilise la communication radio à longue portée (LoRa) pour transmettre les données sur de longues distances, le rendant adapté aux zones ayant un accès internet limité.

Les composants nécessaires pour le Système d’irrigation intelligent

1. Nodemcu ESP8266 Wi-Fi Module
2. Module transcepteur LoRa Reyax rylr890
3. Arduino Nano
4. Capteur d’humidité du sol capacitif V1.2
5. PCB d’alimentation pour Nodemcu ESP8266
6. PCB d’alimentation pour le module LoRa Reyax
7. Régulateur de tension LM7805
8. Résistances (4.7kΩ et 10kΩ)
9. Condensateurs (470μF)
10. LED
11. Connecteur DC femelle pour l’alimentation
12. Résistance de 330Ω (résistance pour la LED)
13. Fils de connexion et connecteurs pour les interconnexions
14. Boîtier en plastique étanche pour le côté émetteur
15. Application Blynk

Conception du Circuit du Système d’irrigation intelligent

Le circuit du Système d’irrigation intelligent se compose de deux parties : l’émetteur et le récepteur. Côté émetteur, le capteur d’humidité du sol capacitif est connecté à l’ESP8266 Nodemcu, qui envoie ensuite les données via le module LoRa Reyax vers le récepteur distant. Côté récepteur, un autre module LoRa est associé à un Nodemcu, qui reçoit les données du capteur et les transmet à une application Blynk. Le relais connecté au Nodemcu peut être activé ou désactivé à distance en fonction de l’humidité du sol mesurée

Branchement du circuit côté émetteur

1. Alimentation : Tout d’abord, assurez-vous de fournir une alimentation appropriée au circuit côté émetteur. Vous pouvez utiliser une source d’alimentation externe ou une batterie en fonction de vos besoins. Assurez-vous de respecter les tensions requises par les différents composants, en particulier le module LoRa Reyax rylr890 qui nécessite une tension d’alimentation de 2.8V à 3.6V.
2. Capteur d’humidité du sol capacitif : Connectez le capteur d’humidité du sol capacitif V1.2 (DFRobot) à l’Arduino Nano. Branchez la broche GND du capteur au GND de l’Arduino, la broche VCC au 5V de l’Arduino et la broche AOUT au broche analogique A1 de l’Arduino.
3. Module transcepteur LoRa : Connectez le module transcepteur LoRa Reyax rylr890 à l’Arduino Nano. Utilisez un circuit de diviseur de tension composé de résistances de 4.7kΩ et 10kΩ pour abaisser la tension du signal TX de l’Arduino (5V) à la tension requise de 3.3V pour le module LoRa. Connectez le fil du milieu du diviseur de tension à la broche RXD du module LoRa et le fil de sortie du diviseur de tension à la broche TXD du module LoRa. Assurez-vous de connecter les broches VDD et GND du module LoRa à une alimentation de 3.3V et à la masse respectivement.
4. Assemblage final : Une fois tous les composants connectés, vérifiez les connexions pour vous assurer qu’il n’y a pas de court-circuit ou d’erreur de câblage. Une fois que tout est vérifié, vous pouvez procéder à l’assemblage final du circuit côté émetteur dans un boîtier en plastique étanche pour le protéger des intempéries.

Branchement du circuit côté récepteur

1. Alimentation : Tout d’abord, assurez-vous de fournir une alimentation appropriée au circuit côté récepteur. Utilisez un régulateur de tension LM7805 pour abaisser la tension d’alimentation à 5V, qui sera utilisée pour alimenter le Nodemcu ESP8266 Wi-Fi Module.
2. Module transcepteur LoRa : Connectez le module transcepteur LoRa Reyax rylr890 au Nodemcu ESP8266 Wi-Fi Module. Assurez-vous de connecter les broches VDD et GND du module LoRa à une alimentation de 3.3V et à la masse respectivement. Connectez la broche RX du module LoRa à la broche TX du Nodemcu, et la broche TX du module LoRa à la broche RX du Nodemcu.
3. Relais (en option) : Si vous souhaitez contrôler une pompe d’irrigation à distance, vous pouvez connecter un relais au Nodemcu ESP8266. Branchez la broche de commande du relais à une broche de sortie du Nodemcu et assurez-vous de le configurer correctement dans le code pour activer ou désactiver la pompe en fonction des niveaux d’humidité du sol reçus.
4. Assemblage final : Vérifiez les connexions pour vous assurer qu’il n’y a pas de court-circuit ou d’erreur de câblage. Une fois que tout est vérifié, vous pouvez procéder à l’assemblage final du circuit côté récepteur et le placer dans un boîtier pour une utilisation en extérieur ou en intérieur selon vos besoins.

Programmation du côté émetteur

Voici le code du circuit émetteur :

int Capacitive_Soil_Moisture_Sensor = A1;
int Soil_Moisture_Sensor_data = 0;

int data_length;
String sensorsdata;

void setup() {
  Serial.begin(115200);
  pinMode(Capacitive_Soil_Moisture_Sensor, INPUT);
}

void loop() {
  MultipleSensors();
  send_data(sensorsdata, data_length);
  delay(1000);
  sensorsdata = "";
}

void MultipleSensors() {
  Soil_Moisture_Sensor_data = analogRead(Capacitive_Soil_Moisture_Sensor);
  sensorsdata = sensorsdata + Soil_Moisture_Sensor_data + "%";
  data_length = sensorsdata.length();
}

void send_data(String sensorvalue, int valuelength) {
  String mymessage;
  mymessage = mymessage + "AT+SEND=0" + "," + valuelength + "," + sensorvalue + "\r";
  Serial.println(mymessage);
}

Explication du code

1. Les déclarations des variables : Le code commence par déclarer les variables utilisées dans le programme, telles que Capacitive_Soil_Moisture_Sensor pour définir la broche à laquelle le capteur d’humidité du sol capacitif est connecté, et Soil_Moisture_Sensor_data pour stocker la valeur lue à partir du capteur.
2. Configuration initiale : Dans la fonction setup(), nous initialisons la communication série à une vitesse de 115200 bauds et définissons la broche du capteur d’humidité du sol comme une entrée.
3. Boucle principale : La fonction loop() est la boucle principale du programme, qui s’exécute en boucle de manière répétée.
4. Fonction MultipleSensors() : Cette fonction est utilisée pour lire la valeur d’humidité du sol à partir du capteur capacitif. La valeur est lue à l’aide de la fonction analogRead() et est ensuite ajoutée à la variable sensorsdata sous forme de chaîne, suivie du symbole “%”. Cette chaîne contiendra les données d’humidité collectées à partir du capteur.
5. Fonction send_data() : Cette fonction est utilisée pour envoyer les données d’humidité collectées via la communication LoRa. Elle crée une chaîne de message mymessage qui contient les informations nécessaires pour l’envoi de données, telles que la longueur des données (valuelength) et les données elles-mêmes (sensorvalue). Le message est ensuite imprimé sur le port série à l’aide de Serial.println().

Programmation du côté récepteur

// Inclusion des bibliothèques nécessaires
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <SoftwareSerial.h>
#include <SimpleTimer.h>

// Identifiant d'authentification Blynk
char auth[] = "LnMZlB1ZiT1kgYW1uGgc-yiPflg6BRav";

// Informations de connexion Wi-Fi
char ssid[] = "AndroidAP7DF8"; // Remplacez par le nom de votre réseau Wi-Fi
char pass[] = "jamshaid";     // Remplacez par le mot de passe de votre réseau Wi-Fi

// Déclaration des broches et variables
SimpleTimer timer;
String myString;
String garbage;
char data;
int firstVal; // Valeur du capteur, reçue depuis l'émetteur.
int soilflag = 0; // Permet d'éviter les répétitions inutiles du code.
int relay = D0; // Vous pouvez connecter un relais ici.
int relayf = 0; // Drapeau du relais

void setup() {
  Serial.begin(115200);
  pinMode(relay, OUTPUT);
  digitalWrite(relay, LOW);

  // Initialisation de la connexion Blynk
  Blynk.begin(auth, ssid, pass);

  // Configuration des intervalles de temps
  timer.setInterval(1000L, sensorvalue1);
  timer.setInterval(1000L, Receivedata);
}

void loop() {
  Blynk.run();
  timer.run(); // Initie BlynkTimer
}

void Receivedata() {
  if (Serial.available() > 0) {
    garbage = Serial.readString(); // Contient l'erreur "+ERR=2 ERROR".

    myString = Serial.readString();

    // Extraction des différentes valeurs du message reçu
    String l = getValue(myString, ',', 0); // Adresse
    String m = getValue(myString, ',', 1); // Longueur des données
    String n = getValue(myString, ',', 2); // Données
    String o = getValue(myString, ',', 3); // RSSI (Indicateur de force du signal reçu)
    String p = getValue(myString, ',', 4); // SNR (Rapport signal/bruit)

    // Extraction des valeurs du capteur d'humidité du sol
    String q = getValue(n, '%', 0); // Capteur1

    // Conversion de la valeur du capteur en entier
    firstVal = q.toInt();

    // Contrôle du relais en fonction des valeurs du capteur reçues
    if ((firstVal <= 20) && (relayf == 0)) {
      digitalWrite(relay, HIGH);
      relayf = 1;
    }

    if ((firstVal >= 30) && (relayf == 1)) {
      digitalWrite(relay, LOW);
      relayf = 0;
    }

    myString = "";
  }
}

void sensorvalue1() {
  int sdata = firstVal;

  // Envoi de la valeur du capteur au widget Blynk Virtual Pin V2
  Blynk.virtualWrite(V2, sdata);

  // Notification en fonction du niveau d'humidité du sol
  if ((sdata <= 100) && (soilflag == 0)) {
    Blynk.notify("Besoin d'eau");
    soilflag = 1;
  }

  if ((sdata >= 900) && (soilflag == 1)) {
    Blynk.notify("L'humidité du sol est bonne");
    soilflag = 0;
  }
}

// Fonction pour extraire les valeurs de la chaîne de données reçue
String getValue(String data, char separator, int index) {
  int found = 0;
  int strIndex[] = {0, -1};
  int maxIndex = data.length() - 1;

  for (int i = 0; i <= maxIndex && found <= index; i++) {
    if (data.charAt(i) == separator || i == maxIndex) {
      found++;
      strIndex[0] = strIndex[1] + 1;
      strIndex[1] = (i == maxIndex) ? i + 1 : i;
    }
  }

  return found > index ? data.substring(strIndex[0], strIndex[1]) : "";
}

Explication du code

1. Inclusion des bibliothèques : Le code commence par inclure les bibliothèques nécessaires pour la communication Wi-Fi avec Blynk, la communication série et le gestionnaire de minuterie.
2. Déclarations : Les variables, broches et autres éléments nécessaires sont déclarés.
3. Configuration initiale : Dans la fonction setup(), nous initialisons la communication série, la broche du relais et nous établissons la connexion Wi-Fi avec Blynk.
4. Boucle principale : La fonction loop() s’occupe de l’exécution continue de Blynk et du gestionnaire de minuterie.
5. Fonction Receivedata() : Cette fonction est utilisée pour recevoir les données d’humidité du sol transmises par le circuit émetteur via la communication série. Les données reçues sont ensuite traitées pour extraire la valeur du capteur d’humidité du sol. En fonction de cette valeur, le relais est contrôlé pour l’arrosage automatique et des notifications Blynk sont envoyées pour informer l’utilisateur du niveau d’humidité du sol.
6. Fonction sensorvalue1() : Cette fonction est utilisée pour envoyer la valeur du capteur d’humidité du sol au widget Blynk Virtual Pin V2. Elle envoie également des notifications lorsque le niveau d’humidité atteint certains seuils prédéfinis.
7. Fonction getValue() : Cette fonction est utilisée pour extraire les différentes valeurs à partir de la chaîne de données reçue. Elle divise la chaîne en utilisant le séparateur (“,”) et renvoie la valeur souhaitée en fonction de l’index spécifié.

Application Blynk

L’application Blynk joue un rôle essentiel dans notre système d’irrigation intelligent, permettant aux utilisateurs de surveiller les données en temps réel et de contrôler l’irrigation à distance. Nous avons conçu une interface utilisateur conviviale comprenant un indicateur de l’humidité du sol et des notifications d’alerte pour les besoins en irrigation. Blynk nous permet également d’accéder aux données historiques et de les analyser pour optimiser l’utilisation de l’eau et améliorer l’efficacité de l’irrigation.

Assurez-vous d’avoir installé l’application Blynk sur votre téléphone portable. Créez un projet Blynk, obtenez l’identifiant d’authentification (auth token) et configurez les widgets pour afficher les données de l’humidité du sol.

Lien outilles

Pour découvrir plus de tutoriel, vous pouvez consulter notre bloc : https://www.moussasoft.com/tutoriels-electroniques

Téléchargement de l’Arduino IDE : https://www.arduino.cc/en/software