Agriculture intelligente connectée à IoT en utilisant l’Arduino

Arduino UNO 16-12-24

20 0

Plan de tutoriel

1- Présenter l'agriculture intelligente connectée à IoT ?

2- L'objectif du projet à réaliser

3- Matériel nécessaire

4- Schéma de câblage du système

5- Programmation de la carte Arduino

Présenter l'agriculture intelligente connectée à IoT ?

L’agriculture intelligente connectée à l’Internet des Objets (IoT) est une approche moderne de l’agriculture qui intègre des technologies avancées pour optimiser les processus agricoles. Elle repose sur l'utilisation de capteurs, de dispositifs connectés, de données en temps réel et d'automatisation pour améliorer la production agricole, réduire les ressources utilisées et augmenter l'efficacité.

Composantes de l’Agriculture Intelligente avec IoT

1- Capteurs :

Mesurent des variables comme l’humidité du sol, la température, la lumière, la qualité de l’air ou les niveaux de nutriments.

Exemples : capteurs d’humidité du sol, capteurs climatiques.

2- Actuateurs et Systèmes Connectés :

Machines automatisées pour arroser, fertiliser, ou activer des systèmes de ventilation ou d’éclairage.

Exemples : systèmes d’irrigation intelligents, drones agricoles.

3- Réseaux de Communication :

Les données collectées par les capteurs sont transmises via des réseaux tels que Wi-Fi, Bluetooth, Zigbee ou des technologies longue portée (LoRa, NB-IoT).

4- Plateformes Cloud et Big Data :

Les données collectées sont stockées sur des serveurs cloud où elles sont analysées grâce à des algorithmes d’apprentissage automatique (IA).

Exemples : plateformes de gestion agricole (Farm Management Software).

5- Applications Mobiles et Interfaces :

Permettent aux agriculteurs de visualiser les données en temps réel et de prendre des décisions, voire de commander des actions à distance.

Avantages de l’Agriculture Intelligente avec IoT

Efficacité accrue : Utilisation optimisée des ressources (eau, engrais, pesticides).

Réduction des coûts : Moins de gaspillage grâce à des systèmes précis et automatisés.

Amélioration des rendements : Meilleure gestion des cultures et conditions environnementales.

Surveillance en temps réel : Les agriculteurs peuvent réagir immédiatement aux problèmes.

Adaptabilité aux changements climatiques : Prévisions précises et ajustements automatiques.

Traçabilité : Suivi complet des étapes de production pour une agriculture plus durable et transparente.

L'agriculture intelligente connectée à IoT est une révolution dans la manière de produire des aliments. Elle offre des solutions innovantes pour répondre aux défis de la sécurité alimentaire mondiale, tout en réduisant l'impact environnemental. Cependant, pour une adoption à grande échelle, il est essentiel de surmonter les défis liés aux coûts et à la connectivité dans les zones rurales.

L'objectif du projet à réaliser

L'objectif principal de l'agriculture intelligente connectée à l'IoT utilisant l'Arduino UNO, le module Wi-Fi ESP8266, un capteur d'humidité du sol et la plateforme ThingSpeak est de surveiller et automatiser l'irrigation agricole en temps réel tout en collectant et en analysant des données pour une gestion optimale des ressources. Cette solution permet d'optimiser l'utilisation de l'eau, de réduire les coûts opérationnels et d'améliorer la productivité agricole.

Objectifs détaillés :

1. Surveillance en temps réel des conditions du sol

Utiliser un capteur d'humidité du sol pour mesurer le niveau d'humidité en temps réel.

Transmettre les données mesurées par l'Arduino via le module ESP8266 à la plateforme cloud ThingSpeak.

Permettre aux utilisateurs (agriculteurs ou gestionnaires) de consulter les données via des graphiques ou une application, facilitant la prise de décision.

2. Automatisation de l’irrigation

Contrôler automatiquement un système d’irrigation (pompe à eau ou vanne) basé sur les données collectées :

a) Si le niveau d'humidité du sol est inférieur à un seuil critique, la pompe s'allume automatiquement.

b) Si le sol est suffisamment humide, l'irrigation s'arrête pour éviter le gaspillage.

3. Collecte et analyse des données sur la plateforme ThingSpeak

Envoyer les données d'humidité du sol vers ThingSpeak, une plateforme IoT pour :

a) Stocker et visualiser les données historiques.

b) Effectuer des analyses prédictives (comme identifier des tendances d'humidité dans le temps).

c) Générer des alertes ou des notifications basées sur les seuils définis.

4. Contrôle et supervision à distance

Permettre à l'utilisateur de :

a) Surveiller les données depuis n'importe quel endroit via une interface web ou mobile.

b) Commander manuellement le système d'irrigation (par exemple, activer ou désactiver la pompe) depuis l'application ThingSpeak.

5. Optimisation de l’utilisation des ressources

a) Réduire la consommation d'eau en fournissant la quantité exacte nécessaire pour maintenir les cultures en bonne santé.

b) Éviter la surcharge des sols (qui peut entraîner des maladies ou un gaspillage d'eau).

6. Facilité d’intégration et d’évolutivité

Le système peut être étendu pour inclure d'autres capteurs (température, lumière, humidité de l'air) ou équipements (fertilisateurs automatiques, capteurs météo).

Matériel nécessaire

Arduino UNO

Arduino Uno

Contrôleur principal pour lire les données du capteur et envoyer des commandes.

1- Il lit les données fournies par le capteur d'humidité du sol.

2- Il traite les données pour déterminer si une action (comme activer une pompe à eau) est nécessaire.

3- Il communique avec le module ESP8266 pour transmettre les données à la plateforme ThingSpeak.

ESP8266 (module Wi-Fi)

Le ESP8266 est un module Wi-Fi à faible coût, très populaire dans les applications IoT. Il permet à l’Arduino UNO de se connecter à un réseau Wi-Fi et de communiquer avec une plateforme cloud comme ThingSpeak.

Il transmet les données collectées par l’Arduino UNO à ThingSpeak via Internet.

Capteur d’humidité du sol

Il mesure le niveau d'humidité dans le sol. Il utilise deux électrodes qui détectent la conductivité du sol, celle-ci variant selon la teneur en eau et fournit une mesure analogique ou numérique indiquant le niveau d'humidité dans le sol.

Plateforme ThingSpeak

ThingSpeak est une plateforme IoT basée sur le cloud qui permet de collecter, stocker, analyser et visualiser des données en temps réel provenant de capteurs connectés.

ThingSpeak Stocke les données d’humidité du sol envoyées par le module ESP8266.

Il fournit des graphiques en temps réel pour la visualisation des données.

Il Permet le contrôle à distance via des commandes retournées à l’Arduino (par exemple, activer la pompe à eau manuellement depuis une interface web).

Câble de connexion

Fils de connexion

Vous aurez besoin d'un câble pour connecter le capteur de sol et le module Wifi ESP826 à la carte Arduino UNO.

Plaque d'essai (Breadboard) :

plaque d'essai

On utilise la plaque d'essai pour faciliter le câblage des différents composants.

Schéma de câblage du système

Pour réaliser le montage, on peut connecter:

pour le capteur du sol :

la broche S à la broche A0 de la carte Arduino

la broche (+) à la broche 3.3V de la carte Arduino

la broche (-) à la broche GND de la carte Arduino

Pour le module ESP8266, on connecte:

La broche RX à la broche 4 de la carte Arduino

La broche TX à la broche 3 de la carte Arduino

La broche GND au GND de la carte Arduino

Les deux broches 3V3 et EN à la broche 5V du module de l’alimentation

La broche RST à la broche 8 de la carte Arduino

Programmation de la carte Arduino

Voici un exemple simplifié du code Arduino pour ce système :

#include <Adafruit_ESP8266.h>
#include <SoftwareSerial.h>

#define ESP_RX 3
#define ESP_TX 4
#define ESP_RST 8
SoftwareSerial softser(ESP_RX, ESP_TX);

// Must declare output stream before Adafruit_ESP8266 constructor; can be
// a SoftwareSerial stream, or Serial/Serial1/etc. for UART.
Adafruit_ESP8266 wifi(&softser, &Serial, ESP_RST);
// Must call begin() on the stream(s) before using Adafruit_ESP8266 object.

#define ESP_SSID "**************" // Your network name here
#define ESP_PASS "*************" // Your network password here

String API = "*******************"; // CHANGE ME
#define HOST "api.thingspeak.com" // Find/Google your email provider's SMTP outgoing server name for unencrypted email

#define PORT 80 // Find/Google your email provider's SMTP outgoing port for unencrypted email
String field = "field1";
int count = 0; // we'll use this int to keep track of which command we need to send next
bool send_flag = false; // we'll use this flag to know when to send the email commands
#define SOLPIN 5 // // pour le capteur de l’humidité du sol
int analogVal;

void setup() {
char buffer[50];

// This might work with other firmware versions (no guarantees)
// by providing a string to ID the tail end of the boot message:

// comment/replace this if you are using something other than v 0.9.2.4!
wifi.setBootMarker(F("Version:0.9.2.4]\r\n\r\nready"));

softser.begin(9600); // Soft serial connection to ESP8266
Serial.begin(57600); while(!Serial); // UART serial debug

// Test if module is ready
Serial.print(F("Hard reset..."));
if(!wifi.hardReset()) {
Serial.println(F("no response from module."));
for(;;);
}
Serial.println(F("OK."));

Serial.print(F("Soft reset..."));
if(!wifi.softReset()) {
Serial.println(F("no response from module."));
for(;;);
}
Serial.println(F("OK."));

Serial.print(F("Checking firmware version..."));
wifi.println(F("AT+GMR"));
if(wifi.readLine(buffer, sizeof(buffer))) {
Serial.println(buffer);
wifi.find(); // Discard the 'OK' that follows
} else {
Serial.println(F("error"));
}

Serial.print(F("Connecting to WiFi..."));
if(wifi.connectToAP(F(ESP_SSID), F(ESP_PASS))) {

// IP addr check isn't part of library yet, but
// we can manually request and place in a string.
Serial.print(F("OK\nChecking IP addr..."));
wifi.println(F("AT+CIFSR"));
if(wifi.readLine(buffer, sizeof(buffer))) {
Serial.println(buffer);
wifi.find(); // Discard the 'OK' that follows

Serial.print(F("Connecting to host..."));

Serial.print("Connected..");
wifi.println("AT+CIPMUX=0"); // configure for single connection,
//we should only be connected to one SMTP server
wifi.find();
wifi.closeTCP(); // close any open TCP connections
wifi.find();
Serial.println("Type \"send it\" to send an email");

} else { // IP addr check failed
Serial.println(F("error"));
}
} else { // WiFi connection failed
Serial.println(F("FAIL"));
}
}

void loop() {
send_flag = true;
if(send_flag){ // the send_flat is set, this means we are or need to start sending SMTP commands
if(do_next()){ // execute the next command
count++; // increment the count so that the next command will be executed next time.
}
}
}

boolean do_next()
{
switch(count){
case 0:
Serial.println("Connecting...");
return wifi.connectTCP(F(HOST), PORT);
break;
case 1:
analogVal = analogRead(SOLPIN); // lecture de l'humdité du sol
char charVal2[100];
char charVal1[100]="GET /update?api_key=KM7MYIGX8G2X6GA0&field1=";
itoa(analogVal, charVal2, 10);
//dtostrf(analogVal, 4, 2, charVal2);
strcat(charVal1,charVal2);
return wifi.cipSend(charVal1); // Envoi des données au site Thinkspeak
delay(60000);
}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

#include <Adafruit_ESP8266.h>

#include <SoftwareSerial.h>

#define ESP_RX 3

#define ESP_TX 4

#define ESP_RST 8

SoftwareSerial softser(ESP_RX, ESP_TX);

// Must declare output stream before Adafruit_ESP8266 constructor; can be

// a SoftwareSerial stream, or Serial/Serial1/etc. for UART.

Adafruit_ESP8266 wifi(&softser, &Serial, ESP_RST);

// Must call begin() on the stream(s) before using Adafruit_ESP8266 object.

#define ESP_SSID "**************" // Your network name here

#define ESP_PASS "*************" // Your network password here

String API = "*******************"; // CHANGE ME

#define HOST "api.thingspeak.com" // Find/Google your email provider's SMTP outgoing server name for unencrypted email

#define PORT 80 // Find/Google your email provider's SMTP outgoing port for unencrypted email

String field = "field1";

int count = 0; // we'll use this int to keep track of which command we need to send next

bool send_flag = false; // we'll use this flag to know when to send the email commands

#define SOLPIN 5 // // pour le capteur de l’humidité du sol

int analogVal;

void setup() {

char buffer[50];

// This might work with other firmware versions (no guarantees)

// by providing a string to ID the tail end of the boot message:

// comment/replace this if you are using something other than v 0.9.2.4!

wifi.setBootMarker(F("Version:0.9.2.4]\r\n\r\nready"));

softser.begin(9600); // Soft serial connection to ESP8266

Serial.begin(57600); while(!Serial); // UART serial debug

// Test if module is ready

Serial.print(F("Hard reset..."));

if(!wifi.hardReset()) {

Serial.println(F("no response from module."));

for(;;);

}

Serial.println(F("OK."));

Serial.print(F("Soft reset..."));

if(!wifi.softReset()) {

Serial.println(F("no response from module."));

for(;;);

}

Serial.println(F("OK."));

Serial.print(F("Checking firmware version..."));

wifi.println(F("AT+GMR"));

if(wifi.readLine(buffer, sizeof(buffer))) {

Serial.println(buffer);

wifi.find(); // Discard the 'OK' that follows

} else {

Serial.println(F("error"));

}

Serial.print(F("Connecting to WiFi..."));

if(wifi.connectToAP(F(ESP_SSID), F(ESP_PASS))) {

// IP addr check isn't part of library yet, but

// we can manually request and place in a string.

Serial.print(F("OK\nChecking IP addr..."));

wifi.println(F("AT+CIFSR"));

if(wifi.readLine(buffer, sizeof(buffer))) {

Serial.println(buffer);

wifi.find(); // Discard the 'OK' that follows

Serial.print(F("Connecting to host..."));

Serial.print("Connected..");

wifi.println("AT+CIPMUX=0"); // configure for single connection,

//we should only be connected to one SMTP server

wifi.find();

wifi.closeTCP(); // close any open TCP connections

wifi.find();

Serial.println("Type \"send it\" to send an email");

} else { // IP addr check failed

Serial.println(F("error"));

}

} else { // WiFi connection failed

Serial.println(F("FAIL"));

}

void loop() {

send_flag = true;

if(send_flag){ // the send_flat is set, this means we are or need to start sending SMTP commands

if(do_next()){ // execute the next command

count++; // increment the count so that the next command will be executed next time.

}

boolean do_next()

{

switch(count){

case 0:

Serial.println("Connecting...");

return wifi.connectTCP(F(HOST), PORT);

break;

case 1:

analogVal = analogRead(SOLPIN); // lecture de l'humdité du sol

char charVal2[100];

char charVal1[100]="GET /update?api_key=KM7MYIGX8G2X6GA0&field1=";

itoa(analogVal, charVal2, 10);

//dtostrf(analogVal, 4, 2, charVal2);

strcat(charVal1,charVal2);

return wifi.cipSend(charVal1); // Envoi des données au site Thinkspeak

delay(60000);

}

A l'exécution de ce programme, les valeurs de l'humidité du sol envoyées par la carte Arduino au site thinkspeak.com.

Avec ce système, les agriculteurs peuvent :

Surveiller les conditions du sol en temps réel.

Automatiser l’irrigation en fonction des données précises.

Consulter les données historiques et optimiser les stratégies agricoles.

Contrôler l’irrigation à distance via ThingSpeak, réduisant ainsi les efforts manuels et les ressources gaspillées.

Ce projet constitue une solution pratique et économique pour moderniser les pratiques agricoles, en particulier dans les régions où l'accès à l'eau doit être géré de manière efficace.