Arduino Forum

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 :
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)
}

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 :

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.

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.

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?

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)
}

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

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 :


#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

Pas la peine de sortir l'artillerie lourde, la réponse #1 était bien....

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?

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

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 :
  delay(5000); // Attendre 4 seconde (prendre des mesures toutes les 4 secondes)le delay(5000) attend 5 secondes, pas 4.

Donc, j'ai mis avant le setup :

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 : ?void togglecanal ()
{



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

void togglecapthumidite ()
{





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

Non, tu ne peux pas faire de lecture avant le setup. Tu fais juste des déclarations :
int niveaucanal; // état du du niveau d'eau canal
int humidite; // état du détecteur 1Oui pour les deux fonctions.

Et les deux digitalread je les enlèves?

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 :

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

NOOOOOOON !!!

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

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


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)

OK, alors bons tests et reviens dire si ça marche !

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é :

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

Je ne vois rien de mal dans ton code, la seule chose : tu peux ôter int dans ces deux lignes :
int humidite = digitalRead(capthumidite); // Lecture de l etat du détecteur 1
int niveaucanal = digitalRead(canal); // Lecture de l etat du du niveau d'eau canal
Si ça ne suffit pas, tu peux ajouter des Serial.print(millis()); dans les fonctions togglexxx pour voir s tu y passes bien après les temporisations

En effet, sans les int cela fonctionne mieux.

ET j'avais inversé "LOW" et High dans  le capteur d'humidité.

Tout fonctionne parfaitement.

Un Grand merci a lesept :)

Par contre j'ai rajouté du code dans le "setup" pour lire l'état des capteurs avant démarrage, car cela pouvait fausser la valeur d'un jour a l'autre (l'arduino s'allume tous les jours dans une plage horaire pour vérifier l'humidité.)

Disons que la lecture du capteur au démarrage était sur "sec" du coup la pompe s'allumait, et 3 minutes après la lecture du capteur humidité sol, la pompe s'arrêtait car le sol était en réalité mouillé.

Maintenant la lecture du capteur est directement sur sol mouillé. Donc a la prochaine lecture (3minutes après) le capteur vérifie si le sol est bien mouillé ou pas.

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

Et je me demandais si c'était possible que les leds témoins (humidité, sec, ) puissent s'allumer a la seconde près du changement d'état. c'est a dire qu'ils puissent s'allumer de suite sans délais millis.

Car maintenant, les leds s'allument 3 minutes après avoir mesuré l'humidité du sol

Mais que la pompe réagirait en fonction du millis.

Tout est possible - faut juste coder en fonction du besoin :)

Éventuellement jetez un œil à mon tuto Programmation Automate fini / Machine à état (http://forum.arduino.cc/index.php?topic=470879.0)

Il suffit de déplacer tes if dans la fonction concernée :
  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
  }déplacé dans togglecapthumidite qui devient :
void togglecapthumidite ()
{


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

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
  }

  // remember when we toggled it
  capthumiditetimer = millis ();
}  // end of togglecapthumiditeet même chose pour l'autre fonction

Alors, déplacer les "int" ne fonctionne pas. Les leds restent éteintes, je pense que c'est plus compliqué que ça.

Mais bon,, je pense laisser comme ça. Cela fonctionne bien.

Il y a juste le capteur d'humidité qui a tendance a  changer de résistivité a cause de la corrosion il me semble.

Je n'ai pas branché en Analogique car les valeurs variaient beaucoup trop et ne sont pas stables (le cable du capteur a une longueur de 6/7m. Il y a deux tiges en aluminium qui plongent dans le terre et qui sont fixés parallèlement par une plaque de plexiglas a une distance de 1.5cm).

Les 'if' pas les 'int'. Il faut vérifier que les variables ledsec et ledhumide sont globales (définies dans l'entête du code, avant le setup).

Au besoin poste le code en l'état actuel...

Oui les if et pas les int dsl.

Voici le code actuel :

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 = 3000;
const unsigned long capthumiditeinterval = 180000;

// 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);

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



  canaltimer = millis ();
  capthumiditetimer = millis ();




}  // end of setup

void togglecanal ()
{

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

  // remember when we toggled it
  canaltimer = millis ();

  Serial.print(millis());
}  // end of togglecanal

void togglecapthumidite ()
{


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


  // remember when we toggled it
  capthumiditetimer = millis ();

  Serial.print(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(3000); // Attendre 3 seconde (prendre des mesures toutes les 3 secondes)




}  // end of loop

Et quand tu déplaces ces lignes
  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
  }de la loop dans la fonction togglecapthumidite :
void togglecapthumidite ()
{


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

  if  (humidite == LOW) {
    digitalWrite(ledhumide, HIGH); // Allumer LED humide
    digitalWrite(ledsec, LOW); // Eteindre Led sec
  } else { // <-- petit changement au passage...
    digitalWrite(ledsec, HIGH); // Allumer Led sec
    digitalWrite(ledhumide, LOW); // Eteindre LED humide
  }

  // remember when we toggled it
  capthumiditetimer = millis ();

  Serial.print(millis());
}  // end of togglecapthumidite
ça n'allume pas les LEDs ?
Je ne vois pas pourquoi...

Au besoin, ajoute un
Serial.println(humidite);après le digitalRead pour voir ce que ça vaut.

Non les deux leds du capteur d'humidité restent éteinte, c'est peut etre parce que le toggle humidité se fait que toutes les trois minutes.?

Oui, le toggle humidité se fait toutes les 3 minutes et, avec la modification, les leds s'allument au moment de la mesur d'humidité.
Mais celle du niveau se fait toutes les 3 secondes, tu devrais voir les leds s'allumer plus souvent.

Tu peux enlever les deux lignes digitalRead du setup et les remplacer par les deux appels togglexxx