Go Down

Topic: Arrosage automatique (Read 5387 times) previous topic - next topic

HG89

Jun 21, 2017, 05:28 pm Last Edit: Jun 21, 2017, 05:37 pm by HG89
Bonjour

Voici une réalisation complète pour faire un arrosage de plantes (ou autres), et qui fonctionne à deux endroits différents (avec deux boitiers évidemment) depuis trois semaines.
Mon cahier des charges était:
-Alimentation élect. sur batterie 12v (jardin)
-Puisage d'eau de pluie dans une réserve (bidon), afin d'avoir de l'eau non calcaire et de pouvoir y ajouter un engrais liquide.
-Sonde d'humidité afin d'avoir un arrosage constant et régulier.

J'ai donc réalisé un boitier à partir d'un Pro Mini 5v pour son petit format, avec un capteur d'humidité chez TiptopBoards légèrement modifié.

Un potentiomètre règle la valeur d'humidité voulue. Toutes les 30 sec une mesure se fait et si le seuil est dépassé cela commande  le déclenchement d'un relais avec une temporisation de 40 Sec.
le cycle recommence tant que le niveau réglé n'est pas atteint, ou bien tant que le niveau d'eau de la cuve est bon, ou bien si il ne fait pas nuit.
Trois LED RJV donnent le niveau d'humidité de la terre, avec un buzzer qui bip à chaque démarrage de la pompe, ou bien s'il n'y a plus assez d'eau. dans la cuve

Quelques photos:




Le "capteur" de niveau est simplement deux fils de cuivre collés le long de la pompe.




La sonde d'humidité est aussi deux fils de cuivre collés dans le boitier, mais le mieux serait deux fils inox à cause de l'oxydation rapide sur le cuivre.

Je n'arrive pas à insérer les fichiers KICAD, si vous êtes intéressé je vous les envérais par MP. ou-bien en PDF  

Le code suit ce poste (autre PC)

Code: [Select]
/* Arrosage automatique avec fonction veille
Juin 2017  */

#include <avr/sleep.h>
#include <avr/power.h>
#include <avr/wdt.h>

 volatile int f_wdt = 1;             
 int coef = 0;
 const int nbcoef = 1; // nb de fois 8 secondes

    unsigned long valtemps;
    unsigned long debuttemps;
    unsigned long fintemps;
    int relais = 2;
    int buzer = 6;
    int led = 13;
    int ledrouge = 9;
    int ledjaune = 7;
    int ledverte = 8;
   
    int reglage = A0;
    int eclairage = A1;
    int humidite= A6;
    int nivcuve = A7;

     int valhumidite = 0;
     int valreglage = 0;
     int valnivcuve = 0;
     int valeclairage = 200;
      int cas = 0;
     
void setup() {
 
 pinMode(led, OUTPUT);
 pinMode ( ledrouge, OUTPUT); // sortie rouge
 pinMode ( ledverte, OUTPUT); // sortie vert
 pinMode ( ledjaune, OUTPUT); // sortie jaune
 pinMode ( buzer, OUTPUT); // sortie beep
 pinMode ( relais, OUTPUT); // sortie relais pompe
 
 pinMode(humidite, INPUT);
 pinMode (reglage, INPUT);
 pinMode (nivcuve, INPUT);
 pinMode (eclairage, INPUT);
 
  valhumidite = 0;
  valreglage = 0;
  valnivcuve = 30; // valeur de niveau cuve mini pour arret de pompopage
  valeclairage = 70; // niveau d'eclairage
 
 valtemps = 40000;    // 1000 par seconde  600000 par minute TEMPS DE POMPAGE
 
  digitalWrite(ledrouge,HIGH); delay (500); digitalWrite(ledrouge,LOW);
  digitalWrite(buzer,HIGH); delay (1000); digitalWrite(buzer,LOW);
 //****************************************************************************
 // paramètre : 0=16ms, 1=32ms, 2=64ms, 3=128ms, 4=250ms,
//           : 5=500ms, 6=1 sec,7=2 sec, 8=4 sec, 9=8 sec
  setup_watchdog(9);
 Serial.begin(9600);
 //****************************************************************************
}

void loop() {      //****************************************************************************

  if (f_wdt == 1) { // mode travail
  if (coef <= nbcoef) { coef ++;  f_wdt = 0; enterSleep(); }
  else{ 
 
 // affichage des mesures pour contrôles
 /*       Serial.println(" ");
        Serial.print(analogRead(humidite));
        Serial.print(" H  ");
        Serial.print (analogRead(reglage)); Serial.println(" : ");
       
        Serial.print(analogRead(nivcuve));
        Serial.print(" C  ");
        Serial.print (valnivcuve); Serial.println(" :: ");
       
        Serial.print(analogRead(eclairage));
        Serial.print(" E  ");
        Serial.print (valeclairage); Serial.println(" ::: ");
  */
   valhumidite = analogRead(humidite);
   valreglage = analogRead(reglage);
     
   if (valhumidite < valreglage) { cas = 2;}  // JAUNE
   if (valhumidite > valreglage) { cas = 3;}  // ROUGE
   if (valhumidite < (valreglage - 200)) { cas = 1; } // VERT
   
   switch (cas) {
          case 1 : digitalWrite(ledverte,HIGH); delay (150); digitalWrite(ledverte,LOW); break;
         
          case 2 :  digitalWrite(ledjaune,HIGH); delay (150); digitalWrite(ledjaune,LOW); break;
   
          case 3 : digitalWrite(ledrouge,HIGH); delay (150); digitalWrite(ledrouge,LOW);
                   digitalWrite(buzer,HIGH); delay (50); digitalWrite(buzer,LOW);
                   if ((analogRead(nivcuve) >= valnivcuve) && (analogRead(eclairage) >= valeclairage)) {
                       debuttemps = millis(); fintemps = debuttemps + valtemps ; f_wdt == 1;
             while ((millis() <= fintemps) && (analogRead(humidite) >= (analogRead(reglage))) && (analogRead(nivcuve) >= valnivcuve)) {
               digitalWrite(led,HIGH); digitalWrite(relais,HIGH); delay(1000);
                   } }
              digitalWrite(led,LOW); digitalWrite(relais,LOW);             
             break;     
      }
    fintemps = 0;   
           
  coef = 0;
    f_wdt = 0; // Ne pas oublier d'initialiser le flag, sinon pas de sommeil
    enterSleep(); //Revenir en mode veille
 } } // fin d'if travail
} // fin de loop  // ============================================================================

  // Watchdog Interrupt Service est exécité lors d'un timeout du WDT
ISR(WDT_vect)
{
  if (f_wdt == 0)
  { f_wdt = 1; } // flag global
  }
//*************************************************************
// paramètre : 0=16ms, 1=32ms, 2=64ms, 3=128ms, 4=250ms,
//           : 5=500ms, 6=1 sec,7=2 sec, 8=4 sec, 9=8 sec
void setup_watchdog(int ii) {
  byte bb;
  int ww;
  if (ii > 9 ) ii = 9;   // pour 8 secondes
  bb = ii & 7;
  if (ii > 7) bb |= (1 << 5);
  bb |= (1 << WDCE);
  ww = bb;
  // Clear the reset flag
  MCUSR &= ~(1 << WDRF);
  // start timed sequence
  WDTCSR |= (1 << WDCE) | (1 << WDE);
  // set new watchdog timeout value
  WDTCSR = bb;
  WDTCSR |= _BV(WDIE);
}

void enterSleep(void) {
  //digitalWrite(led, LOW);
  //Serial.print("   je dort  ");
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_enable();
  sleep_mode(); //Entre dans le mode veille choisi
  //le micro passe en sommeil pour x secondes
  // Le programme va reprendre ici après le timeout du WDT
  sleep_disable(); // La 1ère chose à faire est de désactiver le mode veille
  //Serial.println("..............fin sommeil ");
}

icare

Bonjour,
Je n'arrive pas à insérer les fichiers KICAD, si vous êtes intéressé je vous les envérais par MP. ou-bien en PDF   
Tu peux mettre le fichier comprimé en zip par exemple
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

Fadoul

bonjour!je suis vraiment intéresser par votre projet,et j,aimerai le réalisé chez moi.merci de me contacter sur mon mail: hisseinabba@gmail.com
j'aimerai vous demandez quelque détaille.

HG89

Bonjour
 Quel renseignements voulez vous ?

HG89

Merci,

Je viens de développer et mettre au point le module avec commandes par Bluetooth avec une bonne évolution.
Je le met en ligne rapidement.

megabombus

Bonjour HG89

Très bon projet, je suis moi même sur un petit projet d'arrosage mais moins "sophistiqué".

serait-il possible d'avoir la liste des composants et les connections ?

Et sans abuser, avoir également la version Bluetooth ?

merci et encore félicitations

Mégabombus

Go Up