Arroseur Automatique

## But du Projet

Le but de ce projet est de réaliser un système d'arrosage automatique, utilisable facilement par n'importe quel utilisateur souhaitant arroser ses fleurs.

## Présentation du projet

Ce système sera réalisé à partir d’un détecteur d’humidité « Grove moisture sensor », qui va dans un premier temps indiquer en permanence à l'Arduino UNO l'humidité du sol. Ce dernier fonctionne grâce à la capacité qu'a la terre à laisser passer plus ou moins de courant selon l'humidité (sa résistivité évolue en fonction de l'humidité):

**NB**: ***Nous pourrons afficher le pourcentage d'humidité à partir de ces valeurs sur un afficheur.***

Au moment où la terre est détectée comme sèche, l'Arduino déclenche la pompe péristaltique jusqu'à ce la terre soit suffisamment arrosé. Pour cela, nous plaçons un simple capteur d'humidité sous le pot qui arrêtera la pompe quand l'eau commence à couler du pot.

De ce fait, nous obtenons un système totalement automatique qui permet d'arroser ses plantes et d'en contrôler le taux d'humidité.

**Diagramme récapitulatif du fonctionnement du système**

## Cahier des charges

Un Arduino UNO fournira une tension de 0-5V au 2 capteurs d'humidité, ainsi qu'au système de multiplicateur de courant.

* Le 1er détecteur d'humidité (broche) renverra une valeur analogique de la tension aux bornes lu par Arduino (plus l'humidité augmente, plus la résistivité du sol diminue et donc laisse passer plus de courant)

* Le 2e capteur d'humidité sous le pot sera relié par sa sortie numérique qui renverra 1 si le capteur est mouillé et 0 s'il est sec.

* La pompe péristaltique sera alimenté par un un circuit multiplicateur de courant (utilisant le 5V d'Arduino) alimenté par une alimentation externe de 9V, et fournira ainsi une puissance d'environ 2,43W.
* **NB**: ***La pompe puisera l'eau depuis un réservoir type bouteille d'eau, bidon, pouvant être rechargé manuellement et aisément***

*Schéma du montage réalisé sur Fritzing*

*Schéma technique du montage réalisé sur Fritzing*

**NB: L'afficheur n'est pas représenté sur les schémas pour plus de lisibilité sur le système principal.**

## Capteurs nécessaires

* La mesure de l'humidité est réalisée par un capteur d'humidité de type broche, alimenté en Vcc = 5V par Arduino, sortant du ~3.5V quand il est immergé dans l'eau et ~0V dans l'air, qui nous donnera les valeurs de la tension aux bornes en analogique sur du 10bits (2^10 =1024 niveaux équivalent a environ 5V/1024 = 5mV par digits) lu par l'Arduino.

    Ce capteur nous permet de mesurer l'humidité de la terre se basant sur la conductivité du sol entre les 2 pattes, dépendant lui même de la résistivité de la terre selon son humidité (plus la terre est humides, moins elle est résistive et plus le courant circule de patte en patte).

* La détection de l'humidité sous le pot qui permettra d’arrêter la pompe est fait par un 2nd capteur d'humidité beaucoup plus simple et moins précis, lui aussi alimenté par le 5V d'Arduino qui nous renverra seulement les valeurs numériques (grâce au module ajouté permettant de convertir l'analogique en numérique). La valeur 0 (LOW) nous indique que du courant passe donc qu'il y a présence d'eau sur le capteur, et inversement avec 1(HIGH).

Ce capteur est fabriqué de fait que les 2 bornes conductrices soient repartis en plusieurs proche de courte distance, séparés par un isolant. Lorsqu'il n'y a pas d'eau, la résistance est très forte donc le courant ne circule pas et inversement, quand de l'eau établie le contact entre les bornes, le courant passe.

## Besoins électriques

Les 2 capteurs d'humidités seront alimentés par la tension de 0-5V fourni par Arduino.

Pour alimenter la pompe péristaltique, on utilisera une alimentation externe de 9V, monté sur un circuit indépendant contrôlé par Arduino par un relais.

## Besoins Mécaniques

Nous n'avons pas réellement besoin de support, étant donné que les capteurs utilisés ne sont pas sensible à l'eau et ne pollue pas le sol.

Cependant nous pouvons imaginer une boite contenant l'Arduino et son alimentation externe de 5V (et un éventuel afficheur sur le dessus), ainsi qu'un boitier dans lequel nous laisserons dépasser la broche du capteur d'humidité afin d'y stocker les fils et de rendre l'installation du capteur plus pratique.

Par manque de temps, nous n'avons pu rendre le système plus ergonomique, mais il est totalement possible et envisageable de le miniaturiser pour simplifier son utilisation par l'utilisateur.

## Arduino

L'Arduino UNO possède plusieurs Entrées/sorties numériques et analogiques.

Ici, l'entrée analogique A0 est utilisée pour lire les valeurs du 1er capteur d’humidité analogique entre 0 et 5V sur 10bits, nous fournissant ainsi des valeurs variants de 0 a 210=1024, par conséquent une résolution de 1024/5 = 204.8 par volt, ce qui est largement précis pour notre système, étant donné que l'on différencie un sol sec à 995 et un sol après arrosage à 520.

L'entrée numérique D5 est utilisée pour lire le 2nd capteur qui permet de savoir si l'eau a débordé ou non du pot: quand une goutte d'eau se place sur le capteur, le courant circule et renvois directement 1 (HIGH) à l'arduino. Cette condition établie, Arduino renvoie dans le Gate du MOSFET une valeur numérique= 0(LOW) et entraîne le basculement du relais et donc l'extinction du moteur.

Et enfin la sortie numérique D13 est reliée à la Base du transistor et permet donc de contrôler la pompe péristaltique,

## Programme Arduino

Liens Mega pour télécharger le programme Arduino.

```
#include "Wire.h"
#include "LCD.h"
#include "LiquidCrystal_I2C.h"

#define I2C_ADDR 0x3F  // Utiliser I2C scanner pour vérifier l'adresse I2C de l'afficheur
// On définit les constantes des pins de l'afficheur LCD
#define Rs_pin 0
#define Rw_pin 1
#define En_pin 2
#define BACKLIGHT_PIN 3
#define D4_pin 4
#define D5_pin 5
#define D6_pin 6
#define D7_pin 7

LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin); // Entre en communication avec le lCD

void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  pinMode(13, OUTPUT);
   lcd.begin (16,2); //  Si 16 caractères et 2 lignes

  // LCD Backlight ON
  lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
  lcd.setBacklight(HIGH);
  lcd.home (); // go home on LCD
  lcd.clear();

 }

 void loop()
 {
         /* ............... Code Principal permettant de faire fonctionner basiquement notre système ...............*/

   int sensorValueOn = analogRead(A0), pumpPin = 13, sensorValueOff = digitalRead(7), analogSec = 900, analogAir = 1020 ; // On définit en int les différents pins utilisés
  float pourcentageHumidite, nouveauPourcentage=0, maxHumidite = 72.0;

   if (sensorValueOn >= analogSec && sensorValueOn < 1020) // Condition d'allumage de la pompe: Si la valeur analogique du capteur Broche est >= 900 (correspondant à un sol sec définit expérimentalement), la pompe se déclenche
  {
     digitalWrite(pumpPin, HIGH); // Renvoie 1 dans le Gate du MOSFET, afin de basculer le relais et enclencher la pompe
  }

   if (sensorValueOff == LOW) // Condition d'extinction de la pompe: Si la valeur numérique est == 0 (correspondant au capteur simple immergé dans l'eau), la pompe s'éteint
  {
     digitalWrite(pumpPin, LOW); // Renvoie 0 dans le Gate du MOSFET, afin de basculer le relais et éteindre la pompe

   }

       /* ............... Code permettant d'afficher les informations sur l'écran LCD 16*2 ...............*/

   pourcentageHumidite = ((1024.0 - sensorValueOn)/1024.0)*100; //Convertit la valeur analogique en %
  nouveauPourcentage =  (pourcentageHumidite/maxHumidite)*100; //Crée un % sur une échelle de 300=> 100% et 1024 =>0%

   if (nouveauPourcentage < 30) //Si le pourcentage d'huimidité est <30% alors affiche "sec" + humidité %
  {
     lcd.setCursor(1,0);
    lcd.print("sec");
    lcd.setCursor(1,1);
    lcd.print("humidite ");
    lcd.print(nouveauPourcentage);
    lcd.print("%");

   }
   else if ( nouveauPourcentage >= 30 && nouveauPourcentage <= 50 ) //Si le pourcentage d'huimidité est [30,50%] alors affiche "Mi-sec" + humidité %
  {
     lcd.setCursor(1,0);
    lcd.print("mi-sec");
    lcd.setCursor(1,1);
    lcd.print("humidite ");
    lcd.print(nouveauPourcentage);
    lcd.print("%");

   }
   else // Sinon humidité >50% alors affiche "humide" + humidité %
  {

     lcd.setCursor(1,0); //Sinon (
    lcd.print("humide");
    lcd.setCursor(1,1);
    lcd.print("humidite ");
    lcd.print(nouveauPourcentage);
    lcd.print("%");
  }

           /* ...............Code secondaire qui nous permet de réaliser nos tests et
contrôler le bon fonctionnement des capteurs sur ordinateur............... */

   delay(1000);
   Serial.print("Broche ");
  Serial.println(sensorValueOn); // Affiche la valeur analogique du capteur broche
  Serial.print("simple ");
  Serial.println(sensorValueOff); // Affiche la valeur numérique du capteur simple
  lcd.clear();
 }

```

## Tests

Des premiers tests concluants ont été réalisé afin de vérifier le bon fonctionnement du système autonome en lui même, en remplaçant le système externe moteur+Alimentation par une simple led alimenté sur le 5V d'Arduino, le tout en simulant les capteurs en les immergeant ou non dans de l'eau:

Analogie avec la situation réelle: si le capteur est dans l'eau => Terre arrosée / dans l'eau et si le capteur est à l'air libre => terre sèche / pas d'eau qui ne coule sous le pot.

Par conséquent, nous avons procédés tel quel:

On immerge la broche dans l'eau et le capteur simple à l'air libre (=Terre humide et pas d'eau sous le pot), puis on retire la broche de l'eau (= la terre est subitement sèche). Cela a eu bel et bien pour effet de déclencher la pompe comme voulu. On re immerge la broche dans l'eau ainsi que le capteur simple (= la terre est fraîchement arrosée, et de l'eau a coulé sous le pot, certifiant un arrosage uniforme dans la profondeur de la terre). Ce qui a donc entrainé l’extinction de la pompe.

En multipliant le procédés, aucun changement n'a été observé, le système fonctionnant donc bel et bien en total autonomie quant à la gestion de la pompe.

**NB: *Nous réaliserons d'autres tests, cette fois ci au plus proche de la réalité en mettant la vrais pompe, et en immergeant cette fois ci la broche dans différents type de sols (plus oui moins humide) afin de vérifier le fonctionnement du système en situation*.**

## Mesures

* **Mesures de la résistance et des valeurs analogiques aux bornes du capteur d'humidité (broche) en fonction de l'humidité du sol:**

  Terre après arrosage
  Terre sèche

* **Mesure de la résistance aux bornes du 2nd capteur d'humidité:**

  Air libre
 (sec)
  Eau

* **Caractérisation du moteur actionnant la pompe péristaltique, par le graphe I(V).**

## Affichages

Nous avons choisis d'intégrer un afficheur LCD 16\*2 afin d'afficher les mesures faites par le capteur d'humidité, afin de créer un taux d'humidité à notre échelle (entre 500 et 1020 valeurs analogiques) et d'afficher si la nature du sol (sec, mi-sec, humide).

## Problèmes rencontrés

Après avoir caractérisé le moteur, nous avons choisis de l'alimenter avec une alimentation externe (type pile 9V) afin que cette dernière puisse fournir suffisamment de puissance requise au moteur (P = 9 \* 0.270 = 2.43W, qui est suffisant pour faire tourner le moteur rapidement afin d'augmenter le débit d'arrosage).

Cependant, pour contrôler le moteur avec Arduino, nous avons décidé d'utiliser un MOSFET (STP16NF06) en tant que relais pour activer et désactiver le moteur, mais nous avons eu des difficultés à connecter, et à faire fonctionner ce dernier. Par conséquent, nous avons donc décidé d'utiliser un simple transistor NPN BD681 pour remplacer le MOSFET, ce qui régla notre problème.

## Documentation

* MOSFET (STP13NF06) ressource
* Transistor NPN (BD681) ressource
* Capteur d'humidité (type broche) ressource

* PDF de la présentation du projet (Lien Mega)
* le pdfFichier:Arroseur Automatique.pdf