Gestionnaire automatique d une serre

(1)

UNIVERSITE CADI AYYAD

Faculté des Sciences et Technique-Marrakech

Projet de Fin d’études

Présenté en vue de l’obtention du diplôme de Licence Professionnelle Universitaire

Maintenance Industriel en Génie Electrique Promotion : 2019-2020

Responsable de la Formation Le Professeur:

Dr. DOUBABI Saïd Encadré par Le Professeur :

Dr. ELBEID

Réaliser par :

Mr. BOUGRINE Abdelhak

Intitulé :

Gestionnaire automatique d’une serre

(2)

REMERCIEMENT

Tout d’abord, je remercie Allah, le tout puissant qui m’a donné la volonté, la force et la patience pour élaborer mon

travail de stage.

Mes vifs remerciements au Responsable de la formation le Professeur Mr DOUBABI Saïd pour ses orientations bénéfiques

et objectives pour la réalisation de la formation

Mes remerciements vont également à mon encadreur le Professeur Mr ELBEID pour son aide précieuse, ses conseils constructifs et ses orientations bénéfiques et objectives pour la

réalisation de ce projet de fin de d’études.

À cette occasion pour adresser tous nos remerciements au corps professeurs de FSTG et surtout du département

maintenance industriel en gène électrique.

Enfin, je tiens à exprimer ma reconnaissance à tous nos amis et collègues pour leur soutien moral. Merci à tous !

(3)

Dédicace

Je dédie ce modeste travail :

A mes très chers parents qui m’ont aidé et m’ont encouragé durant toutes mes études A toute ma famille,

A mes chers frères et sœurs,

A tous mes amis, avec lesquels j’ai partagé mes meilleurs moments.

Que dieu leur accorde santé et prospérité.

BOUGRINE Abdelhak

(4)

Table des matières

Introduction………..6

Définition d’un système Embarqué ……….6

Caractéristiques principales d’un SE ………6

Chapitre I : Généralités sur les serres automatisées

Capteurs utilisé………7

Actionneurs utilisé………7

Le module Arduino………..8

Représentation du système………..9

Etude du système……….9

Eclairage………..9

Température……….9

Humidité………10

Schéma grossier de notre système global……….11

Chapitre II : Réalisation et Implémentation d’une Serre Automatique

Cahier des charges……….12

La gestion d’irrigation………. 12

Sous système de détection de niveau et remplissage du réservoir……….12

Détecteurs de niveau………...14

LEDs indicatrices………..14

Chronogramme du système……….14

Câblage des composants………15

Programme principal……….16

Mise en marche de la pompe et son indicateur SetPompe()………16

Activation des voyants H et B SetLED()………16

Programmation d’un état………17

Problème de démarrage………18

Programme principal………18

Résultat de simulation durant le remplissage du réservoir………..19

(5)

Sous système d’irrigation………..19

Montages et composition du système……….19

Etalonnage du capteur d’humidité du sol………..20

Traçage de la courbe des valeurs mesurées……….22

Pompe d’Arrosage………..22

Électrovanne………..23

Le module relais………..23

Montage du sous-système d’irrigation………24

Diagramme du programme du sous-système d’irrigation……….24

Programme du sous-programme d’irrigation……….26

La gestion de luminosité……….………..28

Montage et composition du système……….……….28

Montage du sous-système……….……….29

Diagramme du programme du système de gestion d’éclairage……….29

Le programme………..31

Résultat de simulation du système d’éclairage……….31

La gestion de température………..32

Composition et montage du système………..32

Montage du système de gestion de température………33

Diagramme du programme……….34

Résultats de simulation………..36

Chapitre III : Système de connexion à internet et Programme globale

Système de connexion à internet………37

Composant et montage du système……….37

Programme globale………..41

Programmation………41

La configuration……….41

Programme globale qui gère de la serre ………...42

Conclusion………...46

Bibliographie………..47

(6)

Introduction Générale

Selon l'Organisation des Nations Unies (ONU), le « principal facteur à l'origine de l'augmentation des besoins alimentaires ». Selon l'Organisation des Nations Unies pour l'alimentation et l'agriculture (FAO), la population mondiale devrait atteindre 9,6 milliards d'habitants d'ici 2050. Il sera donc difficile pour le secteur agricole de répondre aux besoins de la population vivant de l'alimentation.

Aujourd'hui, une autre difficulté que le secteur agricole doit faire face relative aux conditions météorologiques instables et le réchauffement de la planète qui a un impact négatif sur les cultures.

Les scientifiques cherchent des techniques et des moyens répondant aux besoins alimentaires

suffisants et allants au-delà des menaces du changement climatique. L'agriculture intelligente utilise des technologies avancées telles que l’utilisation des technologies de la communication de

l’information (TIC), Big Data, l'Internet des objets(IoT), réseaux de capteurs, stations météo

connectées au réseau etc. Elle facilite l'automatisation de l'agriculture, la collecte des données sur le terrain et les analyses afin que les agriculteurs puissent prendre une décision précise en matière de production de cultures de haute qualité.

Dans ce Projet, nous parlons de l'agriculture intelligente en générale et des serres intelligentes en particulier, Nous allons automatiser les différents processus d’acquisition de données (températures, humidité, ensoleillement, …etc) grâce à un réseau de capteur, ainsi que les processus d’actions (chauffage, irrigation, éclairage, ventilation…etc) grâce à un réseau d’actionneurs. Les capteur et actionneurs sont connectés à une carte Arduino pour le stockage et la gestion de données. Notre objectif est de rendre la serre agricole autonome et la doté d’un système intelligent capable de prendre des décisions. Une fois connectée à internet, la serre pourra à Recueillir les données métrologiques et décider en fonction de ces données d’irriguer ou de ventiler ou de chauffer etc On peut considérer une serre agricole automatisé comme un système embarqué.

Définition d’un système Embarqué :

Il peut être défini comme un système électronique et informatique autonome, qui est dédié à une tâche bien précise, caractérisé par : D'espace compté, de petite consommation énergétique et

temporelle.

Caractéristiques principales d’un SE :

Exécute un logiciel dédié à des fonctionnalités bien précises, qui est en partie ou entièrement programmé dans le matériel (firmware), Dispose de ressources limitées. Cette limitation est

généralement d'ordre spatial (encombrement réduit) et énergétique (consommation restreinte), C'est un système principalement ne possède pas d’entrées/sorties standards tels qu’un port série RS232, USB, … etc et de périphériques classiques comme un clavier d’ordinateur (possède périphériques limités : des boutons poussoir, clavier matriciel …) ou un écran d'ordinateur (affichage limité ou aucun affichage : LED, écran LCD, ….etc),C'est un système principalement numérique Possède généralement un fonctionnement en temps réel , Il est généralement ouvert au monde extérieur pour des mises à jour ou pour communiquer mais ce n'est pas indispensable Dans certaines applications, Il a un fonctionnement sûr pour ne pas mettre en péril des vies humaines ou en danger des

investissements importants.

(7)

Chapitre I: Généralités sur les serres automatisées

Dans ce chapitre nous présentons les outils matériels et ainsi que les différentes études du système.

Capteurs utilisé :

Nous avons utilisé quatre types de capteurs, qui sont résumés dans le tableau suivent :

Capteurs Description

capteur de température et

d'humidité : DHT11

Ce module utilisé en tant que nœud

d'acquisition de température et d'humidité pour notre projet

Capteur de luminosité: LDR

Une photorésistance est un composant dont la valeur en ohms dépend de la lumière à laquelle elle est exposée

Capteur d’humidité du sol

Capteur sensible à l’humidité ambiante et détecte la teneur en humidité du sol. module de sortie AO et AD analogique connecté par l’intermédiaire du convertisseur AD, vous pouvez obtenir des valeurs plus précises de l’humidité du sol.

Détecteur de niveau d’eau

Est un capteur muni d’un flotteur qui gère la détection, plusieurs sondes sont placées verticalement aux niveaux seuils souhaités.

Lorsque le niveau monte, le liquide arrive au flotteur, un courant électrique s'établit alors, indiquant que le liquide vient d'arriver au niveau seuil.

Tableau I-1 : Capteurs utilisés

Actionneurs utilisé :

Nous avons utilisé les actionneurs qui sont résumés dans le tableau suivent :

(8)

actionneurs Description

électrovanne :

Installation une électrovanne afin de bloquer l’eau

pompe d’Arrosage

Elle pompe l’eau du réservoir vers les plantes si elle est mise sous tension

pompe électrique pour le contrôle à distance

Pompe Remplissage de

Reservoir

Elle remplir le réservoir,

pompe électrique pour le contrôle à distance

.

Ventilateur de Refroidissement

Les ventilateurs extracteurs permettent de forcer l'aération dans la serre lorsque la ventilation naturelle à travers les ouvrants du toit et/ou du périmètre ne permet pas d'atteindre le taux de renouvellement d'air désiré.

.

Chauffage d’air

Un air chaud :

joue un roule d’élévateur de température

lampe

Nous avons utilisée lampes à LED de 220 V spécifique pour éclairer la serre.

Tableau I-2 : Actionneurs utilisés

Le module Arduino :

Le module Arduino est un circuit imprimé en matériel libre (plateforme de contrôle dont les plans de la carte elle-même sont publiés en licence libre dont certains composants de la carte : comme le microcontrôleur et les composants complémentaires qui ne sont pas en licence libre. Un

microcontrôleur programmé peut analyser et produire des signaux électriques de manière à effectuer des tâches très diverses. Arduino est utilisé dans beaucoup d'applications comme l'électrotechnique industrielle et embarquée ; le modélisme, la domotique mais aussi dans les domaines différents comme l'art contemporain et le pilotage d'un robot, commande des moteurs et faire des jeux de lumières, communiquer avec l'ordinateur, commander des appareils mobiles (modélisme). Chaque

(9)

module d’Arduino possède un régulateur de tension +5 V et un oscillateur à quartez 16 MHz (ou un résonateur céramique dans certains modèles). Pour

Programmer cette carte, on utilise l’logiciel ID Arduino

Figure I-1 : Carte Arduino

Représentation du système :

Chaque serre agricole doit être équipée d’un système qui va contrôler les paramètres climatiques et lumière, ce système doit contrôler la température et l’humidité et lumière, ce sont les variables les plus importantes à contrôler du point de vue de la survie et de la croissance des plantes.

A partir du cahier des charges, nous devions trouver des solutions pour résoudre tous les problèmes techniques.

Etude du système :

L’étude du notre système est divisé en Trois parties :

 Luminosité.

 Température.

 Humidité.

Eclairage :

Le contrôle de la lumière peut concerner les actions suivantes :

 Renforcement de l'éclairage : Durant les courtes journées d’hiver ou dans les zones très nuageuses, un éclairage Supplémentaire est requis. Le renforcement de l'éclairage peut être réalisé par une source supplémentaire d'éclairage basé sur des lampes électriques ou par la lumière réfléchie du soleil. La lumière réfléchie est surtout important dans le cas des jardins urbains.

 Réduction de l'éclairage : s'il y a trop de lumière dans la serre, on peut la diminuer.

Température :

(10)

Température

<15°

Commander un chauffage

La température de notre serre doit être comprise entre 15°C et 30°C pour une bonne croissance des plantes (germination Tomate). Si la température atteint 30°C et plus, l’alarme sonore va être

déclenchée, et la serre est commandée par moteur permettant une ventilation, sinon un chauffage électrique sera allumé automatiquement dés que la température est en dessous d’une

Valeur minimale fixé à 15°C.

Figure I-2 : Logigramme de fonctionnement de la température.

Humidité :

La partie d’humidité de notre système est un autre type principal climatique, qui protège les

occupants d’un milieu très humide ou bien trop sec. Si l’humidité descend sous un seuil, le système doit déclencher un arrosage automatique.

Début

Température °C

Température

>30°

Ouverture des toits (option) Ventilation

Déclencher L’alarme

(11)

Figure I-3 : Logigramme d’humidité.

Schéma grossier de notre système global :

Figure I-4 : Schéma grossier de système global Début

Humidité [100%]

Humidité

< 60%

Humidité

> 60%

Arrosage automatique

Ventilation naturelle

(12)

Chapitre II: Réalisation et Implémentation d’une Serre Automatique :

Dans ce chapitre nous présentons environnements logiciels utilisés pour développer notre système et ainsi que les différentes plateformes d'exécution de ses différentes parties

Cahier des charges :



germination Tomate

 Le système doit contrôler la température et le taux d’humidité de la serre

 La température de la serre doit être comprise entre 15°C et 30°C.

 Le taux d’humidité ne doit pas descendre en dessous de 60%

 Le système doit commander un chauffage électrique pour que la température ne descende pas au dessous d’une valeur maximale fixée.

 Le système doit déclencher une alarme sonore si la température et le taux d’humidité ne sont pas dans la plage de fonctionnement normale.

 Le système doit déclencher un système d’arrosage pour maintenir un taux d’humidité fixé.

 Le système doit commander un moteur permettant une ventilation dés que la consigne de température maximum est atteinte.

 Le système doit déclencher la Pompe remplissage de réservoir en cas de manque d’eau dans cette dernière.

 Le système doit déclencher l’éclairage de la serre en cas de besoin

La gestion d’irrigation :

Le système d’irrigation assure un niveau d’humidité du sol convenable à la végétation afin d’éviter l’asphyxie ou un manque d’eau dans la plante. Ce système est composé de deux sous- systèmes : système de détection du niveau du réservoir et système d’irrigation :

Sous système de détection de niveau et remplissage du réservoir :

Fonctionnement :

Le mini projet est un système automatique de pompage. Il sert à contrôler le remplissage d’un réservoir d’eau d’une manière automatique en utilisant une pompe électrique. Le montage est constitué des éléments suivants :

Pompe (P) : Elle permet de remplir le réservoir avec de l’eau lorsque le niveau d’eau est faible dans le réservoir (La pompe est mise en marche lorsque le niveau d’eau est atteint de niveau bas (B), Elle s’arrête lorsque le niveau d’eau arrive au niveau haut (H)).

Carte relais : Mise en marche/arrêt de la pompe, la carte relais contient un relais de puissance (AC/DC) qui assure la mise sous tension de la pompe, les caractéristiques du relais doivent être adéquates avec celle de la pompe (tension, puissance),nous utiliserons dans ce projet un relais

(250V/10A) menu avec un étage de puissance (isolation optique, transistor, diode de retour, etc.). En effet une tension TOR 5V à faible courant permet de déclencher le relais. Le relais ne nécessite pas un transistor de puissance, tout est intègre dans la carte relais !

(13)

Figure II-1 : SYSTÈME AUTOMATIQUE DE POMPAGE AVEC ARDUINO

Le capteur du niveau d’eau : Basé sur le principe magnétique le capteur indique un ‘0’ s’il est à l’état bas et un ‘1’ s’il est à l’état haut

Figure II-2 : Détecteur de niveau flottant

Le brochage du schéma de la figure précédente ne suffit pas car avec celui-ci il nous donne un résultat faussé : à la sortie détecteur on trouve un ‘’0 logique’’ quand il est au niveau bas (vide ou presque vide), et une suite logique de ‘’1’’ et de’’0’’ (111111000000011111000000….) quand il est au niveau haut alors qu’il doit donner un ‘’1’’. Ceci dit le brochage qui fonctionne sans erreur est le suivant :

Figure II-3 : Brochage de le photorésistance avec Arduino

(14)

L’ajout de la résistance ainsi que la référence (Com) est important pour que le système ne donne pas de fausses données (la résistance est de petite valeur de 220Ω).

De même avec l’autre détecteur mais on le branche dans un autre port digital, ceci donne le montage suivant :

Figure II-4 : Circuit de détection du niveau

Remarque :

Le diagramme est un programme en langage C de l’Arduino qui travail en boucle infinie de 1 seconde, à chaque boucle il teste l’état des 2 capteurs et affiche l’état du niveau d’eau.

Détecteurs de niveau :

Le réservoir dispose de deux détecteur TOR de niveaux Haut (H) et Bas (B), les deux détecteurs fournissent un signal logique de la façon suivante :

 « 0 » : Lorsque l’eau n’attient pas le détecteur, ce dernier fournit un niveau logique bas ou une tension égale à 0V

 « 1 » : Lorsque l’eau attient le détecteur, ce dernier fournit un niveau logique haut ouune tension égale à 5V

LEDs indicatrices :

On dispose de trois voyants lumineux (LEDs) indiquent l’état des détecteurs et celui de la pompe :

 LED (P) : Illustre l’état de la pompe. Elle s’allume lorsque la pompe est mise en route

 LED (H) : Illustre l’état du détecteur (H). Elle s’allume lorsque l’eau attient le niveau haut

 LED (B): Illustre l’état du détecteur (B). Elle s’allume lorsque l’eau attient le niveau bas Carte Arduino : Il sert à contrôler l’ensemble du système (lecture des détecteurs et envoie des consignes aux LEDs et à la pompe)

Chronogramme du système :

On considère la variable HB sur deux bits : Bit du poids fort H indique l’état du détecteur haut, B pour celui du bas. Exemples : HB=00 : Les deux détecteurs sont inactifs, HB=01 : Détecteur bas actif, etc.

Le programme principal contient 4 états :

(15)

Phase de remplissage :

 État « 1 » : Il est la position initiale du système. Il faut assurer que le réservoir est vide avant de lancer le programme. En effet, lorsque le réservoir est vide HB=00. Durant cet état, le programme mis en route la pompe (P=1) tant que HB=00. Lorsque HB=01, le programme transit à l’état suivant

 État « 2 » : Le programme mis en route la pompe (P=1) tant que HB=01. Autrement dit, la pompe continue de remplir le réservoir tant le détecteur H n’est pas attient. Une fois HB=11, le programme passe à l’état suivant

Phase de vidange :

 État « 3 » : Le programme met en arrêt la pompe tant le réservoir est plient (HB=11) ou défaut du détecteur bas (HB=10). En effet, l’état 10 n’est pas envisageable dans cas pratique car il ‘est pas possible que l’eau atteigne le niveau haut (H=1) sans que le niveau bas soit actif (B=1). Par conséquent, la présence de l’état HB=10 est certainement un défaut du détecteur bas. Le programme transit à l’état suivant l’eau quitte le détecteur haut (HB=01)

 État « 4 » : La pompe reste en état d’arrêt (P=0) tant que le détecteur B est actif (HB=01) (fluide entre H et B). Lorsque l’eau arrive au dessous du détecteur B (HB=00) on relance le cycle de fonctionnent.

Ci-dessous le chronogramme du système :

HB=00

HB=01

HB=01 HB=11

HB=11, HB=10

HB=01

HB=01 HB=00

Câblage des composants :

 Détecteur B: Pin 2

 Détecteur H:Pin 3

 LED (B):Pin 5

 LED (H):Pin 6

 LED (P): Pin 9

 Pompe (P): Pin 10

P=1

P=0 P=1

P=0

(16)

Programme principal :

Lecture des détecteurs : GetHB()

La fonction GetHB() permet de lire l’états des détecteurs H et B et renvoie une valeur comprise entre 0 et 3, En effet la valeur de retour est notre variable HB !

HB=0 lorsque H=0 & B=0 HB=1 lorsque H=0 & B=1 HB=2 lorsque H=1 & B=0 HB=3 lorsque H=1 & B=1

int GetHB(int H_Pin, int B_Pin) {

int HB=0;

if(digitalRead(B_Pin)==1) HB=HB+1;

if(digitalRead(H_Pin)==1) HB=HB+2;

Return HB;

}

Mise en marche de la pompe et son indicateur SetPompe() :

La LED (P) reflète l’état de la pompe P en revanche le relais est activé (niveau bas). Autrement dit, le relais est actif lorsque la sortie numérique (Pin10) de la carte Arduino est égale à « 0 » (inactif à

« 1 »). Par conséquent, les états des sorties 9 et 10 doivent être complémentaires et déclenchés en parallèle. La fonction SetPompe() permet d’activer les deux sorties en respectant l’état de chacune.

void SetPompe(byte P_val, int PP, int P_LEDD ) {

if(P_val==0) {

digitalWrite(P_LEDD, LOW);

digitalWrite(PP, HIGH);

} else {

digitalWrite(P_LEDD, HIGH);

digitalWrite(PP, LOW);

} }

Activation des voyants H et B SetLED() :

La fonction SetLED() active les LED H et B en fonction de l’état de la variable HB

 HB=0 : Deux LED éteintes

(17)

 HB=1 : LED B allumée

 HB=2: LED H allumée

 HB=3 : Deux LED allumées

void SetLED(byte HB_val, int Flag_BB, int Flag_HH ) {

switch (HB_val) {

Case 0:

digitalWrite(Flag_BB, LOW);

digitalWrite(Flag_HH, LOW);

break;

case 1:

digitalWrite(Flag_BB, HIGH);

digitalWrite(Flag_HH, LOW);

break;

case 2:

digitalWrite(Flag_BB, LOW);

digitalWrite(Flag_HH, HIGH);

break;

case 3:

digitalWrite(Flag_BB, HIGH);

digitalWrite(Flag_HH, HIGH);

break;

} }

Programmation d’un état :

On peut considérer un état comme une boucle infinie. On active une ou plusieurs sorties à l’intérieur de la boucle. La sortie de boucle est assurée par la validation de la transition vers l’état suivant. Dans notre cas, durant l’état « 1 », on active la pompe et son indicateur lorsque HB=0 en boucle. Puis, on passe à l’état « 2 » lorsque HB=1. Ci-dessous la programmation de l’état « 1 » :

…

// Etat '1' while(1) {

// Lectures H & B HB_val=GetHB(H, B);

// Condition de l'activation des sorties if(HB_val==0)

{

SetPompe(1, P,P_LED);

SetLED(HB_val,Flag_B, Flag_H);

}

(18)

// Condition de passage à l'état suivant if(HB_val==1)

break;

// Délais (pas nécessaire) delay(200);

}

…

Problème de démarrage :

Nous constatons que la mise en marche de la pompe durant l’état « 1 » exige l’inactivation des deux détecteurs (HB=0) ou le vidange du réservoir. Il est intéressant d’intégrer le mode vidange (ou nettoyage) du réservoir d’une façon manuelle en utilisant par exemple un interrupteur (« 1 » : Mode normal, « 0 » : Mode manuel). Durant ce mode on désactive la pompe (P=0) puis on affiche les états des LEDs. On met en marche par la suite le système lorsque les deux LED (H et B) sont éteintes.

oid loop() {

if(Mode_Sel=1) {

Mode Normal;

} else {

Mode vidange;

} }

Programme principal :

// Entrées détecteur de niveaux const int B = 6; // Bas

const int H = 7; // Haut

// Sorties indicateurs (LEDs) const int Flag_B = 5;

const int Flag_H = 6;

int HB_val=0;

// Sortie pompe

const int P_LED = 9;

const int P = 10;

void setup() {

(19)

Serial.begin(9600);

//Init

pinMode(B,INPUT);

Résultat de simulation durant le remplissage du réservoir :

Après intégration du programme dans la carte Arduino et test du sous-programme on a obtenu le résultat suivant durant le remplissage du réservoir pendant 20 seconde :

Figure II-5 : Résultat de simulation durant le remplissage du réservoir.

Sous système d’irrigation :

Cette partie concerne l’automatisation du système d’irrigation pour ne pas avoir besoin

d’intervention humaine. Le but étant d’économiser l’eau en donnant aux plantes juste la quantité dont elle est en besoin, réduire le gaspillage d’eau permet d’économiser l’argent.

Montages et composition du système :

On installer le capteur d’humidité du sol afin de prendre la mesure du taux d’humidité dans le sol et de l’envoyer au microcontrôleur qui lui assurera la gestion de l’irrigation selon la consigne donnée.

(20)

Figure II-6 : Branchement du capteur d'humidité du sol avec Arduino.

Etalonnage du capteur d’humidité du sol :

A l’aide d’une multitude de mesures et d’un appareil témoin (le four), nous allons créer un tableau qui nous servira pour calculer la courbe liant la tension à la donnée mesurée. Le four va nous servir comme un appareil de mesure “témoin” qui vous servira de référence. En suivant à chaque mesure référence la méthode suivante pour mesurer le taux d’humidité dans la terre :

 Mesurer le poids d’une capsule vide à l’aide d’une balance (P0).

 Introduire 10g de sol P1=P0(capsule vide) +10g de sol.

 En troisième étape arrive le séchage dans l’étuve à 105°C pendant 24h.

Figure II-7: Séchage dans l'étuve du témoin 1 à 105°C.

 Peser la capsule (après séchage) -> P2.

 Et en fin on applique la formule suivante pour trouver le taux d’humidité :

𝐻% = (𝑃1 − 𝑃2)

(𝑃1 − 𝑃0) ∗ 100

Après la mesure de H% on prend la même terre et on mesure avec le capteur la valeur analogique

(21)

ainsi que la tension (V) pour dessiner la courbe

On a pris 2 témoins pour trouver 2 points dans la courbe d’étalonnage en raison de quelques

difficultés pour atteindre le laboratoire dont on peut étalonner le capteur. Ces mesures ne suffisent pas pour savoir là où la courbe d’étalonnage est linéaire donc on a suggéré que le capteur est linéaire durant tout sa plage de fonctionnement.

 Témoin 1 :

P0=86,99 g ; P1=96,99 g ; P2=96,90 ;

En appliquant dans la formule précédente on trouve le taux d’humidité:

𝐻% =(96,99 − 96,90)

(96,99 − 86,99)∗ 100 = 0,9%

Après cette mesure on a pris le résultat de la mesure du capteur dans le témoin 1 (un autre échantillon du témoin 1) pour voir s’il est linéaire ou pas, on a trouvé le résultat suivant :

Figure II-8 : Résultat de la mesure du capteur dans le témoin 1

Remarque

:

la valeur du pourcentage et de la tension obtenue est de 0.02 v on remarque qu’elle est presque nulle mais il n’est pas égale à la valeur de l’étalon (0,9%) cela est dû peut être dû à l’erreur de mesure.

Témoin 2 :

P0=87,03 g ; P1=97,03 g ; P2= 97,01 ;

En appliquant dans la formule précédente on trouve le taux d’humidité:

𝐻% =(97,03 − 97,01)

(97,03 − 87,03)∗ 100 = 9,8%

(22)

Après cette mesure on a pris le résultat de la mesure du capteur dans le témoin 2 (un autre échantillon du témoin 2) pour voir s’il est linéaire ou pas, on a trouvé le résultat suivant :

Figure II-9 : Résultat de la mesure du capteur dans le témoin 2.

Remarque :

La valeur du pourcentage est de 11% et de la tension obtenue est de 0 ,54 v on remarque qu’il y a une erreur de 1,2% cela est dû peut être dû à l’erreur de mesure, mais les deux valeurs sont proches.

Traçage de la courbe des valeurs mesurées :

V (volt)

Figure II-10 : Courbe d’évolution de la tension en fonction de l’humidité.

Pompe d’Arrosage :

Elle permet de pomper l’eau du réservoir vers les plantes si elle est mise sous tension.

H %

(23)

Figure II-11 : Schéma du branchement de la pompe Arrosage avec Arduino

Électrovanne :

 Installation une électrovanne devant la pompe afin de bloquer l’eau

 L’électrovanne doit être actionnée avant la pompe.

Figure II-12 : Schéma du branchement de l'électrovanne avec Arduino

Le module relais :

(24)

Entre le GND et les l’alimentation 3,3 V du relais il y a les 4 PINs de commande des relais, et l’alimentation 5V du relais est supplémentaire mais obligatoire car le courant des sorties de la carte de Arduino est de 30 mA alors que un seul relais pour le commander il faut un courant de 70 mA.

Remarque : La commande des relais se fait avec l’état bas c.à.d. le relais s’actionne lorsqu’il est branché avec le GND.

Figure II-13 : Branchement du module relais avec la carte Arduino

Montage du sous-système d’irrigation :

Comme montrée dans la figue si dessous le capteur d’humidité du sol est rincé dans le sol des plantes et est relié à l’entrée analogique de la carte Arduino afin d’acquérir l’information et décider depuis si on actionne le système d’arrosage ou non. L’entrée de la pompe est reliée à la sortie du réservoir par un canal et la sortie de la pompe à l’entrée de l’électrovanne et depuis vers les plantes.

La pompe et l’électrovanne sont commandées, a travers deux relais, par 2 sorties digitales de l’Arduino int1 et int2 comme le montre la figure ci-dessous.

Figure II- 14 : Montage du sous-système d'irrigation

Diagramme du programme du sous-système d’irrigation :

(25)

Ceci est le diagramme en langage C de l’Arduino du sous-système d’irrigation fonctionnant en

boucle infinie. Si la valeur captée est inférieure à la consigne minimale le système s’actionne jusqu’à atteindre la consigne et il s’arrête.

(26)

Figure II-15 : Diagramme du sous programme d'irrigation

Définition de Serial.begin :

Définit le débit de données en bits par seconde (bauds) pour la transmission de données série. Pour communiquer avec l'ordinateur, utilisez l'un des taux suivants: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 ou 115200. Vous pouvez toutefois spécifier d'autres taux, par exemple pour communiquer sur la broche 0 et 1 avec un composant qui nécessite un débit en bauds particulier.

Programme du sous-programme d’irrigation :

Ceci est le programme en C de l’Arduino du sous-programme d’irrigation :

#define hum A1 //entrée analogique du capteur

d'humidité du sol #define pp 9 //entrée commandant le relais qui commande la pompe #define ev 8 //entrée commandant le relais qui commande

void setup() {

//déclaration des entrées /

début

hums <- lire: hum valhs<- 1024-hums

Valhs ? <C-600 non

oui

Ev <-0; Pp<-0;

valhs < C

oui

non Delay(2000ms)

Delay(500ms)

Ev <-1; Pp<-1;

fin hums <- lire: hum

valhs<- 1024-hums

Delay(5000ms) Serial.begin(9600);

Setup: E/S Pp, ev : OUTPUT; hum : INPUT pp<-pin 9 ; hum<-pin A0 Ev <-pin

8

Pp: pompe.

Hum: variable du signal du capteur.

Ev : électrovanne.

Hums : valeur inversé du signal.

Valhs : valeur non inversé du signal.

C : consigne.

(27)

pinMode(hum,INPUT);

pinMode(pp,OUTPUT);

pinMode(ev,OUTPUT);

//initialisation de l'etat des relais commandant la pompe et l'electrovanne digitalWrite(ev,HIGH);

digitalWrite(pp,HIGH);

//la vitesse d'éxécution par seconde (obligatoire) Serial.begin(9600);

} void loop() {

float hums=analogRead(hum); //lecture de la valeur analogique du capteur

float valhs=1024-hums; //inverser la valeur analogique le 0 avec 0%

et le max du capteur avec 100%

float vval=valhs/205; //conversion de la valeur en voltage float pcth=valhs/9.83; //conversion de la valeur en

pourcentage float consigne=600.00;

Serial.print("valeur analogique=");//impression des valeurs Serial.print(valhs);

Serial.print("\n");

Serial.print("valeur voltage=");

Serial.print(vval);

Serial.print(" V");

Serial.print("\n");

Serial.print("pourcentage d'humidité du sol="); Serial.print(pcth);

Serial.print("%");

Serial.print("\n");

Serial.print("---");

Serial.print("\n");

//test de la condition d'arrosage ou pas if(valhs<(consigne-

600.00)){

while(valhs<consigne){

//activation des relais qui fonctionnent à l'etat bas digitalWrite(ev,LOW);

delay(1000);

digitalWrite(pp,LOW);

//durée du cycle

delay(2000);

//arret du systeme d'iirigation

digitalWrite(ev,HIGH);

delay(5000);

hums=analogRead(hu m); valhs=1024-hums;

}} else{

(28)

digitalWrite(pp,HIGH)

;

digitalWrite(ev,HIGH)

; } delay(500); }

Résultats

Après implémentation du programme dans la carte Arduino et installation du sous-système on a obtenu le résultat suivant :

Figure II-16 : Valeur d'humidité du sol mesuré avant d'actionner le système.

On a mis une valeur de consigne égale 600.00 comme décrit dans le programme puis on a actionné le système pour voir sa réaction.

Remarque:

 Si la valeur de l’humidité du sol à dépasser la consigne et cela est dû à la faible perméabilité du sol utilisé, l’eau a pris beaucoup de temps pour s’infiltrer dans la terre, aussi la pompe n’a pas un débit fixe car son débit dépend du niveau d’eau dans le réservoir.

 Durant l’étalonnage du capteur et pendant la mesure de la valeur analogique, le capteur a donné un meilleur résultat après avoir redu le capteur étanche en couvrant sa partie supérieur avec le Silicone.

 Chose importante : Durant l’étalonnage du capteur c’est que les impuretés peuvent augmenter l’erreur de mesure, on aurait dû les enlevés.

La gestion de luminosité :

La régulation du taux de lumière en créant un micro climat avec un éclairage convenable à la plantation.

Montage et composition du système :

Le sous-système est composé de :

 Capteur LDR : Monté comme suit avec l’Arduino :

(29)

Figure II-17 : Montage de la photorésistance avec l'Arduino

 LEDs : Afin de superviser l’éclairage.

Remarque :

Pour la supervision de l’obscurité il suffit de mettre dans la serre des vitres moins transparentes et contrôler l’éclairage.

Montage du sous-système :

Figure II-18 : Montage du système de gestion d'éclairage

Diagramme du programme du système de gestion d’éclairage :

Ceci est le diagramme en langage C d’Arduino fonctionnant en boucle infinie, si l’éclairage est inférieur à la consigne les leds s’éclaircie juste pour compenser la différence entre la consigne et la lecture en utilisant le PWM (Puls Width Modulation) accessible dans les pins 2, …, 13 de l’Arduino MEGA

(30)

Figure II-19 : Diagramme du programme de gestion d'éclairage

Le PWM (Pulse Width Modulation) C’est une technique qui permet de contrôler l’intensité de l’éclairage des leds.

Le pourcentage de temps passé à l’état HIGH sur la période du signal est appelé le rapport cyclique.

Il varie donc de 0%, le signal est tout le temps LOW, à 100%, le signal est tout le temps HIGH. Plus le rapport cyclique est petit plus moins les leds s’éclaircie et inversement.

Début

lu<- lire: lum

lu ? < C-400 non

oui

lu ? < C a <- consigne-lu

b <- a*255/620 oui

non

b ?> 255 non

Led <-0 ;

oui b <- 255 ;

Led <- b

fin Delay(500ms) Serial.begin(9600);

Setup: E/S; led : lum<-pin A9 ;

Lum: variable de l’entrée du LDR.

Lu : la valeur analogique du capteur.

C : consigne.

(31)

Le programme :

Ceci est le programme en C de l’Arduino du système de gestion d’éclairage :

#define lum A9 //PIN de l'entree analogique du capteur const byte led = 3;

void setup(void){

pinMode(led,OUTPUT);//Déclaration des input / output pinMode(lum,INPUT);

Serial.begin(9600);// } void loop(void){

float lu=analogRead(lum); //lecture de la valeur analogique du capteur float lumv=lu/205.00; //conversion de la valeur en voltage

float lump=lu/9.83; //conversion de la valeur en pourcentage float consigne=400.00;

float Cmin=consigne-80.00;

Serial.print("valeur

analogique=");//impression des valeurs Serial.print(lu);

Serial.print("\n");

Serial.print("valeur voltage=");

Serial.print(lumv);

Serial.print(" V");

Serial.print("\n");

Serial.print("pourcentage de lumière="); Serial.print(lump);

Serial.print("%");

Serial.print("\n");

Serial.print("---");

Serial.print("\n");

if(lu<Cmin)//condition d'activation ou de désactivation du système // si infèrieur à la consigne minimale (Cmin)

{if(lu<consigne)

{//lancer l'éclairage avec PWM float a=consigne-lu;

float

b=(a*255)/620.00;

if(b>255){b=255;}

analogWrite(led,b); }}

else

{digitalWrite(led,LOW ); } delay(2000); }

Résultat de simulation du système d’éclairage :

On a donné plusieurs consignes à notre système et les réponses étaient comme suit :

(32)

Consigne (en valeur analogique du système)

Réponse du système 600.00 Entre 595.00 et 644.00 500.00 Entre 490.00 et 550.00 400.00 Entre 393.00 et 416.00 300.00 Entre 360.00 et 320.00 Tableau II-1 : Résultat du teste du système d'éclairage.

Remarque :

A la distance de 20 cm et en utilisant le PWM (Pulse Width Modulation) du microcontrôleur on a obtenu un résultat satisfaisant, même si il y a un taux d’erreur le système a bien réagis. La distance entre la LDR et les LEDs joue un rôle important dans la variation du taux d’éclairage.

La gestion de température :

La température étant un des paramètres les plus importants pour la germination, nous avons mis en disposition deux systèmes de régulation de celle-ci afin de la maintenir dans une plage de

température convenable pour la germination. Le 1er système est celui du refroidissement de la serre et le 2ème celui de réchauffement de la serre, et pour cela on a utilisé les composants suivant :

Composition et montage du système :

Le système de gestion de température de la serre est composé de :

 Un capteur de température :

Pour contrôler la température on a besoin avant tout de la mesurer et pour cela on a utilisé un capteur DHT11 monté tel que la montre le schéma ci-dessous avec la carte ARDUINO.

Figure II-20 : Montage du DHT11 avec Arduino

 Un ventilateur de refroidissement :

Il a un rôle de rabaisser la température au milieu de la serre. Il est placé en haut comme le montre la figure ci-dessous en raison que la chaleur a tendance de monter en haut. On ajouter une autre source

(33)

d’alimentation externe avec un module de relais pour commande le tout.

Figure II-21 : Montage du ventilateur avec Arduino

 Un air chaud :

Contrairement au ventilateur, celui-là joue un roule d’élévateur de température.

Figure II-22: Montage de l’air chaud avec Arduino

Montage du système de gestion de température :

Après avoir tester tous les sous-ensembles le temps est venu de les regrouper en une seule partie comme la montre la figure ci-dessous :

(34)

Figure II-23 : Montage du sous-système de gestion de température

Diagramme du programme :

Ceci est un diagramme en langage C de l’Arduino qui nous a permis de garder le niveau de température entre 2 consignes (max et min).

Figure II-24 : Diagramme du programme de gestion de la température.

début

Setup: E/S; fr, ch : OUTPUT;

Dht pin <- INPUT

Serial.begin(9600);

t<- lire:

Température

non non

t ?< Cmin=15°C t ?> Cmax=30°C

oui oui

non

t ?< Cmax ch <- 1 Fr <- 0 ch <- 1 Fr <- 1

oui t<- lire:

temperature ch <- 0 Fr <- 1

fin Delay(500ms)

fr<-pin 11 ; dht lib ch<-pin 12 ;dht <-pin 4

Fr: refroidissement.

Ch : réchauffement.

T: Donnée de température.

Cmin : consigne minimale.

Cmax : consigne maximale.

‘0’ : activation.

‘1’ : Désactivation.

(35)

Partie programmation

La démarche du programme est la suivante :

 Si la température < consigne min : actionne le chauffage jusqu’à atteindre la consigne max.

 Si la température >consigne max : actionne le ventilateur jusqu’à évacuer la chaleur qui s’est accumulée.

 Si non tout est bon et n’actionne rien.

#include "DHT.h"

#define DHTPIN 4 // à quelle broche nous sommes connectés // type du DHT

#define DHTTYPE DHT11

// Initialiser DHT pour 16mhz Arduino DHT dht(DHTPIN, DHTTYPE);

#define refroi 11

#define chauff 12 void setup() {

pinMode(DHTPIN,INPUT);

pinMode(refroi,OUTPUT);

pinMode(chauff,OUTPUT);

Serial.begin(9600);

Serial.println("DHTxx test!");

digitalWrite(chauff,HIGH);

digitalWrite(refroi,HIGH);

dht.begin();}

void loop() {

// Attendez quelques secondes entre les mesures. delay(2000);

// Les lectures du capteur peuvent également durer jusqu'à 2 secondes (c'est un capteur très lent)

float h = dht.readHumidity();

//Lire la température en Celsius float t = dht.readTemperature();

float cmin=15;

float cmax=30;

// Vérifiez si les lectures ont échoué et quittez tôt (pour réessayer). if (isnan(h) || isnan(t) ) {

Serial.println("Failed to read from DHT sensor!");} Serial.print("Humidity: ");

Serial.print(h);

Serial.print("

%\t");

Serial.print("Temperature:

"); Serial.print(t);

Serial.print(" *C\t

"); Serial.print("\n

");

if(t<cmin)//condition d'activation et désactivation des actionneurs

(36)

{ while(t<cmax){

digitalWrite(chauff,LOW);

t = dht.readTemperature();}}

else if(t>cmax){

digitalWrite(refroi,LOW);}

else {

digitalWrite(refroi,HIGH);}

}

Résultats de simulation :

On a donné plusieurs consignes supérieures à la température ambiante à notre système et les réponses étaient les suivantes :

Temperature

ambiante (°C) Consigne (°C) Réponse du système

Temps de réponse

10 11 28 1m15s

10 13 30 2m52s

10 15 33 5m30s

10 17 35 9m23s

Tableau II-2 : Résultat lors de l'activation de l'air chaud

On a donné plusieurs consignes supérieures à la température ambiante à notre système et les réponses étaient les suivantes :

Température ambiante (°C)

Consigne (en °C) Temps mis pour évacuer la chaleur

sans Fan

Temps mis pour évacuer la chaleur

avec Fan

38 34 / /

38 32 1m53s 1m00s

38 30 8m45s 3m23s

38 28 28m45s 8m38s

Tableau II-3 : Résultat de l'évacuation de la chaleur avec et sans fan.

Le système est fonctionnel est a bien réagie aux consignes donnée

(37)

Chapitre III: Système de connexion à internet et programme globale

Système de connexion à internet :

Connecter la serre agricole à un réseau internet permettrai d’acquérir en temps réel les prévisions météorologiques. L’objectif est d’anticiper des actions dans une démarche d’augmentation de l’autonomie et de réduction des dépenses d’énergie et de l’eau. Ce concept ouvre la voix vers l’intégration d’une intelligence artificielle au sein de la serre agricole. La société Google travaille déjà dans cette voie par le développement du système AI pour l’agriculture intelligente (Smart Farming).

Composant et montage du système :

Un ESP 8266 : C’est un shield WIFI qui permet à l’Arduino d’accéder à un serveur WEB lequel on va télécharger des données météorologiques en raison de faire des prévisions ou de télécharger des données d’environnement correspondantes à un type de plante.

Figure III-01 : Montage de l'ESP8266 avec l'Arduino

 Etapes de connexion du shield avec le serveur : 1) Ajouter le support de l'ESP8266

(38)

Figure III-02 : Etape d'insertion de la bibliothèque de l'ESP8266 dans l'Arduino

(39)

2) Sélectionnez ensuite le Gestionnaire de cartes (Boards Manager)

Figure III-03: Sélectionnement board manager 3) Sélectionnez le paquet esp8266

Figure III-04 : Sélection du package ESP8266

(40)

4) choisir la cible Generic ESP8266 Module

Figure III-05 : Chemin vers le choix de la cible Générique module Une fois l'ESP connecté à votre poste, sélectionnez le port COM correspondant (menu Outils/Port…)

Si le firmware d'origine est toujours présent dans l'ESP8266, vous pouvez communiquer avec lui au travers du Moniteur Série :

1) Ouvrez le Moniteur Série (Serial Monitor) ;

2) Sélectionnez la vitesse de transmission, normalement 115 200 bauds (baud rate), mais selon le firmware, elle peut être inférieure ;

3) Sélectionnez « Les deux, NL et CR » (Both NL & CR), pour envoyer un New Line et Carriage Return à chaque envoi (bouton Envoyer) ;

4) Tapez (sans les guillemets) la commande « AT », puis cliquez sur le bouton « Envoyer ». L'ESP devrait renvoyer « OK » dans le Moniteur Série. Si ce n'est pas le cas, pressez le bouton RESET ou essayez à nouveau en redémarrant après avoir débranché le câble USB. Vérifiez aussi que vous avez sélectionné le bon port COM. Si l'ESP ne répond toujours pas, peut-être que le firmware « standard » n'est pas installé et qu'il ne comprend pas les commandes AT. Dans ce cas, cela n'est pas vraiment un problème puisque vous allez réécrire par-dessus le firmware avec votre propre code ;

5) Tapez « AT+GMR ». L'ESP retourne le numéro de version du firmware.

Remarque :

Faute de temps on n’a pas pu faire la réalisation de la partie connexion internet.

(41)

Programme globale :

Intégration de l’ensemble des sous-systèmes

A la fin nous avons intégré tous les sous programmes en un seul programme.

Programmation :

Le programme se décompose en deux parties : Setup :

Le code n'est exécuté qu'une fois au démarrage du module.

 Configuration du réseau

 Définition des variables

 Connexion au réseau Wifi

 Démarrage du serveur http Boucle Principale :

Le code de cette boucle est répété jusqu'à extinction du module

 attente d'une connexion sur le serveur Web embarqué

 interprétation de la requête reçue et pilotage de la température (haute ou basse)

 réponses sur port série et http

 envoi d'une commande API vers.

La configuration :

Dans la boucle SETUP, vous devez configurer

 le réseau

 Les commandes API qui seront envoyées vers IPX800 (retour d'état)

 Les Leds optionnelles

En mode WIFI le module peut travailler sous 3 modes :



Figure III-06 : Les différents modes de connexion

(42)

Programme globale qui gère de la serre :

#define lum A9 //PIN de l'entree analogique du capteur

#define led 3 //PIN de la sortie TOR des LEDs //////////////////////////////////

#define cbas 6

#define chaut 7

//////////////////////////////////

#define hum A1 //entrée analogique du capteur d'umidité du sol #define pp 9 //entrée commandant le relais qui commande la pompe

#define ev 8 //entrée commandant le relais qui commande //////////////////////////////////

#include "DHT.h"

#define DHTPIN 4 // à quelle broche nous sommes connectés // type du DHT #define DHTTYPE DHT11 // Initialiser DHT pour 16mhz Arduino

DHT dht(DHTPIN, DHTTYPE);

#define refroi 11

#define chauff 12

///////////////////////////////////

void setup(void){

pinMode(led,OUTPUT);//Déclaration des input / output pinMode(lum,INPUT);

//////////////////////////////////

//déclaration des entrées / sorties pinMode(cbas,INPUT);

pinMode(chaut,INPUT);

/////////////////////////////////

pinMode(hum,INPUT);

pinMode(pp,OUTPUT);

pinMode(ev,OUTPUT); //initialisation de l'etat des relais commandant la pompe et l'electrovanne

/////////////////////////////////

pinMode(DHTPIN,INPUT);

pinMode(refroi,OUTPUT);

pinMode(chauff,OUTPUT);

Serial.println("DHTxx test!");

dht.begin();

Serial.begin(9600);

}

(43)

void loop(void){

float lu=analogRead(lum); //lecture de la valeur analogique du capteur float lumv=lu/205.00; //conversion de la valeur en voltage

float lump=lu/9.83; //conversion de la valeur en pourcentage float consignelu=400.00;

float Cminlu=consignelu-80.00;

//////////////////////////////

boolean cb=digitalRead(cbas);

boolean ch=digitalRead(chaut);

//////////////////////////////

float hums=analogRead(hum); //lecture de la valeur analogique du capteur

float valhs=1024-hums; //inverser la valeur analogique le 0 avec 0% et le max du capteur avec 100%

float vval=valhs/205; //conversion de la valeur en voltage float pcth=valhs/9.83; //conversion de la valeur en pourcentage float consignehs=600.00;

float cminhs=0;

///////////////////////////////

// La lecture de la température ou de l'humidité prend environ 250 millisecondes!

// Les lectures du capteur peuvent également durer jusqu'à 2 secondes (c'est un capteur très lent)

float h = dht.readHumidity();

//Lire la température en Celsius float t = dht.readTemperature();

// Lire la température en Fahrenheit float f = dht.readTemperature(true);

float cmint=15;

float cmaxt=30;

/////////////////////////////////

Serial.print("valeur analogique d'intensité lumineuse=");//impression des valeurs

Serial.print(lu);

Serial.print("\n");

/*Serial.print("valeur voltage=");

Serial.print(lumv);

Serial.print(" V");

Serial.print("\n");*/

Serial.print("pourcentage

d'éclairage="); Serial.print(lump);

Serial.print("%");

Serial.print("\n");

Serial.print(" --- ");

Serial.print("\n");

//////////////////////////////

//pour le réservoir l'affichage est inclu dand le test.

//////////////////////////////

(44)

Serial.print("valeur analogique d'humidité du sol=");//impression des valeurs Serial.print(valhs);

Serial.print("\n");

/*Serial.print("valeur voltage=");

Serial.print(vval);

Serial.print(" V");

Serial.print("\n");*/

Serial.print("pourcentage d'humidité du sol="); Serial.print(pcth);

Serial.print("%");

Serial.print("\n");

/////////////////////////////////

// Vérifiez si les lectures ont échoué et quittez tôt (pour réessayer).

if (isnan(h) || isnan(t) || isnan(f)) {

Serial.println("Failed to read from DHT sensor!");

}

Serial.print("Humidity: ");

Serial.print(h);

Serial.print(" %\t");

Serial.print("Temperature intèrne: ");

Serial.print(t);

Serial.print(" *C\t ");

//////////////////////////////////

if(lu<Cminlu)//codition d'activation ou de désactivation du système // si infèrieur à la consigne minimale (Cmin)

{if(lu<consignelu)

{//lancer l'éclairage avec PWM

float a=consignelu-lu;

float b=(a*255)/620.00;

if(b>255){b=255;}

analogWrite(led,b); } }

else {digitalWrite(led,LOW); } //////////////////////////////////

if(ch==1){

Serial.print("Le niveau du réservoir est plein"); Serial.print("\n"); }

else if(ch==0 && cb==1){

Serial.print("Le niveau du réservoir est

(45)

moyen"); Serial.print("\n");}

else {

Serial.print("Le niveau du réservoir est bas"); Serial.print("\n"); }

///////////////////////////////

//test de la condition d'arrosage ou pas if(valhs<cminhs){

while(valhs<consignehs){

//activation des relais qui fonctionnent à l'etat bas.

digitalWrite(ev,LOW);

delay(1000);

digitalWrite(pp,LOW);

//durée du cycle.

delay(2000);

//arret du systeme d'iirigation.

delay(5000);//\\*************** relire la valeur de l'humidité du sol après chaque cycle. hums=analogRead(hum);

valhs=1024-hums; }}

else{

digitalWrite(ev,HIGH); } //////////////////////////////////

if(t<cmint)//condition d'activation et désactivation des actionneurs { while(t<cmaxt){

digitalWrite(chauff,LOW);

t = dht.readTemperature();}}

else if(t>cmaxt){

digitalWrite(refroi,LOW);}

else {

digitalWrite(refroi,HIGH);}

/////////////////////////////////// }

(46)

Conclusion générale

Nous avons conçu et réalisé un système pour obtenir un microclimat avec la régulation des 3 paramètres très influant sur le développement des plantes, cela peut faire des économies en supprimons les frais de transports des produit non locale ainsi on diminue aussi la pollution des engins de transport, mais de l’autre côté la consommation énergétique causé par les actionneurs a fait augmenter le cout. D’autre part, l’introduction de l’autonomie énergétique dans notre système est préférable afin de réduire au maximum le cout ainsi le projet serai vraiment rentable sur le long terme. Enfin, cette étude nous a permis de comprendre le fonctionnement d’une serre agricole dans l’objectif de la rendre autonome.

En perspective de notre travail, après la réalisation de la serre automatique et la validation du concept, il est primordial de terminer la partie connexion pour une meilleure gestion de la serre. Il est possible d’intégrer une carte ARM Cortex M3 avec noyau temps réel afin de rendre le système multitâches et en temps réel pour une meilleure adaptation du microclimat avec le besoin de la plante. Ceci permettrait d’optimiser la consommation énergétique. Nous avons réfléchi à intégrer une source d’énergie renouvelable composée des panneaux solaire et des batteries afin de rendre le projet plus viable.

(47)

BIBLIOGRAPHIE

 https://jardinierparesseux.com/2018/02/28/temperatures-de-germination-legumes-et-herbes- aromatiques/amp/

 https://www.yara.fr/fertilisation/solutions-pour-cultures/tomate/principes-agronomiques- tomates/

 https://www.arduino.cc/

 https://arduino.developpez.com/tutoriels/cours-complet-arduino/?page=programmer-arduino