Go Down

Topic: Lire deux capteur d'humidité a intervalle différent non bloquant. (Read 502 times) previous topic - next topic

gwest77

Bonjour,

Je sais que le sujet a surement déjà été traité plusieurs fois, mais je sollicite votre aide concernant la possibilité de pouvoir lire deux capteurs d'humidité a des intervalles différents :

Exemple :

Lire le capteur 1 toutes les 4 secondes.
En même temps lire le capteur 2 toutes les 5 minutes


Jai vu ici qu'il y avait la possibilite : http://gammon.com.au/blink

Cependant, je ne vois pas comment et quoi remplacer dans mon code pour que cela fonctionne.

Il y a un capteur qui est utilisé pour vérifier le niveau de l'eau dans un canal d'arrosage "canal"
Et un autre pour vérifier l'humidité du sol "capthumidite"


Voici mon code :
Code: [Select]

const int prog = 11; // programateur
const int canal = 10; // niveau d'eau canal
const int pompe = 9; // relais pompe
const int capthumidite = 8; // détecteur d'humidité numéro 1
int ledhumide = 7;
int ledsec = 6;
int ledniveaucanalbas = 5;
int ledniveaucanalhaut = 4;
int ledprogramateur = 3;
int pumpLEDPin = 2; // Led  pompe verte




void setup()
{
  // Configure la broche avec la résistance de tirage
  pinMode(prog, INPUT);  //   programateur
  pinMode(canal, INPUT); // niveau d'eau du canal
  pinMode(pompe, OUTPUT); // pompe est une broche de sortie
  pinMode(capthumidite, INPUT); // détecteur d'humidité
  pinMode(ledhumide, OUTPUT);
  pinMode(ledsec, OUTPUT);
  pinMode(ledniveaucanalbas, OUTPUT);
  pinMode(ledniveaucanalhaut, OUTPUT);
  pinMode(ledprogramateur, OUTPUT);
  pinMode(pumpLEDPin, OUTPUT);

}



void loop()
{



  // Récupération de l'état détecteur humidité
  int humidite = digitalRead(capthumidite); // Lecture de l etat du détecteur 1
  int programateur = digitalRead(prog); // Lecture de l etat du programateur
  int niveaucanal = digitalRead(canal); // Lecture de l etat du du niveau d'eau canal






  if  (humidite == HIGH) {
    digitalWrite(ledhumide, LOW); // Eteindre LED humide
    digitalWrite(ledsec, HIGH); // Allumer Led sec
  }

  if  (humidite == LOW) {
    digitalWrite(ledsec, LOW); // Eteindre Led sec
    digitalWrite(ledhumide, HIGH); // Allumer LED humide
  }

  if  ((niveaucanal) == HIGH) {
    digitalWrite(ledniveaucanalbas, HIGH); // Eteindre LED niveau canal bas
    digitalWrite(ledniveaucanalhaut, LOW); // Allumer Led niveau canal haut
  }

  if  ((niveaucanal) == LOW) {
    digitalWrite(ledniveaucanalbas, LOW); // Eteindre Led niveau canal bas
    digitalWrite(ledniveaucanalhaut, HIGH); // Allumer LED niveau canal haut
  }

  if  ((programateur) == HIGH) {
    digitalWrite(ledprogramateur, LOW); // Allumer Led programateur
  }
  else  {
    digitalWrite(ledprogramateur, HIGH);// Sinon éteindre Led programateur

  }




  // Agir en fonction de l'état des parametres
  if ((humidite == HIGH)&&(niveaucanal == LOW)&&(programateur == LOW))
  {
    digitalWrite(pompe, LOW);
    digitalWrite(pumpLEDPin, HIGH); // Allumer Led pompe
  }
  else
  {
    digitalWrite(pompe, HIGH);
    digitalWrite(pumpLEDPin, LOW); // Eteindre Led pompe
  }







  delay(4000); // Attendre 4 seconde (prendre des mesures toutes les 4 secondes)
}

hbachetti

Zéro réponse ...
Le problème est probablement trop simple.

Je ne vois pas trop où est le besoin "non bloquant".

Le plus simple dans ton cas serait d'ajouter un compteur, un simple integer global ou statique dans la fonction loop(), et de lire le deuxième capteur que le compteur atteint la valeur 75.
5mn = 4s * 75

Mais si tu tiens absolument à traiter en non bloquant :

Dans le lien que tu fournis, il te suffit de remplacer les périodes par les tiennes :
Code: [Select]

const unsigned long greenLEDinterval = 500;
const unsigned long redLEDinterval = 1000;
// remplacer par
const unsigned long greenLEDinterval = 4000;
const unsigned long redLEDinterval = 300000;

Et ensuite d'utiliser les deux fonctions toggleGreenLED() et toggleRedLED() pour faire tes mesures.
Code: [Select]

void toggleGreenLED ()
{
  // LIRE PREMIER CAPTEUR
  greenLEDtimer = millis (); 
}

void toggleRedLED ()
{
  // LIRE DEUXIEME CAPTEUR
  redLEDtimer = millis (); 
}


Je te laisse le soin de donner aux variables et fonctions des noms plus en rapport avec le sujet.

Linux is like a wigwam: no Windows, no Gates, and an Apache inside ...

gwest77

Bonjour, merci pour la réponse,

J'ai essayé avec un bout de code "timer" :

Je voulais savoir si cela fonctionnerais ?

Par contre, est-ce que le "   delay(1000 - SENSOR_DELAY);  va me bloquer le code?

Code: [Select]
const int canal = 10; // niveau d'eau canal
const int pompe = 9; // relais pompe
const int capthumidite = 8; // détecteur d'humidité numéro 1
const int power = 12; // alimentation capteur humidité sur pin 12
int ledhumide = 7;
int ledsec = 6;
int ledniveaucanalbas = 5;
int ledniveaucanalhaut = 4;
const int ledprogramateur = 3;
int pumpLEDPin = 2; // Led  pompe verte

// Define our timer.
const int TIMER = 300; // in seconds
const int RESET = TIMER - 1;
const int SENSOR_DELAY = 10; // in milliseconds
int counter;


void setup()
{
  // Configure la broche avec la résistance de tirage
  Serial.begin(9600);
  pinMode(canal, INPUT); // niveau d'eau du canal
  pinMode(pompe, OUTPUT); // pompe est une broche de sortie
  pinMode(capthumidite, INPUT); // détecteur d'humidité
  pinMode(power, OUTPUT);
  pinMode(ledhumide, OUTPUT);
  pinMode(ledsec, OUTPUT);
  pinMode(ledniveaucanalbas, OUTPUT);
  pinMode(ledniveaucanalhaut, OUTPUT);
  pinMode(ledprogramateur, OUTPUT);
  pinMode(pumpLEDPin, OUTPUT);

  // Start with sensor OFF
  digitalWrite(power, LOW);

  // Setup timer.
  counter = RESET;

}



void loop()
{


  digitalWrite(ledprogramateur, HIGH); // Allumer Led programateur


  int niveaucanal = digitalRead(canal); // Lecture de l etat du du niveau d'eau canal
  int humidite = digitalRead(capthumidite); // Lecture de l etat du détecteur 1


  // If the counter is at the end of a cycle
  // take a new reading and reset counter.
  if (counter <= 0) {
    // Turn sensor ON and wait a moment.
    digitalWrite(power, HIGH);
    delay(SENSOR_DELAY);

    // Take reading, send to plotter.
    Serial.println(analogRead(capthumidite));

    if  (humidite == LOW) {
      digitalWrite(ledhumide, HIGH); // Allumer LED humide
      digitalWrite(ledsec, LOW); // Eteindre Led sec
    }

    if  (humidite == HIGH) {
      digitalWrite(ledsec, HIGH); // Allumer Led sec
      digitalWrite(ledhumide, LOW); // Eteindre LED humide
    }

    // Turn sensor OFF again.
    digitalWrite(power, LOW);

    // Start new countdown.
    counter = RESET;
  }

  // If counter isn't at the end yet, pause for
  // the same amount of time as if the sensor
  // had been activated to keep things in sync.
  else {
    delay(SENSOR_DELAY);
  }

  // Decrement counter and delay until next second.
  counter--;
  delay(1000 - SENSOR_DELAY);




  if  ((niveaucanal) == HIGH) {
    digitalWrite(ledniveaucanalbas, HIGH); // Allumer LED niveau canal bas
    digitalWrite(ledniveaucanalhaut, LOW); // Eteindre Led niveau canal haut
  }

  if  ((niveaucanal) == LOW) {
    digitalWrite(ledniveaucanalbas, LOW); // Eteindre Led niveau canal bas
    digitalWrite(ledniveaucanalhaut, HIGH); // Allumer LED niveau canal haut
  }






  // Agir en fonction de l'état des parametres
  if ((humidite == HIGH) && (niveaucanal == LOW))
  {
    digitalWrite(pompe, LOW);
    digitalWrite(pumpLEDPin, HIGH); // Allumer Led pompe
  }
  else
  {
    digitalWrite(pompe, HIGH);
    digitalWrite(pumpLEDPin, LOW); // Eteindre Led pompe
  }







  delay(5000); // Attendre 5 seconde (prendre des mesures toutes les 5 secondes)
}

infobarquee

bonjour,
un delay est bloquant, la question ne se pose même pas.
AUCUNE AIDE PAR MP

THENICK

Hello !

Il y a bien la fonction "millis" qui compte les millisecondes en temps réel, mais je n'ai pas réussi à la faire fonctionner correctement. Du coup je pense avoir trouvé mieux avec: "Metro"
C'est une fonction avancée non bloquante pour réaliser des actions à intervalles réguliers.

En gros, ça compte le temps (depuis le démarrage de ton code) en milliseconde et ça relève régulièrement le temps écoulé.
Tant que ton intervalle n'est pas atteint, il passe. Lorsqu'il est atteint (ou dépassé), tu peux engager l'action désirée. Il y a la possibilité de remettre à zéro et/ou de changer l'intervalle mesuré.

tu peux aller jeter un oeil ici : https://www.pjrc.com/teensy/td_libs_Metro.html

sinon je t'ai préparé un truc comme ça :


Code: [Select]
#include <Metro.h>
Metro mesureCanal = Metro(4000); //objet qui a pour but de "mesurer" les 4 secondes
Metro mesureSol = Metro(300000); //objet qui a pour but de "mesurer" les 5 minutes


void loop()
{

//**********************************************************  FONCTION CANAL   *******

  if (mesureCanal.check() == 1)  // vérifie si mesureCanal a dépassé son intervalle
  {
    // si oui, alors je fais la mesure du niveau d'eau du canal
     }
    else
    {
      // si non, Blabla
    }
  }

//**********************************************************  FONCTION SOL  ****************

  if (mesureSol.check() == 1)  // vérifie si mesureSol a dépassé son intervalle
  {
    // si oui, alors je fais la mesure de l'humidité du sol
     }
    else
    {
      // si non, Blabla
    }
  }

//**********************************************************  FONCTION SOL  ****************


// ICI TU PEUX METTRE TOUT LE RESTE DE TON CODE AVEC TOUTES TES FONCTIONNALITES QUASI A L'IDENTIQUE



}


du coup tu n'es pas obligé de les lancer en même temps, ni même de placer ces deux blocs de code au même endroit de ton propre code, à la limite peu importe où tu les place, pourvu que ton programme balaye régulièrement ces fonctions. à chaque passage, ça ne prends qu'un temps-machine infinitésimal

je te laisse le soin de débugger tout ça avec ton code ^^

NiCk

J-M-L

Pas la peine de sortir l'artillerie lourde, la réponse #1 était bien....
Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums
Pas de messages privés SVP

gwest77

Bonjour hbachetti,



J'ai réécris mon code  cependant, si je sépare la lecture des capteurs et que je met l'autre partie dans le loop, j'ai alors l'erreur suivante :

"exit status 1
'humidite' was not declared in this scope"

Alors du coup je n'aurais pas du faire comme j'ai fait?

Code: [Select]
const int canal = 10; // niveau d'eau canal
const int pompe = 9; // relais pompe
const int capthumidite = 8; // détecteur d'humidité numéro 1
int ledhumide = 7;
int ledsec = 6;
int ledniveaucanalbas = 5;
int ledniveaucanalhaut = 4;
const int ledprogramateur = 3;
int pumpLEDPin = 2; // Led  pompe verte

// Time periods of blinks in milliseconds (1000 to a second).
const unsigned long canalinterval = 4000;
const unsigned long capthumiditeinterval = 300000;

// Variable holding the timer value so far. One for each "Timer"
unsigned long canaltimer;
unsigned long capthumiditetimer;

void setup ()
{
  // Configure la broche avec la résistance de tirage
  Serial.begin(9600);
  pinMode (canal, INPUT); // entrée capteur niveau canal
  pinMode (capthumidite, INPUT); // entrée capteur sol humidité
  pinMode(pompe, OUTPUT); // pompe est une broche de sortie
  pinMode(ledhumide, OUTPUT);
  pinMode(ledsec, OUTPUT);
  pinMode(ledniveaucanalbas, OUTPUT);
  pinMode(ledniveaucanalhaut, OUTPUT);
  pinMode(ledprogramateur, OUTPUT);
  pinMode(pumpLEDPin, OUTPUT);
  canaltimer = millis ();
  capthumiditetimer = millis ();
}  // end of setup

void togglecanal ()
{

  int niveaucanal = digitalRead(canal); // Lecture de l etat du du niveau d'eau canal


  // remember when we toggled it
  canaltimer = millis ();
}  // end of toggleGreenLED

void togglecapthumidite ()
{


  int humidite = digitalRead(capthumidite); // Lecture de l etat du détecteur 1


  // remember when we toggled it
  capthumiditetimer = millis ();
}  // end of toggleRedLED

void loop ()
{

  // Handling the blink of one LED.
  if ( (millis () - canaltimer) >= canalinterval)
    togglecanal ();

  // The other LED is controlled the same way. Repeat for more LEDs
  if ( (millis () - capthumiditetimer) >= capthumiditeinterval)
    togglecapthumidite ();

  /* Other code that needs to execute goes here.
     It will be called many thousand times per second because the above code
     does not wait for the LED blink interval to finish. */

     
  digitalWrite(ledprogramateur, HIGH); // Allumer Led programateur








  if  (humidite == LOW) {
    digitalWrite(ledhumide, HIGH); // Allumer LED humide
    digitalWrite(ledsec, LOW); // Eteindre Led sec
  }

  if  (humidite == HIGH) {
    digitalWrite(ledsec, HIGH); // Allumer Led sec
    digitalWrite(ledhumide, LOW); // Eteindre LED humide
  }

  if  ((niveaucanal) == HIGH) {
    digitalWrite(ledniveaucanalbas, HIGH); // Allumer LED niveau canal bas
    digitalWrite(ledniveaucanalhaut, LOW); // Eteindre Led niveau canal haut
  }

  if  ((niveaucanal) == LOW) {
    digitalWrite(ledniveaucanalbas, LOW); // Eteindre Led niveau canal bas
    digitalWrite(ledniveaucanalhaut, HIGH); // Allumer LED niveau canal haut
  }






  // Agir en fonction de l'état des parametres
  if ((humidite == HIGH) && (niveaucanal == LOW))
  {
    digitalWrite(pompe, LOW);
    digitalWrite(pumpLEDPin, HIGH); // Allumer Led pompe
  }
  else
  {
    digitalWrite(pompe, HIGH);
    digitalWrite(pumpLEDPin, LOW); // Eteindre Led pompe
  }







  delay(5000); // Attendre 4 seconde (prendre des mesures toutes les 4 secondes)

}  // end of loop

lesept

C'est normal, tu définis les variables humidite et niveaucanal comme variables locales des fonctions togglecanal () et togglecapthumidite ()
Si tu veux les utiliser dans la loop, il faut soit les définir en variables globales (avant le setup) soit les renvoyer en sortie de tes fonctions.

Une petite coquille au passage :
Code: [Select]
  delay(5000); // Attendre 4 seconde (prendre des mesures toutes les 4 secondes)le delay(5000) attend 5 secondes, pas 4.
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

gwest77

Donc, j'ai mis avant le setup :

Code: [Select]
int niveaucanal = digitalRead(canal); // Lecture de l etat du du niveau d'eau canal
int humidite = digitalRead(capthumidite); // Lecture de l etat du détecteur 1




ET par contre dans les deux "void" je laisse juste cela : ?
Code: [Select]
void togglecanal ()
{



  // remember when we toggled it
  canaltimer = millis ();
}  // end of toggleGreenLED

void togglecapthumidite ()
{





  // remember when we toggled it
  capthumiditetimer = millis ();
}  // end of toggleRedLED

lesept

Non, tu ne peux pas faire de lecture avant le setup. Tu fais juste des déclarations :
Code: [Select]
int niveaucanal; // état du du niveau d'eau canal
int humidite; // état du détecteur 1
Oui pour les deux fonctions.
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

gwest77

Et les deux digitalread je les enlèves?

Code: [Select]
digitalRead(canal); // Lecture de l etat du du niveau d'eau canal
digitalRead(capthumidite); // Lecture de l etat du détecteur 1


Voici mon code final :
Code: [Select]

const int canal = 10; // niveau d'eau canal
const int pompe = 9; // relais pompe
const int capthumidite = 8; // détecteur d'humidité numéro 1
int ledhumide = 7;
int ledsec = 6;
int ledniveaucanalbas = 5;
int ledniveaucanalhaut = 4;
const int ledprogramateur = 3;
int pumpLEDPin = 2; // Led  pompe verte

// Time periods of blinks in milliseconds (1000 to a second).
const unsigned long canalinterval = 4000;
const unsigned long capthumiditeinterval = 300000;

// Variable holding the timer value so far. One for each "Timer"
unsigned long canaltimer;
unsigned long capthumiditetimer;

int niveaucanal; // état du du niveau d'eau canal
int humidite; // état du détecteur 1



void setup ()
{
  // Configure la broche avec la résistance de tirage
  Serial.begin(9600);
  pinMode (canal, INPUT); // entrée capteur niveau canal
  pinMode (capthumidite, INPUT); // entrée capteur sol humidité
  pinMode(pompe, OUTPUT); // pompe est une broche de sortie
  pinMode(ledhumide, OUTPUT);
  pinMode(ledsec, OUTPUT);
  pinMode(ledniveaucanalbas, OUTPUT);
  pinMode(ledniveaucanalhaut, OUTPUT);
  pinMode(ledprogramateur, OUTPUT);
  pinMode(pumpLEDPin, OUTPUT);
  canaltimer = millis ();
  capthumiditetimer = millis ();
}  // end of setup

void togglecanal ()
{



  // remember when we toggled it
  canaltimer = millis ();
}  // end of toggleGreenLED

void togglecapthumidite ()
{





  // remember when we toggled it
  capthumiditetimer = millis ();
}  // end of toggleRedLED

void loop ()
{

  // Handling the blink of one LED.
  if ( (millis () - canaltimer) >= canalinterval)
    togglecanal ();

  // The other LED is controlled the same way. Repeat for more LEDs
  if ( (millis () - capthumiditetimer) >= capthumiditeinterval)
    togglecapthumidite ();

  /* Other code that needs to execute goes here.
     It will be called many thousand times per second because the above code
     does not wait for the LED blink interval to finish. */


  digitalWrite(ledprogramateur, HIGH); // Allumer Led programateur








  if  (humidite == LOW) {
    digitalWrite(ledhumide, HIGH); // Allumer LED humide
    digitalWrite(ledsec, LOW); // Eteindre Led sec
  }

  if  (humidite == HIGH) {
    digitalWrite(ledsec, HIGH); // Allumer Led sec
    digitalWrite(ledhumide, LOW); // Eteindre LED humide
  }

  if  ((niveaucanal) == HIGH) {
    digitalWrite(ledniveaucanalbas, HIGH); // Allumer LED niveau canal bas
    digitalWrite(ledniveaucanalhaut, LOW); // Eteindre Led niveau canal haut
  }

  if  ((niveaucanal) == LOW) {
    digitalWrite(ledniveaucanalbas, LOW); // Eteindre Led niveau canal bas
    digitalWrite(ledniveaucanalhaut, HIGH); // Allumer LED niveau canal haut
  }






  // Agir en fonction de l'état des parametres
  if ((humidite == HIGH) && (niveaucanal == LOW))
  {
    digitalWrite(pompe, LOW);
    digitalWrite(pumpLEDPin, HIGH); // Allumer Led pompe
  }
  else
  {
    digitalWrite(pompe, HIGH);
    digitalWrite(pumpLEDPin, LOW); // Eteindre Led pompe
  }







  delay(5000); // Attendre 5 seconde (prendre des mesures toutes les 5 secondes)

}  // end of loop

lesept

NOOOOOOON !!!

Si tu les enlèves, tu ne peux pas connaitre tes niveaux. Laisse les fonctions avec les digitalRead comme ils étaient.

Code: [Select]
void togglecanal ()
{

  int niveaucanal = digitalRead(canal); // Lecture de l etat du du niveau d'eau canal


  // remember when we toggled it
  canaltimer = millis ();
}  // end of togglecanal

void togglecapthumidite ()
{


  int humidite = digitalRead(capthumidite); // Lecture de l etat du détecteur 1


  // remember when we toggled it
  capthumiditetimer = millis ();
}  // end of togglecapthumidite
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

gwest77

Désolé, je suis un peu long a comprendre  :o

Merci pour l'aide apportés, n'étant pas sur place, je testerais le tout dans les semaines a venir.

Je souhaitais définir un délais de mesure, surtout pour le capteur d'humidité car sinon il y a des allumage et arrêts intempestifs de la pompe le temps de la stabilisation de la mesure de l'humidité du sol, surtout quand il y a apport d'eau a la terre.

Mon système active une pompe de 1.5kw et irrigue 1000m2 de potager.
Le panneau de commande a un inter 3 positions, avec une position manuelle et automatique(arduino)
Un arret d''urgence et les leds qui indiquent le fonctionnement.

Elle s'allume quand le programmateur mécanique allume l'arduino et vérifie les capteurs.
Elle s'éteint quand l'humidité de la terre est atteinte ou bien que le programmateur arrête l'arduino ou bien quand le niveau d'eau du canal est trop bas ( car le débit d'eau du canal varie parfois au long de la journée)




lesept

A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

gwest77

Bonjour,

Alors, j'ai essayé , mais cela ne fonctionne pas. Quand je change d'état le niveau du canal après 4 secondes il n'y a pas de changement d'état des leds et du relais. Disons que si il y a changement d'état sur le pin 10 (entrée), la led niveau bas ou niveau haut canal doit changer dans les 4 secondes.

J'ai l'impression que mon code ne s'exécute pas.

Voici le code final utilisé :

Code: [Select]
const int canal = 10; // niveau d'eau canal
const int pompe = 9; // relais pompe
const int capthumidite = 8; // détecteur d'humidité numéro 1
int ledhumide = 7;
int ledsec = 6;
int ledniveaucanalbas = 5;
int ledniveaucanalhaut = 4;
const int ledprogramateur = 3;
int pumpLEDPin = 2; // Led  pompe verte

// Time periods  in milliseconds (1000 to a second).
const unsigned long canalinterval = 4000;
const unsigned long capthumiditeinterval = 300000;

// Variable holding the timer value so far. One for each "Timer"
unsigned long canaltimer;
unsigned long capthumiditetimer;

int niveaucanal; // état du du niveau d'eau canal
int humidite; // état du détecteur 1


void setup ()
{
  // Configure la broche avec la résistance de tirage
  Serial.begin(9600);
  pinMode (canal, INPUT); // entrée capteur niveau canal
  pinMode (capthumidite, INPUT); // entrée capteur sol humidité
  pinMode(pompe, OUTPUT); // pompe est une broche de sortie
  pinMode(ledhumide, OUTPUT);
  pinMode(ledsec, OUTPUT);
  pinMode(ledniveaucanalbas, OUTPUT);
  pinMode(ledniveaucanalhaut, OUTPUT);
  pinMode(ledprogramateur, OUTPUT);
  pinMode(pumpLEDPin, OUTPUT);
  canaltimer = millis ();
  capthumiditetimer = millis ();
}  // end of setup

void togglecanal ()
{

int niveaucanal = digitalRead(canal); // Lecture de l etat du du niveau d'eau canal

  // remember when we toggled it
  canaltimer = millis ();
}  // end of togglecanal

void togglecapthumidite ()
{


int humidite = digitalRead(capthumidite); // Lecture de l etat du détecteur 1


  // remember when we toggled it
  capthumiditetimer = millis ();
}  // end of togglecapthumidite

void loop ()
{

  // Handling the blink of one sensor
  if ( (millis () - canaltimer) >= canalinterval)
    togglecanal ();

  // The other sensor is controlled the same way. Repeat for more sensors
  if ( (millis () - capthumiditetimer) >= capthumiditeinterval)
    togglecapthumidite ();

  /* Other code that needs to execute goes here.
     It will be called many thousand times per second because the above code
     does not wait for the sensor blink interval to finish. */


  digitalWrite(ledprogramateur, HIGH); // Allumer Led programateur








  if  (humidite == LOW) {
    digitalWrite(ledhumide, HIGH); // Allumer LED humide
    digitalWrite(ledsec, LOW); // Eteindre Led sec
  }

  if  (humidite == HIGH) {
    digitalWrite(ledsec, HIGH); // Allumer Led sec
    digitalWrite(ledhumide, LOW); // Eteindre LED humide
  }

  if  ((niveaucanal) == HIGH) {
    digitalWrite(ledniveaucanalbas, HIGH); // Allumer LED niveau canal bas
    digitalWrite(ledniveaucanalhaut, LOW); // Eteindre Led niveau canal haut
  }

  if  ((niveaucanal) == LOW) {
    digitalWrite(ledniveaucanalbas, LOW); // Eteindre Led niveau canal bas
    digitalWrite(ledniveaucanalhaut, HIGH); // Allumer LED niveau canal haut
  }






  // Agir en fonction de l'état des parametres
  if ((humidite == HIGH) && (niveaucanal == LOW))
  {
    digitalWrite(pompe, LOW);
    digitalWrite(pumpLEDPin, HIGH); // Allumer Led pompe
  }
  else
  {
    digitalWrite(pompe, HIGH);
    digitalWrite(pumpLEDPin, LOW); // Eteindre Led pompe
  }





  delay(5000); // Attendre 5 seconde (prendre des mesures toutes les 5 secondes)



}  // end of loop

Go Up