[Programmateur journalier] Detection d'un signal sortie d'un reveil activation pompe piscine

Bonjour,

Je souhaiterais détecter le signal d'un réveil, celui qui est connecté au buzzer. C'est un signal haché, si l'on branche une simple led a la place du buzzer, la led s'allume toutes les secondes.
je souhaiterais activer un relais quand le signal du réveil sonne (donne une tension qui fluctue pendant 2 minutes)
Cependant si je détecte le signal sur une entrée analogique, comme le signal fluctue et qu'il y a des moments ou la tension descend a 0v, l’Arduino le détecte comme si il n' a rien de branché a ses bornes et donne des tensions farfelue.. Auriez vous une solution ?

Faire une moyenne sur 2 ou 3 secondes

Oui en effet, j'y ai pensé, mais voici la différence de signal entre le reveil au repos et quand il y a un signal sortant des 2 fils sur lequel était branché le buzzer. Quand une led y est branché dessus, elle clignote 2 fois par seconde.

http://zebreak.free.fr/wp-content/uploads/signal.png

La différence entre les deux signaux ne sont pas flagrant, je doute que même une moyenne puisse faire la différence..

Je viens d'obtenir un signal beaucoup plus tranché avec non pas une mesure de la tension mais de l'intensité par l’intermédiaire d'une résistance et d'une led :

void setup() {
  Serial.begin(9600);
}
void loop() {
  int resultBinary = analogRead(A0);
  float resultVolts = resultBinary / 1023.0 * 5.0;
  float R = 22.0;
  float intensity = resultVolts / R * 1000; // x 1000 pour avoir le résultat en mA (milliampères)!
  Serial.println(intensity); // En milliampères
  delay(250);
}

Il faut peut être essayer de mettre une résistance de 10ko (ou 100ko) en parallèle pour charger la sortie. Les signaux obtenus sont peut être le résultat d'une connexion en l'air.

Avec le code précédent, j'arrive a détecter le signal.

Le but de ce projet c'est de créer une sorte de programmateur qui va metre en route la pompe de filtration de la piscine en fonction du signal de sortie du reveil et de la temperature de l'eau dont j'ai essayé de bricoler un code qui n'est pas encore fini, j'arrive a détecter le signal d'intensité en sortie du reveil et faire clignoter une led dès que le seuil d'intensité dépasse 0.8, j'ai pour le moment aussi la temperature qui s'affiche sur un lcd 16 x 2 en I2C :

#include <OneWire.h> //Librairie du bus OneWire
#include <DallasTemperature.h> //Librairie du capteur
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

const int broche4 = 4;

LiquidCrystal_I2C lcd(0x3F,16,2);  //l adresse 0x27 est a changé en fonction de votre écran
OneWire oneWire(10); //Bus One Wire sur la pin 10 de l'arduino
DallasTemperature sensors(&oneWire); //Utilistion du bus Onewire pour les capteurs
DeviceAddress sensorDeviceAddress; //Vérifie la compatibilité des capteurs avec la librairie

void setup(void){
 Serial.begin(9600); //Permet la communication en serial
 sensors.begin(); //Activation des capteurs
 sensors.getAddress(sensorDeviceAddress, 0); //Demande l'adresse du capteur à l'index 0 du bus
 sensors.setResolution(sensorDeviceAddress, 12); //Résolutions possibles: 9,10,11,12
 lcd.init();                      // initialize the lcd
 lcd.backlight();

}

void loop(void){
 sensors.requestTemperatures(); //Demande la température aux capteurs

 // Print a message to the LCD.
 
 
  lcd.setCursor(0,0);
  lcd.print("Temp eau piscine : ");
  lcd.setCursor(1,1);
  lcd.setCursor(6,1);
  lcd.print(sensors.getTempCByIndex(0));
  lcd.print(" C ");



   int resultBinary = analogRead(A0);
  float resultVolts = resultBinary / 1023.0 * 5.0;
  float R = 200.0;
  float intensity = resultVolts / R * 1000; // x 1000 pour avoir le résultat en mA (milliampères)!
  Serial.println(intensity); // En milliampères

  if (intensity > 0.8)
 { digitalWrite(broche4, HIGH); 
 }
  else
{
   digitalWrite(broche4, LOW); // la condition est fausse, donc je n'active pas la led ou relais
}

    }
 
 

J'ai essayé avec une resistance de 10k, mais les mesures sont toujours très instable quand il n'y a pas de signal :

Tension : 0.00 Volts
Tension : 0.00 Volts
Tension : 0.00 Volts
Tension : 0.14 Volts
Tension : 0.58 Volts
Tension : 1.32 Volts
Tension : 2.15 Volts
Tension : 4.74 Volts
Tension : 5.00 Volts
Tension : 5.00 Volts
Tension : 3.92 Volts
Tension : 3.90 Volts
Tension : 3.33 Volts
Tension : 1.46 Volts
Tension : 1.91 Volts
Tension : 1.25 Volts
Tension : 5.00 Volts
Tension : 5.00 Volts
Tension : 5.00 Volts
Tension : 2.93 Volts

Je pense que la mesure de l'intensité avec une resistance et une led reste la meilleure solution

Voici le signal que j'obtiens en sortie du réveil, je me pose la question pourquoi l'arduino ne détecte pas le signal complet, en sortie en branchant une LED en direct, elle clignote 2 fois par seconde, et l'arduino ne détecte pas tous les signaux... pourquoi ?
Ensuite je souhaiterais que l'arduino puisse détecter tous les "pics" comme un seul signal, c'est a dire que si le réveil donne ces "pics" durant 2 minutes, cela puisse donner un ordre pour allumer un relais pendant quelques secondes ou plus. (une durée de temps) pourriez vous me dire comment procéder?

Voici le code qui fonctionne si on branche 4 relais a l'arduino et sur chaque relais une tempo avec trigger, l'arduino donne l'instruction d'activer chaque relais en fonction de la température et de l'impulsion du réveil.
En l'état, ce code fonctionne, le problème c'est que j'aimerais que le relais ne reste pas alimenté pendant 2 minutes.
Il faudrait pour cela une sorte d'auto-maintient court.. mais qui puisse détecter toutes les impulsions du reveil et ne sélectionner qu'une seule implusion sur le laps de temps des 2 minutes .

#include <OneWire.h> //Librairie du bus OneWire
#include <DallasTemperature.h> //Librairie du capteur
#include <LiquidCrystal_I2C.h>


const int TEMP_SUPERIEUR_16 = 16; // Limite basse temperature
const int TEMP_SUPERIEUR_24 = 24; // Limite basse temperature
const int TEMP_SUPERIEUR_27 = 27; // Limite basse temperature
const int TEMP_SUPERIEUR_30 = 30; // Limite basse temperature

const int relais1 = 4;     // Pin du relais4 pour temperature entre 16 et 24°C
const int relais2 = 5;     // Pin du relais5 pour temperature entre 24 et 27°C
const int relais3 = 6;     // Pin du relais6 pour temperature entre 27 et 30°C
const int relais4 = 7;     // Pin du relais7 pour temperature supérieure a 30°C

float temperature;    // temperature en Celsius
float intensity;    // Intensité

LiquidCrystal_I2C lcd(0x3F,16,2);  //l adresse 0x27 est a changé en fonction de votre écran
OneWire oneWire(10); //Bus One Wire sur la pin 10 de l'arduino
DallasTemperature sensors(&oneWire); //Utilistion du bus Onewire pour les capteurs
DeviceAddress sensorDeviceAddress; //Vérifie la compatibilité des capteurs avec la librairie

void setup(void){
 Serial.begin(9600); //Permet la communication en serial
 sensors.begin(); //Activation des capteurs
 sensors.getAddress(sensorDeviceAddress, 0); //Demande l'adresse du capteur à l'index 0 du bus
 sensors.setResolution(sensorDeviceAddress, 12); //Résolutions possibles: 9,10,11,12
 lcd.init();                      // initialize the lcd
 lcd.backlight();

}

void loop(void){
 sensors.requestTemperatures(); //Demande la température aux capteurs
 temperature = sensors.getTempCByIndex(0);  // lire temperature en Celsius
 

 // Print a message to the LCD.
 
 
  lcd.setCursor(0,0);
  lcd.print("Temp eau piscine : ");
  lcd.setCursor(1,1);
  lcd.setCursor(6,1);
  lcd.print(sensors.getTempCByIndex(0));
  lcd.print(" C ");



   int resultBinary = analogRead(A0);
  float resultVolts = resultBinary / 1023.0 * 5.0;
  float R = 200.0;
  float intensity = resultVolts / R * 1000; // x 1000 pour avoir le résultat en mA (milliampères)!
  Serial.println(intensity); // En milliampères





    if ((intensity > 3)&&(temperature <= TEMP_SUPERIEUR_16)) {
    Serial.println("Temperature inférieure a 16°C");
    Serial.println("Tous les relais sont désactivés");
        digitalWrite(relais1, LOW); // Relais Désactivé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
    
        
  } else if ((intensity > 3)&&(temperature > TEMP_SUPERIEUR_16  && temperature <= TEMP_SUPERIEUR_24)) {
    Serial.println(" Temperature entre 16°C et 24°C");
    Serial.println("Le relais 1 est activé");
        digitalWrite(relais1, HIGH);// Relais1 activé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
        delay(121000);
}

    else if ((intensity > 3)&&(temperature > TEMP_SUPERIEUR_24  && temperature <= TEMP_SUPERIEUR_27)) {
    Serial.println(" Temperature entre 24°C et 27°C");
    Serial.println("Le relais 2 est activé");
        digitalWrite(relais1, LOW);// Relais1 activé
        digitalWrite(relais2, HIGH); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
        delay(121000);
}

     else if ((intensity > 3)&&(temperature > TEMP_SUPERIEUR_27  && temperature <= TEMP_SUPERIEUR_30)) {
    Serial.println(" Temperature entre 27°C et 30°C");
    Serial.println("Le relais 3 est activé");
        digitalWrite(relais1, LOW);// Relais1 activé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, HIGH); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
        delay(121000);
}

         else if ((intensity > 3)&&(temperature > TEMP_SUPERIEUR_30)) {
    Serial.println(" Temperature supérieure a 30°C");
    Serial.println("Le relais 4 est activé");
        digitalWrite(relais1, LOW);// Relais1 activé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, HIGH); // Relais Désactivé
        delay(121000);
}

        else {      
        Serial.println("Attente signal reveil");  
        digitalWrite(relais1, LOW); // Relais Désactivé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
}


    }


hello, c'est un truc dans ce style qu'il te faut

unsigned long tempo_intermediaire = 1000;
unsigned long deb_tempo = 0.0;
void setup() {}

void loop() {
  if (sortie_reveil == High) 
  {
    deb_tempo = millis();
  }
  commande pompe();
}

void commande pompe()
{
  if ((millis() - deb_tempo) < tempo_intermediaire) //si < 1000 pompe ON
  {
    digitalWrite(pompe, HIGH);
  }
  else
  {
    digitalWrite(pompe, LOW);
  }
}

tant que la tempo n'est pas terminée, elle peut etre rearmée par une nouvelle impulsion
si ca ne va pas, il faudra passer par les interruptions pour voir et mémoriser les impulsions

pour que nous puissions regarder, redonnes nous ton code modifié

J'ai essayé juste la partie detection du signal, cela marchait bien, cela arrive au meme but que mon code original sauf que c'est non bloquant.

Et juste pour info, on est pas obligé de mettre une led ,on peut aussi mettre une resistance pour mesurer l'intensité qui la traverse. j'ai mis une résistance de 300 Ohm pour mesurer l'intensité du reveil, si il y a une coupure de courant, et que le réveil se rallume, il donne une impulsion en sortie d'une seconde. Il faut faire en sorte que cette impulsion ne soit pas détecté par l'arduino, mais que quand il sonne, pour activer les relais cela soit détecté.Il faut jouer avec le seuil de detection de l'arduino.

J'ai ensuite mis les taches a executer (relais) dans void relais, mais je crois qu'il faut tout mettre dans void loop`, en l'état, ce code ne fonctionne pas


#include <OneWire.h> //Librairie du bus OneWire
#include <DallasTemperature.h> //Librairie du capteur
#include <LiquidCrystal_I2C.h>


const int TEMP_SUPERIEUR_16 = 16; // Limite basse temperature
const int TEMP_SUPERIEUR_24 = 24; // Limite basse temperature
const int TEMP_SUPERIEUR_27 = 27; // Limite basse temperature
const int TEMP_SUPERIEUR_30 = 30; // Limite basse temperature

const int relais1 = 4;     // Pin du relais4 pour temperature entre 16 et 24°C
const int relais2 = 5;     // Pin du relais5 pour temperature entre 24 et 27°C
const int relais3 = 6;     // Pin du relais6 pour temperature entre 27 et 30°C
const int relais4 = 7;     // Pin du relais7 pour temperature supérieure a 30°C

float temperature;    // temperature en Celsius
float intensity;    // Intensité

LiquidCrystal_I2C lcd(0x3F,16,2);  //l adresse 0x27 est a changé en fonction de votre écran
OneWire oneWire(10); //Bus One Wire sur la pin 10 de l'arduino
DallasTemperature sensors(&oneWire); //Utilistion du bus Onewire pour les capteurs
DeviceAddress sensorDeviceAddress; //Vérifie la compatibilité des capteurs avec la librairie




unsigned long tempo_intermediaire = 1000;
unsigned long deb_tempo = 0.0;


void setup(void) {
  
 Serial.begin(9600); //Permet la communication en serial
 sensors.begin(); //Activation des capteurs
 sensors.getAddress(sensorDeviceAddress, 0); //Demande l'adresse du capteur à l'index 0 du bus
 sensors.setResolution(sensorDeviceAddress, 12); //Résolutions possibles: 9,10,11,12
 lcd.init();                      // initialize the lcd
 lcd.backlight();
  
  
  
  }

void loop(void) {


 sensors.requestTemperatures(); //Demande la température aux capteurs
 temperature = sensors.getTempCByIndex(0);  // lire temperature en Celsius
 

 // Print a message to the LCD.
 
 
  lcd.setCursor(0,0);
  lcd.print("Temp eau piscine : ");
  lcd.setCursor(1,1);
  lcd.setCursor(6,1);
  lcd.print(sensors.getTempCByIndex(0));
  lcd.print(" C ");

  int resultBinary = analogRead(A0);
  float resultVolts = resultBinary / 1023.0 * 5.0;
  float R = 200.0;
  float intensity = resultVolts / R * 1000; // x 1000 pour avoir le résultat en mA (milliampères)!
  Serial.println(intensity); // En milliampères



  
  if (intensity > 3)
  {
    deb_tempo = millis();
  }
  relaisA();
}

void relaisA(void)
{


    if (((millis() - deb_tempo) < tempo_intermediaire)&&(intensity > 3)&&(temperature <= TEMP_SUPERIEUR_16)) {
      
    Serial.println("Temperature inférieure a 16°C");
    Serial.println("Tous les relais sont désactivés");
    
        digitalWrite(relais1, LOW); // Relais Désactivé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
          
  } 
  
  else if (((millis() - deb_tempo) < tempo_intermediaire)&&(intensity > 3)&&(temperature <= TEMP_SUPERIEUR_24)) {
    Serial.println(" Temperature entre 16°C et 24°C");
    Serial.println("Le relais 1 est activé");
        digitalWrite(relais1, HIGH);// Relais1 activé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
        
}

    else if (((millis() - deb_tempo) < tempo_intermediaire)&&(intensity > 3)&&(temperature <= TEMP_SUPERIEUR_27)) {
    Serial.println(" Temperature entre 24°C et 27°C");
    Serial.println("Le relais 2 est activé");
        digitalWrite(relais1, HIGH);// Relais1 activé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
        
}

     else if (((millis() - deb_tempo) < tempo_intermediaire)&&(intensity > 3)&&(temperature <= TEMP_SUPERIEUR_30)) {
    Serial.println(" Temperature entre 27°C et 30°C");
    Serial.println("Le relais 3 est activé");
        digitalWrite(relais1, HIGH);// Relais1 activé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
        
}

         else if (((millis() - deb_tempo) < tempo_intermediaire)&&(intensity > 3)&&(temperature > TEMP_SUPERIEUR_30)) {
    Serial.println(" Temperature supérieure a 30°C");
    Serial.println("Le relais 4 est activé");
        digitalWrite(relais1, HIGH);// Relais1 activé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
        
}

        else {      
        Serial.println("Attente signal reveil");  
        digitalWrite(relais1, LOW); // Relais Désactivé
        digitalWrite(relais2, LOW); // Relais Désactivé
        digitalWrite(relais3, LOW); // Relais Désactivé
        digitalWrite(relais4, LOW); // Relais Désactivé
}}

veux tu tester ce code, (toujours pas compris ce que tu fais avec 4 relais, 4 conditions de temperatures et une seule et meme tempo)

#include <OneWire.h> //Librairie du bus OneWire
#include <DallasTemperature.h> //Librairie du capteur
#include <LiquidCrystal_I2C.h>

const int TEMP_SUPERIEUR_16 = 16; // Limite basse temperature
const int TEMP_SUPERIEUR_24 = 24; // Limite basse temperature
const int TEMP_SUPERIEUR_27 = 27; // Limite basse temperature
const int TEMP_SUPERIEUR_30 = 30; // Limite basse temperature

const int relais1 = 4;     // Pin du relais4 pour temperature entre 16 et 24°C
const int relais2 = 5;     // Pin du relais5 pour temperature entre 24 et 27°C
const int relais3 = 6;     // Pin du relais6 pour temperature entre 27 et 30°C
const int relais4 = 7;     // Pin du relais7 pour temperature supérieure a 30°C

float temperature;    // temperature en Celsius
float intensity;    // Intensité

LiquidCrystal_I2C lcd(0x3F, 16, 2); //l adresse 0x27 est a changé en fonction de votre écran
OneWire oneWire(10); //Bus One Wire sur la pin 10 de l'arduino
DallasTemperature sensors(&oneWire); //Utilistion du bus Onewire pour les capteurs
DeviceAddress sensorDeviceAddress; //Vérifie la compatibilité des capteurs avec la librairie

unsigned long tempo_intermediaire = 1000;
unsigned long deb_tempo = 0.0;
boolean flag_impulsion  = false;
void setup(void)
{
  PORTD = 0b00000000;//UNO uniquement port D à zero.
  DDRD  = 0b11110010;//UNO uniquement port D en sortie sauf RX. 1 = sortie
  Serial.begin(9600); //Permet la communication en serial
  sensors.begin(); //Activation des capteurs
  sensors.getAddress(sensorDeviceAddress, 0); //Demande l'adresse du capteur à l'index 0 du bus
  sensors.setResolution(sensorDeviceAddress, 12); //Résolutions possibles: 9,10,11,12
  lcd.begin();                      // initialize the lcd
  //lcd.init();                      // initialize the lcd
  lcd.backlight();
}

void loop(void)
{
  sensors.requestTemperatures(); //Demande la température aux capteurs
  temperature = sensors.getTempCByIndex(0);  // lire temperature en Celsius
  lcd.setCursor(0, 0);
  lcd.print("Temp eau piscine : ");
  lcd.setCursor(1, 1);
  lcd.setCursor(6, 1);
  lcd.print(sensors.getTempCByIndex(0));
  lcd.print(" C ");

  int resultBinary = analogRead(A0);
  float resultVolts = resultBinary / 1023.0 * 5.0;
  float R = 200.0;
  float intensity = resultVolts / R * 1000; // x 1000 pour avoir le résultat en mA (milliampères)!
  Serial.println(intensity); // En milliampères

  if ((intensity > 3) && (flag_impulsion == false))
  {
    delay(1000);
    flag_impulsion = true;
  }
  else
  {
    if ((intensity > 3) && (flag_impulsion == true))
    {
      deb_tempo = millis();
    }
  }
  if ((millis() - deb_tempo) < tempo_intermediaire)
  {
    activation_relais();
  }
  else
  {
    stop_relais();
  }
}
void stop_relais()
{
  Serial.println("Attente signal reveil");
  digitalWrite(relais1, LOW); // Relais Désactivé
  digitalWrite(relais2, LOW); // Relais Désactivé
  digitalWrite(relais3, LOW); // Relais Désactivé
  digitalWrite(relais4, LOW); // Relais Désactivé
}
void activation_relais()
{
  if (temperature > TEMP_SUPERIEUR_30)
  {
    Serial.println(" Temperature supérieure a 30°C");
    Serial.println("Le relais 4 est activé");
    digitalWrite(relais4, HIGH);// Relais4 activé
  }
  else
  {
    if (temperature >= TEMP_SUPERIEUR_27)
    {
      Serial.println(" Temperature entre 24°C et 27°C");
      Serial.println("Le relais 3 est activé");
      digitalWrite(relais3, HIGH);// Relais3 activé
    }
    else
    {
      if (temperature >= TEMP_SUPERIEUR_24)
      {
        Serial.println(" Temperature entre 16°C et 24°C");
        Serial.println("Le relais 2 est activé");
        digitalWrite(relais2, HIGH);// Relais2 activé
      }
      else
      {
        if (temperature >= TEMP_SUPERIEUR_16)
        {
          Serial.println("Temperature superieure a 16°C");
          Serial.println("Le relais 1 est activé");
          digitalWrite(relais1, HIGH);// Relais1 activé
        }
      }
    }
  }
}

Je viens de tester le nouveau code, et tout fonctionne très bien, merci dfgh.


#include <OneWire.h> //Librairie du bus OneWire
#include <DallasTemperature.h> //Librairie du capteur
#include <LiquidCrystal_I2C.h>

const int TEMP_SUPERIEUR_16 = 16; // Limite basse temperature
const int TEMP_SUPERIEUR_24 = 24; // Limite basse temperature
const int TEMP_SUPERIEUR_27 = 27; // Limite basse temperature
const int TEMP_SUPERIEUR_30 = 30; // Limite basse temperature

const int relais1 = 4;     // Pin du relais4 pour temperature entre 16 et 24°C
const int relais2 = 5;     // Pin du relais5 pour temperature entre 24 et 27°C
const int relais3 = 6;     // Pin du relais6 pour temperature entre 27 et 30°C
const int relais4 = 7;     // Pin du relais7 pour temperature supérieure a 30°C

float temperature;    // temperature en Celsius
float intensity;    // Intensité

LiquidCrystal_I2C lcd(0x3F, 16, 2); //l adresse 0x27 est a changé en fonction de votre écran
OneWire oneWire(10); //Bus One Wire sur la pin 10 de l'arduino
DallasTemperature sensors(&oneWire); //Utilistion du bus Onewire pour les capteurs
DeviceAddress sensorDeviceAddress; //Vérifie la compatibilité des capteurs avec la librairie

unsigned long tempo_intermediaire = 121000;    // Faire en sorte que le relais ne s'allume qu'une fois pendant la sonnerie du réveil
unsigned long deb_tempo = 0.0;
boolean flag_impulsion  = false;
void setup(void)
{

   pinMode(relais1, OUTPUT); //Déclaration de la broche 4 en sortie
 digitalWrite(relais1, HIGH);
 pinMode(relais2, OUTPUT); //Déclaration de la broche 5 en sortie
 digitalWrite(relais2, HIGH);
 pinMode(relais3, OUTPUT); //Déclaration de la broche 6 en sortie
 digitalWrite(relais3, HIGH);
 pinMode(relais4, OUTPUT); //Déclaration de la broche 7 en sortie
 digitalWrite(relais4, HIGH);

  

  Serial.begin(9600); //Permet la communication en serial
  sensors.begin(); //Activation des capteurs
  sensors.getAddress(sensorDeviceAddress, 0); //Demande l'adresse du capteur à l'index 0 du bus
  sensors.setResolution(sensorDeviceAddress, 12); //Résolutions possibles: 9,10,11,12
  lcd.init();                      // initialize the lcd 
  lcd.backlight();                 // retroeclairage lcd
}

void loop(void)
{
  sensors.requestTemperatures(); //Demande la température aux capteurs
  temperature = sensors.getTempCByIndex(0);  // lire temperature en Celsius
  lcd.setCursor(0, 0);
  lcd.print("Temp eau piscine : ");
  lcd.setCursor(1, 1);
  lcd.setCursor(6, 1);
  lcd.print(sensors.getTempCByIndex(0));
  lcd.print(" C ");

  int resultBinary = analogRead(A0);
  float resultVolts = resultBinary / 1023.0 * 5.0;
  float R = 326.0;
  float intensity = resultVolts / R * 1000; // x 1000 pour avoir le résultat en mA (milliampères)!
  Serial.println(intensity); // En milliampères

  if ((intensity > 0.4) && (flag_impulsion == false))
  {
    delay(1000);
    flag_impulsion = true;
  }
  else
  {
    if ((intensity > 0.4) && (flag_impulsion == true))
    {
      deb_tempo = millis();
    }
  }
  if ((millis() - deb_tempo) < tempo_intermediaire)
  {
    activation_relais();
  }
  else
  {
    stop_relais();
  }
}
void stop_relais()
{
  Serial.println("Attente signal reveil");
  digitalWrite(relais1, HIGH); // Relais Désactivé
  digitalWrite(relais2, HIGH); // Relais Désactivé
  digitalWrite(relais3, HIGH); // Relais Désactivé
  digitalWrite(relais4, HIGH); // Relais Désactivé
}
void activation_relais()
{
    if (temperature <= TEMP_SUPERIEUR_16) {
    Serial.println("Temperature inférieure a 16°C");
    Serial.println("Tous les relais sont désactivés");
        digitalWrite(relais1, HIGH); // Relais Désactivé
        digitalWrite(relais2, HIGH); // Relais Désactivé
        digitalWrite(relais3, HIGH); // Relais Désactivé
        digitalWrite(relais4, HIGH); // Relais Désactivé

        
  } else if (temperature > TEMP_SUPERIEUR_16  && temperature <= TEMP_SUPERIEUR_24) {
    Serial.println(" Temperature entre 16°C et 24°C");
    Serial.println("Le relais 1 est activé");
        digitalWrite(relais1, LOW);// Relais1 activé
        digitalWrite(relais2, HIGH); // Relais Désactivé
        digitalWrite(relais3, HIGH); // Relais Désactivé
        digitalWrite(relais4, HIGH); // Relais Désactivé
        
}

    else if (temperature > TEMP_SUPERIEUR_24  && temperature <= TEMP_SUPERIEUR_27) {
    Serial.println(" Temperature entre 24°C et 27°C");
    Serial.println("Le relais 2 est activé");
        digitalWrite(relais1, HIGH);// Relais1 Désactivé
        digitalWrite(relais2, LOW); // Relais2 Activé
        digitalWrite(relais3, HIGH); // Relais3 Désactivé
        digitalWrite(relais4, HIGH); // Relais4 Désactivé
        
}

     else if (temperature > TEMP_SUPERIEUR_27  && temperature <= TEMP_SUPERIEUR_30) {
    Serial.println(" Temperature entre 27°C et 30°C");
    Serial.println("Le relais 3 est activé");
        digitalWrite(relais1, HIGH);// Relais1 Désactivé
        digitalWrite(relais2, HIGH); // Relais2 Désactivé
        digitalWrite(relais3, LOW); // Relais3 activé
        digitalWrite(relais4, HIGH); // Relais4 Désactivé
        
}

         else if (temperature > TEMP_SUPERIEUR_30) {
    Serial.println(" Temperature supérieure a 30°C");
    Serial.println("Le relais 4 est activé");
        digitalWrite(relais1, HIGH);// Relais1 Désactivé
        digitalWrite(relais2, HIGH); // Relais2 Désactivé
        digitalWrite(relais3, HIGH); // Relais3 Désactivé
        digitalWrite(relais4, LOW); // Relais4 activé
        
}

        else {      
        Serial.println("Attente signal reveil");  
        digitalWrite(relais1, HIGH); // Relais Désactivé
        digitalWrite(relais2, HIGH); // Relais Désactivé
        digitalWrite(relais3, HIGH); // Relais Désactivé
        digitalWrite(relais4, HIGH); // Relais Désactivé
}
    
  }

Revoici le code complet(juste, mes LOW et HIGH sont inversés, mais ca n'a pas d'incidence(je pense que c'est du au cablage)

Le but c'est qu'en sortie de chaque relais il soit branché une temporisation qui recoit le signal du relais :
TESTOUUU

Et ensuite par reglage manuel sur chaque temporisation de chaque canal de temperature on puisse régler la durée de fonctionnement de la pompe. C'est a dire que la pompe s'allumera tous les jours a une heure précise définie par le reveil (ici un reveil DCF77 qui se met automatiquement a l'heure) , en fontion de la temperature de l'eau de la piscine et du coup d'une durée définie.
On peut mettre en place un mode Manuel ou AUTO avec un selecteur, et la pompe tourne toute seule tous les jours en fonction de la temperature de l'eau.

pour résumer:
en fonction de la température, si autorisé, la pompe doit tourner plus ou moins longtemps.
chacune des temporisations correspond à une plage de température.

tu veux brasser l'eau pour rendre la température uniforme ?

edit: le code que toi tu viens de poster ne correspond pas à celui que j'ai posté.

En gros je regle chaque temporisation sur une durée :
Si la temperature de l'eau est :
entre 16°C et 24°C > 6h
entre 24°C et 27°C > 8h
ect..

Brasser, l'eau? oui c'est le but pour la filtrer...

Le problème c'est que si le reveil donne ses impulsions, avec ton code, il peut donner un second ordre a une autre tempo, du coup il peut y avoir 2 tempo qui peuvent tourner en même temps si la température de l'eau change pendant la durée des impulsions du réveil ( c'est peu probable que la température de l'eau change si vite car il y a une grande inertie de l'eau)

#include <OneWire.h> //Librairie du bus OneWire
#include <DallasTemperature.h> //Librairie du capteur
#include <LiquidCrystal_I2C.h>

const int TEMP_SUPERIEUR_16 = 16; // Limite basse temperature
const int TEMP_SUPERIEUR_24 = 24; // Limite basse temperature
const int TEMP_SUPERIEUR_27 = 27; // Limite basse temperature
const int TEMP_SUPERIEUR_30 = 30; // Limite basse temperature

const int relais1 = 4;     // Pin du relais4 pour temperature entre 16 et 24°C
const int relais2 = 5;     // Pin du relais5 pour temperature entre 24 et 27°C
const int relais3 = 6;     // Pin du relais6 pour temperature entre 27 et 30°C
const int relais4 = 7;     // Pin du relais7 pour temperature supérieure a 30°C

float temperature;    // temperature en Celsius
float intensity;    // Intensité

LiquidCrystal_I2C lcd(0x3F, 16, 2); //l adresse 0x27 est a changé en fonction de votre écran
OneWire oneWire(10); //Bus One Wire sur la pin 10 de l'arduino
DallasTemperature sensors(&oneWire); //Utilistion du bus Onewire pour les capteurs
DeviceAddress sensorDeviceAddress; //Vérifie la compatibilité des capteurs avec la librairie

unsigned long tempo_intermediaire = 1000;
unsigned long deb_tempo = 0.0;
boolean flag_impulsion  = false;
void setup(void)
{

 pinMode(relais1, OUTPUT); //Déclaration de la broche 4 en sortie
 digitalWrite(relais1, HIGH);
 pinMode(relais2, OUTPUT); //Déclaration de la broche 5 en sortie
 digitalWrite(relais2, HIGH);
 pinMode(relais3, OUTPUT); //Déclaration de la broche 6 en sortie
 digitalWrite(relais3, HIGH);
 pinMode(relais4, OUTPUT); //Déclaration de la broche 7 en sortie
 digitalWrite(relais4, HIGH);
  
  PORTD = 0b00000000;//UNO uniquement port D à zero.
  DDRD  = 0b11110010;//UNO uniquement port D en sortie sauf RX. 1 = sortie
  Serial.begin(9600); //Permet la communication en serial
  sensors.begin(); //Activation des capteurs
  sensors.getAddress(sensorDeviceAddress, 0); //Demande l'adresse du capteur à l'index 0 du bus
  sensors.setResolution(sensorDeviceAddress, 12); //Résolutions possibles: 9,10,11,12
  lcd.init();                      // initialize the lcd
  lcd.backlight();
}

void loop(void)
{
  sensors.requestTemperatures(); //Demande la température aux capteurs
  temperature = sensors.getTempCByIndex(0);  // lire temperature en Celsius
  lcd.setCursor(0, 0);
  lcd.print("Temp eau piscine : ");
  lcd.setCursor(1, 1);
  lcd.setCursor(6, 1);
  lcd.print(sensors.getTempCByIndex(0));
  lcd.print(" C ");

  int resultBinary = analogRead(A0);
  float resultVolts = resultBinary / 1023.0 * 5.0;
  float R = 326.0;
  float intensity = resultVolts / R * 1000; // x 1000 pour avoir le résultat en mA (milliampères)!
  Serial.println(intensity); // En milliampères

  if ((intensity > 0.4) && (flag_impulsion == false))
  {
    delay(1000);
    flag_impulsion = true;
  }
  else
  {
    if ((intensity > 0.4) && (flag_impulsion == true))
    {
      deb_tempo = millis();
    }
  }
  if ((millis() - deb_tempo) < tempo_intermediaire)
  {
    activation_relais();
  }
  else
  {
    stop_relais();
  }
}
void stop_relais()
{
  Serial.println("Attente signal reveil");
  digitalWrite(relais1, HIGH); // Relais Désactivé
  digitalWrite(relais2, HIGH); // Relais Désactivé
  digitalWrite(relais3, HIGH); // Relais Désactivé
  digitalWrite(relais4, HIGH); // Relais Désactivé
}
void activation_relais()
{
  if (temperature > TEMP_SUPERIEUR_30)
  {
    Serial.println(" Temperature supérieure a 30°C");
    Serial.println("Le relais 4 est activé");
    digitalWrite(relais4, LOW);// Relais4 activé
  }
  else
  {
    if (temperature >= TEMP_SUPERIEUR_27)
    {
      Serial.println(" Temperature supérieure a 27");
      Serial.println("Le relais 3 est activé");
      digitalWrite(relais3, LOW);// Relais3 activé
    }
    else
    {
      if (temperature >= TEMP_SUPERIEUR_24)
      {
        Serial.println(" Temperature superieure a  24°C");
        Serial.println("Le relais 2 est activé");
        digitalWrite(relais2, LOW);// Relais2 activé
      }
      else
      {
        if (temperature >= TEMP_SUPERIEUR_16)
        {
          Serial.println("Temperature superieure a 16°C");
          Serial.println("Le relais 1 est activé");
          digitalWrite(relais1, LOW);// Relais1 activé
        }
      }
    }
  }
}

un dernier test?

#include <OneWire.h> //Librairie du bus OneWire
#include <DallasTemperature.h> //Librairie du capteur
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 16, 2); //l adresse 0x27 est a changé en fonction de votre écran
OneWire oneWire(10); //Bus One Wire sur la pin 10 de l'arduino
DallasTemperature sensors(&oneWire); //Utilistion du bus Onewire pour les capteurs
DeviceAddress sensorDeviceAddress; //Vérifie la compatibilité des capteurs avec la librairie

const int temp[]          = {    0,    30,    27,    24,    20,    16};
unsigned long tempo []    = {    0, 30000, 25000, 20000, 15000, 10000};
const byte relais         = 4;     // Pin du relais4 pour temperature entre 16 et 24°C
const byte impulsion      = 14;
float temperature         = 0.0;    // temperature en Celsius
unsigned long tempo_pompe = 0;
unsigned long deb_tempo   = 0;
boolean flag_impulsion    = false;
boolean flag_en_cours     = false;

void setup(void)
{
  PORTD  |= 0b00010000; //UNO uniquement port D à HIGH.
  DDRD   |= 0b00010000; //UNO uniquement port D en sortie sauf RX. 1 = sortie
  Serial.begin(9600); //Permet la communication en serial
  sensors.begin(); //Activation des capteurs
  sensors.getAddress(sensorDeviceAddress, 0); //Demande l'adresse du capteur à l'index 0 du bus
  sensors.setResolution(sensorDeviceAddress, 12); //Résolutions possibles: 9,10,11,12
  lcd.begin();                      // initialize the lcd
  //lcd.init();                      // initialize the lcd
  lcd.backlight();
}

void loop()
{
  temperature_eau();
  if ((analogRead(impulsion) > 650) && (flag_impulsion == false))
  {                                    //1ere impulsion à la mise sous tension
    delay(1000);                       //prise en compte neutralisée pendant 1 seconde
    flag_impulsion = true;
  }
  else
  {                                    //il est l'heure et ce n'est pas la 1ere impulsion
    if ((analogRead(impulsion) > 650) && (flag_impulsion == true))
    {
      deb_tempo = millis();            //armement de la tempo
      init_tempo();                    //init de la durée de la tempo
    }
  }
  if ((millis() - deb_tempo) < tempo_pompe)
  {
    digitalWrite(relais, LOW);         //relais activé
  }
  else
  {
    digitalWrite(relais, HIGH);        //relais désactivé
    flag_en_cours = false;             //nouvelle init de tempo autorisée
  }
}

void init_tempo()
{
  if (flag_en_cours == false)        //si pas de temporisation en cours
  {
    for (byte f = 1; f <= 5; f++)
    {
      if (temperature > temp[f])     //recherche plage temperature
      {
        tempo_pompe = tempo[f];      //init de la durée correspondante
        flag_en_cours = true;        //armement du flag de temporisation en cours
      }
    }
  }
}
void temperature_eau()
{
  sensors.requestTemperatures(); //Demande la température aux capteurs
  temperature = sensors.getTempCByIndex(0);  // lire temperature en Celsius
  lcd.setCursor(0, 0);
  lcd.print("Temp eau piscine : ");
  lcd.setCursor(1, 1);
  lcd.setCursor(6, 1);
  lcd.print(sensors.getTempCByIndex(0));
  lcd.print(" C ");
}

Salut, j'ai réessayé le code, mais mes connaissances ne sont pas assez dévéloppés pour pouvoir modifier ton code, faudrait que tu m'explique.
Je voudrais faire évoluer mon projet pour que la durée de filtration change en fonction de chaque degré de température. Que a chaque fois que le signal du réveil est détecté et que une certaine température est détecté, une durée de filtration se mette en marche. En sorte que le relais s'active au début pendant x secondes, puis s’arrête pendant x heures( durée de filtration) et se rallume pendant x secondes( pour dire a la tempo physique externe d’arrêter la pompe).
Je ne suis pas du tout familier avec millis, j'ai utilisé la librairie ScheduleTable, mais la tempo n'est pas prise en compte.. Faut-il que je mette les états du relais pour que ça soit pris en compte?
Merci de votre aide.

#include <OneWire.h> //Librairie du bus OneWire
#include <DallasTemperature.h> //Librairie du capteur
#include <LiquidCrystal_I2C.h>
#include <ScheduleTable.h>

const int relais1 = 4;       // crée un identifiant pour la broche utilisée avec le relais


SchedTable<4> blinkLED(10, 1000);

void ledOn()
{

  digitalWrite(relais1, LOW);    //On allume le relais1
  Serial.println("Relais1 activé");

}

void ledOff()
{

  digitalWrite(relais1, HIGH);     //On éteint le relais1
  Serial.println("Relais1 desactive");
}




const unsigned long SECOND = 1000;
const unsigned long MINUTE = 60 * SECOND;
const unsigned long HOUR = 3600 * SECOND;
const unsigned long TRENTEMINUTES = 30 * 60 * SECOND;





const int TEMP_SUPERIEUR_16 = 16; //  temperature
const int TEMP_SUPERIEUR_18 = 18; //  temperature
const int TEMP_SUPERIEUR_20 = 20; //  temperature
const int TEMP_SUPERIEUR_21 = 21; //  temperature
const int TEMP_SUPERIEUR_22 = 22; //  temperature
const int TEMP_SUPERIEUR_23 = 23; //  temperature
const int TEMP_SUPERIEUR_24 = 24; //  temperature
const int TEMP_SUPERIEUR_25 = 25; //  temperature
const int TEMP_SUPERIEUR_26 = 26; //  temperature
const int TEMP_SUPERIEUR_27 = 27; //  temperature
const int TEMP_SUPERIEUR_28 = 28; //  temperature
const int TEMP_SUPERIEUR_29 = 29; //  temperature
const int TEMP_SUPERIEUR_30 = 30; //  temperature



float temperature;    // temperature en Celsius
float intensity;    // Intensité

LiquidCrystal_I2C lcd(0x3F, 16, 2); //l adresse 0x27 est a changé en fonction de votre écran
OneWire oneWire(10); //Bus One Wire sur la pin 10 de l'arduino
DallasTemperature sensors(&oneWire); //Utilistion du bus Onewire pour les capteurs
DeviceAddress sensorDeviceAddress; //Vérifie la compatibilité des capteurs avec la librairie




void setup() {

  pinMode(relais1, OUTPUT); //Déclaration de la broche 4 en sortie
  digitalWrite(relais1, HIGH); // mise off du relais au demarrage

  blinkLED.at(2, ledOn);
  blinkLED.at(3, ledOff);
  blinkLED.at(5, ledOn);
  blinkLED.at(6, ledOff);

  blinkLED.start(1);


  Serial.begin(115200); //Permet la communication en serial
  sensors.begin(); //Activation des capteurs
  sensors.getAddress(sensorDeviceAddress, 0); //Demande l'adresse du capteur à l'index 0 du bus
  sensors.setResolution(sensorDeviceAddress, 12); //Résolutions possibles: 9,10,11,12
  lcd.init();                      // initialize the lcd
  lcd.backlight();

}





void loop() {
  sensors.requestTemperatures(); //Demande la température aux capteurs
  temperature = sensors.getTempCByIndex(0);  // lire temperature en Celsius


  // Print a message to the LCD.


  lcd.setCursor(0, 0);
  lcd.print("Temp eau piscine : ");
  lcd.setCursor(1, 1);
  lcd.setCursor(6, 1);
  lcd.print(sensors.getTempCByIndex(0));
  lcd.print(" C ");



  int resultBinary = analogRead(A0);
  float resultVolts = resultBinary / 1023.0 * 5.0;
  float R = 326.0;
  float intensity = resultVolts / R * 1000; // x 1000 pour avoir le résultat en mA (milliampères)!
  Serial.println(intensity); // En milliampères





  if ((intensity > 0.4) && (temperature <= TEMP_SUPERIEUR_16)) {
    Serial.println("Temperature inférieure a 16°C");
    Serial.println("Tous les relais sont désactivés");
    digitalWrite(relais1, HIGH); // Relais Désactivé
  }


  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_16  && temperature <= TEMP_SUPERIEUR_18) ) {

    Serial.println(" Temperature entre 16°C et 18°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé

  }


  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_18  && temperature <= TEMP_SUPERIEUR_20)) {
    Serial.println(" Temperature entre 18°C et 20°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé

  }

  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_20  && temperature <= TEMP_SUPERIEUR_21)) {
    Serial.println(" Temperature entre 20°C et 21°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé

  }

  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_21  && temperature <= TEMP_SUPERIEUR_22)) {
    Serial.println(" Temperature entre 21°C et 22°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé

  }

  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_22  && temperature <= TEMP_SUPERIEUR_23)) {
    Serial.println(" Temperature entre 22°C et 23°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé

  }

  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_23  && temperature <= TEMP_SUPERIEUR_24)) {
    Serial.println(" Temperature entre 23°C et 24°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé

  }

  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_24  && temperature <= TEMP_SUPERIEUR_25)) {
    Serial.println(" Temperature entre 24°C et 25°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé

  }

  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_25  && temperature <= TEMP_SUPERIEUR_26)) {

    Serial.println(" Temperature entre 16°C et 18°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé
  }


  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_26  && temperature <= TEMP_SUPERIEUR_27)) {

    Serial.println(" Temperature entre 16°C et 18°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé


  }


  // Si les conditions sont réunies,
  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_27  && temperature <= TEMP_SUPERIEUR_28)) {
    Serial.println(" Temperature entre 27°C et 28°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé


  }
  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_28  && temperature <= TEMP_SUPERIEUR_29)) {
    Serial.println(" Temperature entre 28°C et 29°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé

  }

  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_29  && temperature <= TEMP_SUPERIEUR_30)) {
    Serial.println(" Temperature entre 29°C et 30°C");
    Serial.println("Le relais 1 est activé");
    digitalWrite(relais1, LOW);// Relais1 activé

  }
  else if ((intensity > 0.4) && (temperature > TEMP_SUPERIEUR_30)) {
    Serial.println(" Temperature supérieure a 30°C");
    Serial.println("Le relais 1 est activé");
    ScheduleTable::update();

  }

  else {
    Serial.println("Attente signal reveil");
    digitalWrite(relais1, HIGH); // Relais Désactivé

  }




}

tu veux : qu'en fonction de la température, le réveil déclenche une impulsion de 1 seconde pour qu’un relais soit collé 1 seconde.
ce relais va donner l'info au système de gestion de ta piscine de faire tourner la pompe.
l'impulsion de 1 seconde est aussi le début d'une tempo dans l’Arduino.
cette tempo est fonction de la température de l'eau.
en fin de tempo, l’Arduino doit refaire une impulsion de 1 seconde
qui va coller le relais pendant cette seconde.
le relais donne l'info au système de gestion de ta piscine qu'il faut stopper la pompe

en fait tu veux simuler le bouton poussoir qui actionne la minuterie de la lumière d'escalier ( télérupteur)

c'est bien ça?

Oui,disons que au départ, le réveil déclenche des impulsions durant 2 minutes, l'arduino détecte au moins 1 impulsion et en fonction de chaque degré de température, active un relais pendant 1 seconde (ou 3 secondes peu importe) puis il y a un repos du relais de plusieurs heures et a la fin du temps de repos(temps de fonctionnement de la pompe) le relais se réactive pendant 3 secondes.FIN..Et la boucle recommence a détecter si il y a une impulsion du réveil (le lendemain) Pour chaque degré de température une tempo de repos différente(temps de fonctionnement de la pompe).
Avec ce système cela permet une économie d'énergie maximale en fonction de chaque différence de degré.