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)
/* 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 ");
}
arrosage-1.pdf (18.3 KB)
arrosage-2.pdf (16.5 KB)