programmateur horaire avec interval

Bonjour,
Je souhaiterai votre aide afin de créer mon projet de programmateur.
Je regarde a droite et à gauche et je n'ai pas trouvé un code qui pourrait correspondre. Peut-être ai je mal cherché : Smiley-confondez:

Dans le bout de code joint, il y a l'explication du but final.

Pouvez vous m'aiguiller afin que je ne me perde pas dans les méandres du codage.
Merci par avance.

//  le but final est de pouvoir déclencher 3 relais à des heures programmés et suivant un nbr de déclenchements choisi et une durée programmée.
//ex: P1_Relai sera déclenché 3 fois pendant 20 secondes à un interval de 3 heures. Le premier déclenchement aura lieu à 11h00
//ex: P2_Relai sera déclenché 2 fois pendant 3 minutes à un interval de 2h20. Le premier déclenchement aura lieu à 07h00
//ex: P3_Relai sera déclenché 6 fois pendant 1 minute à un interval de 1 heure. Le premier déclenchement aura lieu à 15h00
//voici ou je souhaiterai arriver.

#include <Wire.h>
#include <RTClib.h>

RTC_DS1307 rtc;
  DateTime now = rtc.now();
const int P1_Relai  = 48;
const int P2_Relai  = 50;
const int P3_Relai  = 52;

//Heure et minute de référence pour le calcul des déclenchements suivant
byte P1_RefHeure    = 10;
byte P1_RefMinute   = 0;
byte P2_RefHeure    = 11;
byte P2_RefMinute   = 15;
byte P3_RefHeure    = 12;
byte P3_RefMinute   = 30;

// nbr_declenchement_Px  sera modifier suivant les besoins.
// ex: si nbr_declenchement_Px = 3, 1 déclenchement à Px_RefHeure puis le 2e et le 3e déclenchement après interval de x minutes (là aussi modifiable)
uint16_t P1_nbr_declenchement = 2;              //valeur modifiable suivant les besoins
uint16_t P2_nbr_declenchement = 3;              //valeur modifiable suivant les besoins
uint16_t P3_nbr_declenchement = 4;              //valeur modifiable suivant les besoins

// interval de déclenchement.
uint16_t P1_interval;
uint16_t P2_interval;
uint16_t P3_interval;



void setup() {
  Wire.begin();
  Serial.begin(9600);
  Serial.println("Programme Test declenchement de relai");

  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));       // Reglage du RTC à la date & heure de la compilation du sketch

}

void loop() {


}

Merci par avance pour votre aide

il est un peu vide votre code.. montrez nous ce que vous avez essayé de faire, on ne va pas coder cela pour vous.

petite aide:

il est souvent pratique de représenter un moment de la journée par le nombre de secondes écoulées depuis minuit par exemple pour 11h20 et 30 secondes, on écrirait

unsigned long t = 11*3600ul + 20*60 + 30; // le ul pour quel le calcul se fasse bien en unsigned long

ensuite comparer si l'heure actuelle est avant ou après un moment donné est simplement une comparaison de deux nombres pour voir lequel est le plus grand

essayez...

Bonjour et merci pour cette première aide qui m'a bien aiguillé.

Voilà ma petite avancée.
Je vais essayer de tenter l'histoire de l'interval entre les déclenchements.

Tous les conseils et toutes les aides sont les bienvenues.

//  le but final est de pouvoir déclencher 3 relais à des heures programmés et suivant un nbr de déclenchements choisi et une durée programmée.
//ex: P1_Relai sera déclenché 3 fois pendant 20 secondes à un interval de 3 heures. Le premier déclenchement aura lieu à 11h00
//ex: P2_Relai sera déclenché 2 fois pendant 3 minutes à un interval de 2h20. Le premier déclenchement aura lieu à 07h00
//ex: P3_Relai sera déclenché 6 fois pendant 1 minute à un interval de 1 heure. Le premier déclenchement aura lieu à 15h00
//voici ou je souhaiterai arriver.

#include <Wire.h>
#include <RTClib.h>

RTC_DS1307 rtc;

const int P1_Relai  = 48;
const int P2_Relai  = 50;
const int P3_Relai  = 52;


unsigned long heure_ActuelleEnSeconde;

//Start de référence pour le calcul des déclenchements suivant
//il est souvent pratique de représenter un moment de la journée par le nombre de secondes écoulées depuis minuit.
// par exemple pour 11h20 et 30 secondes, on écrirait: unsigned long t = 11*3600ul + 20*60 + 30; // le ul pour quel le calcul se fasse bien en unsigned long
unsigned long P1_RefStart = 14 * 3600ul + 56 * 60 + 0;  //14h  56m  00sec.  le ul pour quel le calcul se fasse bien en unsigned long
unsigned long P2_RefStart = 11 * 3600ul + 15 * 60 + 20; //11h  15m  20sec.  le ul pour quel le calcul se fasse bien en unsigned long
unsigned long P3_RefStart = 15 * 3600ul + 25 * 60 + 35; //15h  15m  35sec.  le ul pour quel le calcul se fasse bien en unsigned long

// Durée du déclenchement en secondes.
unsigned long P1_Duree = 20;
unsigned long P2_Duree = 30;
unsigned long P3_Duree = 40;

// Arrêt de référence calculé.
unsigned long P1_RefStop = P1_RefStart + P1_Duree;
unsigned long P2_RefStop = P2_RefStart + P2_Duree;
unsigned long P3_RefStop = P3_RefStart + P3_Duree;


// nbr_declenchement_Px  sera modifier suivant les besoins.
// ex: si nbr_declenchement_Px = 3, 1 déclenchement à Px_RefHeure puis le 2e et le 3e déclenchement après interval de x minutes (là aussi modifiable)
uint16_t P1_nbrDeclenchement = 2;              //valeur modifiable suivant les besoins
uint16_t P2_nbrDeclenchement = 3;              //valeur modifiable suivant les besoins
uint16_t P3_nbrDeclenchement = 4;              //valeur modifiable suivant les besoins

// interval entre 2 déclenchements (mettre en secondes).
uint16_t P1_interval;
uint16_t P2_interval;
uint16_t P3_interval;




//---------------------------------------- SETUP
void setup() {
  //Wire.begin();
  Serial.begin(9600);
  Serial.println("Programme Test declenchement de relai");

  if (! rtc.begin()) {
    Serial.println("RTC non présent");
    while (1);
  }

  if (! rtc.isrunning()) {
    Serial.println("RTC n'est pas actif!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));// Reglage du RTC à la date & heure de la compilation du sketch
  }

  initialiserRelais();
}

//---------------------------------------- LOOP
void loop() {
  heureActuelleEnseconde();
  P1_Start();
}

//---------------------------------------- Initialisation des Relais
void initialiserRelais()
{
  pinMode(P1_Relai, OUTPUT);
  pinMode(P2_Relai, OUTPUT);
  pinMode(P3_Relai, OUTPUT);
  digitalWrite (P1_Relai, HIGH);
  digitalWrite (P2_Relai, HIGH);
  digitalWrite (P3_Relai, HIGH);
}

//---------------------------------------- Heure actuelle en Seconde depuis Minuit
void heureActuelleEnseconde()
{
  DateTime now = rtc.now();
  // on mets l'heure actuelle en nbr de secondes depuis minuit
  heure_ActuelleEnSeconde = (now.hour() * 3600ul) + (now.minute() * 60) + (now.second());
  Serial.print("Heure Actuelle en Nbr de secondes écoulées depuis Minuit: ");
  Serial.println(heure_ActuelleEnSeconde);
  Serial.println("");
  delay(1000);
}

//---------------------------------------- P1 Déclenchement
void P1_Start()
{
  Serial.print("P1 Start à: ");
  Serial.println(P1_RefStart);
  Serial.print("P1   Durée: ");
  Serial.println(P1_Duree);
  Serial.print("P1  Stop à: ");
  Serial.println(P1_RefStop);

  if (P1_RefStart == heure_ActuelleEnSeconde)
  {
    digitalWrite (P1_Relai, LOW);
  }
  if (P1_RefStop == heure_ActuelleEnSeconde)
  {
    digitalWrite (P1_Relai, HIGH);
  }
}

bon début. au lieu de faire == vous devriez tester >= ou <= histoire que si vous ratez une seconde (on sait jamais si le reste de votre code fait de gros calculs) vous déclenchiez quand même. Dans ce cas pour ne pas redéclencher en permanence, ajoutez une variable pour mémoriser si le relais est déjà actif our pas (ça ne change rien de refaire un digitalWrite() ) HIGH s'il est déjà HIGH mais si vous faites d'autres choses dans le test de déclenchement, il ne faut peut être pas répéter cela des milliers de fois par secondes)

Voici, j'en suis là, ça a l'air de fonctionner.

Maintenant je souhaiterai faire mon interval et déclencher suivant la durée de l'interval sur 24h.
Ex: P1_nbrDeclenchement = 3 sur 24h cela fait un 1er déclenchement à l'heure de réf, un 2e 8h après et un 3e 8h après.

Donc pour l'interval je pense faire:
unsigned long P1_interval = 86400 / P1_nbrDeclenchement ;

Et là je sèche
Pourriez vous m'aiguiller?
Merci par avance.

//  le but final est de pouvoir déclencher 3 relais à des heures programmés et suivant un nbr de déclenchements choisi et une durée programmée.
//ex: P1_Relai sera déclenché 3 fois pendant 20 secondes à un interval de 3 heures. Le premier déclenchement aura lieu à 11h00
//ex: P2_Relai sera déclenché 2 fois pendant 3 minutes à un interval de 2h20. Le premier déclenchement aura lieu à 07h00
//ex: P3_Relai sera déclenché 6 fois pendant 1 minute à un interval de 1 heure. Le premier déclenchement aura lieu à 15h00


#include <Wire.h>
#include <RTClib.h>

RTC_DS1307 rtc;

const int P1_Relai  = 48;
const int P2_Relai  = 50;
const int P3_Relai  = 52;

unsigned long heure_ActuelleEnSeconde;

//Start de référence pour le calcul des déclenchements suivant
//il est souvent pratique de représenter un moment de la journée par le nombre de secondes écoulées depuis minuit.
// par exemple pour 11h20 et 30 secondes, on écrirait: unsigned long t = 11*3600ul + 20*60 + 30; // le ul pour quel le calcul se fasse bien en unsigned long
unsigned long P1_RefStart = 19 * 3600ul + 10 * 60 + 0; //18h  32m  30sec.  le ul pour quel le calcul se fasse bien en unsigned long
unsigned long P2_RefStart = 11 * 3600ul + 15 * 60 + 20; //11h  15m  20sec.  le ul pour quel le calcul se fasse bien en unsigned long
unsigned long P3_RefStart = 15 * 3600ul + 25 * 60 + 35; //15h  15m  35sec.  le ul pour quel le calcul se fasse bien en unsigned long

// Durée du déclenchement en secondes.
unsigned long P1_Duree = 10;
unsigned long P2_Duree = 15;
unsigned long P3_Duree = 20;

// Arrêt de référence calculé.
unsigned long P1_RefStop = P1_RefStart + P1_Duree;
unsigned long P2_RefStop = P2_RefStart + P2_Duree;
unsigned long P3_RefStop = P3_RefStart + P3_Duree;

// nbr_declenchement_Px  sera modifier suivant les besoins.
// ex: si nbr_declenchement_Px = 3, 1 déclenchement à Px_RefHeure puis le 2e et le 3e déclenchement après interval de x minutes (là aussi modifiable)
uint16_t P1_nbrDeclenchement = 2;              //valeur modifiable suivant les besoins
uint16_t P2_nbrDeclenchement = 3;              //valeur modifiable suivant les besoins
uint16_t P3_nbrDeclenchement = 4;              //valeur modifiable suivant les besoins

// interval en secondes entre 2 déclenchements sur la base de 24h.
unsigned long P1_interval = 86400 / P1_nbrDeclenchement ;
unsigned long P2_interval = 86400 / P2_nbrDeclenchement ;
unsigned long P3_interval = 86400 / P3_nbrDeclenchement ;

//Verif si relai actif Oui/Non
boolean P1_Actif;
boolean P2_Actif;
boolean P3_Actif;

//---------------------------------------- SETUP
void setup() {
  //Wire.begin();
  Serial.begin(9600);
  Serial.println("Programme Test declenchement de relai");

  if (! rtc.begin()) {
    Serial.println("RTC non présent");
    while (1);
  }

  if (! rtc.isrunning()) {
    Serial.println("RTC n'est pas actif!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));// Reglage du RTC à la date & heure de la compilation du sketch
  }

  initialisation();
}

//---------------------------------------- LOOP
void loop() {
  heureActuelleEnseconde();
  P1_Start();
  delay(1000);
}

//---------------------------------------- Initialisation
void initialisation()
{
  pinMode(P1_Relai, OUTPUT);
  pinMode(P2_Relai, OUTPUT);
  pinMode(P3_Relai, OUTPUT);
  digitalWrite (P1_Relai, HIGH);
  digitalWrite (P2_Relai, HIGH);
  digitalWrite (P3_Relai, HIGH);

  P1_Actif = false;               //Variable pour voir l'état du relai
  P2_Actif = false;
  P3_Actif = false;
}

//---------------------------------------- Heure actuelle en Seconde depuis Minuit
void heureActuelleEnseconde()
{
  DateTime now = rtc.now();
  Serial.println("");
  Serial.print("Heure  actuelle: ");
  Serial.print(now.hour());
  Serial.print(":");
  Serial.print(now.minute());
  Serial.print(":");
  Serial.println(now.second());

  // on mets l'heure actuelle en nbr de secondes depuis minuit
  heure_ActuelleEnSeconde = (now.hour() * 3600ul) + (now.minute() * 60) + (now.second());
  Serial.print("En secondes: ");
  Serial.print(heure_ActuelleEnSeconde);
  Serial.println("");
}

//---------------------------------------- P1 Déclenchement
void P1_Start()
{
  Serial.print("P1  Start à: ");
  Serial.println(P1_RefStart);
  Serial.print("P1    Durée: ");
  Serial.println(P1_Duree);
  Serial.print("P1   Stop à: ");
  Serial.println(P1_RefStop);
  Serial.print("P1    Actif: ");
  Serial.println(P1_Actif);

  if ((heure_ActuelleEnSeconde >= P1_RefStart) && (heure_ActuelleEnSeconde < P1_RefStop))
  {
    P1_Actif = true;
    Serial.print("dbg_001");
    digitalWrite (P1_Relai, LOW);
  }

  if (heure_ActuelleEnSeconde >= P1_RefStop)
  {
    P1_Actif = false;
    Serial.print("dbg_002");
    digitalWrite (P1_Relai, HIGH);
  }

}

là vous ne pouvez plus compter le nombre de secondes depuis minuit, puisque rajouter 8 ou 16h à une certaine heure va vous emmener parfois au lendemain...

Il faut donc gérer cela un peu de la façon actuelle, avec un nombre représentant l'heure, mais il faut que ce nombre soit capable de représenter n'importe quel jour... pour cela il y a ce que l'on appelle l'unix time, c'est à dire le nombre de secondes écoulées depuis le 1er janvier 1970 00:00:00 UTC ou si vous voulez restez lié à votre RTC, elles compte souvent depuis le 1/1/2000

Votre RTClib (si vous utilisez cette librairie (adafruit/RTClib) ?) vous permette d'obtenir l'heure courante en unixtime: vous verrez que la classe DateTime contient deux méthodes secondstime() et unixtime()

    // 32-bit times as seconds since 1/1/2000
    long secondstime() const;   
    // 32-bit times as seconds since 1/1/1970
    uint32_t unixtime(void) const;

qui sont faites pour cela.

Il y a aussi une classe TimeSpan pour représenter une durée (obtenue par soustraction de deux DateTime ou par création directe et qui vous donne aussi une fonction totalseconds()

Représentez vos valeurs de départ sous forme de DateTime, vous en retirez l'unixtime par exemple et ensuite vous pouvez faire des additions avec le totalseconds() de votre intervalle pour trouver le prochain créneau horaire

ou alors, travaillez directement avec des objets DateTime et TimeSpan pour gérer le temps

Ok, changement de direction.

Mais j'étais content d'être arrivé là, et d'avoir réussi grâce à votre aide à faire fonctionner 1 premier relai.

j'aimai bien ce système de gestion du temps par les secondes écoulées, je le garde au chaud.

Bon, je pense que je vais partir avec DateTime et TimeSpan.

Je revois ça et reviens vers vous.

Merci

Une fois qu’on a compris le principe c’est simple

Bonsoir j'ai besoin d'un coup de main.

j'ai:
int8_t P1_RefHeure = 21; //Heure et minute de référence pour le calcul des déclenchements suivant
int8_t P1_RefMinute = 11;

J'ai regardé TimeSpan, dans l'exemple ci dessous P1future sera l'heure actuelle + 1h 5m et 20 secondes. Jusqu'à là pas de problème
DateTime P1future (now+ TimeSpan(0, 1, 5, 20)); //TimeSpan(jour,heure,minute,seconde)

Mais ce que je souhaiterai c'est à la place de now, que le calcul soit basé sur mon heure et mes minutes de références et là, je bug:

DateTime P1future ((P1_RefHeure , P1_RefMinute )+ TimeSpan(0, 1, 5, 20));

Merci d'avance pour ce coup de main.

Bonjour,
Je vais essayer de me diriger vers la gestion du temps grâce à unixtime.
Je suis arrivé au code ci-dessous, qui fonctionne, mais me parait loin d'être propre.
Pouvez-vous s'il vous plaît, m'orienter pour poursuivre mon programme et surtout me conseiller pour améliorer ce début de code afin que je parte sur de bonnes bases.
Merci d'avance.

//  le but final est de pouvoir déclencher 3 relais à des heures programmés et suivant un nbr de déclenchements choisi et une durée programmée.
//ex: R1Relai sera déclenché 3 fois pendant 20 secondes à un interval de 3 heures. Le premier déclenchement aura lieu à 11h00
//ex: P2_Relai sera déclenché 2 fois pendant 3 minutes à un interval de 2h20. Le premier déclenchement aura lieu à 07h00
//ex: P3_Relai sera déclenché 6 fois pendant 1 minute à un interval de 1 heure. Le premier déclenchement aura lieu à 15h00
//voici ou je souhaiterai arriver.

#include <Wire.h>
#include <RTClib.h>

RTC_DS1307 rtc;

const int R1Relai  = 48;
const int R2Relai  = 50;
const int R3Relai  = 52;

long R1HeureStart    = 17;                  //Heure de déclenchements du relai
long R2HeureStart    = 13;
long R3HeureStart    = 15;

long R1interval;                            //Interval de déclenchement
long R1FoisParJour   = 1;                   //Nbr de déclenchement par 24h
long R1Duree         = 10;                  //Durée d'activation en secondes

//---------------------------------------- Initialisation des pompes Terminer Reglage
void initialiserRelais()
{
  pinMode(R1Relai, OUTPUT);
  pinMode(R2Relai, OUTPUT);
  pinMode(R3Relai, OUTPUT);
  digitalWrite (R1Relai, HIGH);
  digitalWrite (R2Relai, HIGH);
  digitalWrite (R3Relai, HIGH);
}

//---------------------------------------- SETUP
void setup() {
  Serial.begin(9600);
  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! rtc.isrunning()) {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    Serial.println("PROGRAMME DECLENCHEMENT DE RELAI");
  }

  initialiserRelais();
}

//---------------------------------------- LOOP
void loop() {
  delay(600);                                                                         //Doit être à 1000 pour 1 seconde, lorsque les Serial.print seront supprimés
  DateTime now = rtc.now();
  Serial.println();

  DateTime heureActuelle(2000, 01, 01, now.hour(), now.minute(), now.second());       //Heure actuelle
  Serial.print("1-heureActuelle: ");
  Serial.print(heureActuelle.hour()) && Serial.print(':') && Serial.print(heureActuelle.minute()) && Serial.print(':') && Serial.print (heureActuelle.second());
  long heureActuelle2 = (heureActuelle.unixtime());
  Serial.print(" soit: ") && Serial.print(heureActuelle2) && Serial.println("s.");    //en secondes UnixTime

  Serial.print("2-heureRefBase : 00:00:00 ");
  DateTime HeureRef(2000, 01, 01, 0, 0, 0);                                          //Heure de Référence pour les calculs 00:00:00 //Après les tests, remplacer les minutes par 0
  long heureRefBase = (HeureRef.unixtime());
  Serial.print(" soit: ") && Serial.print(heureRefBase) && Serial.println("s.");      //en secondes UnixTime

  long R1HeureReglerStart =  heureRefBase + (R1HeureStart * 3600);
  Serial.print("3-R1HeureReglerStart: ");
  Serial.print(R1HeureReglerStart / 3600) && Serial.print("h, ") && Serial.print(R1HeureReglerStart / 60) && Serial.print("m, ") && Serial.print(R1HeureReglerStart) && Serial.println("s.");

  long R1HeureStartDans = R1HeureReglerStart - heureActuelle2 ;
  Serial.print( "4-R1HeureStartDans: ");
  Serial.print(R1HeureStartDans / 3600) && Serial.print("h, ") && Serial.print(R1HeureStartDans / 60) && Serial.print("m, ") && Serial.print(R1HeureStartDans) && Serial.println("s.");

  R1interval = 86400 / R1FoisParJour;
  Serial.print(R1FoisParJour) && Serial.print(" déclenchement par 24h, avec un interval de: ") && Serial.print(R1interval / 3600) && Serial.print("h, ");
  Serial.print(R1interval / 60) && Serial.print("m, ") && Serial.print(R1interval) && Serial.println("s.");

  switch (R1FoisParJour)
  {
    case 1:     // 1 fois par jour
      if ((heureActuelle2 >= R1HeureReglerStart) && (heureActuelle2 < (R1HeureReglerStart + R1Duree)))
      {
        digitalWrite (R1Relai, LOW);            //START du relai
      }
      if (heureActuelle2 >= (R1HeureReglerStart + R1Duree))
      {
        digitalWrite (R1Relai, HIGH);           //STOP du relai après la durée R1Relai
      }
      break;

    case 2:     // 2 fois par jour
      {
        // 1er déclenchement à l'heure R1HeureReglerStart
        // 2eme déclenchement après l'interval R1interval
      }
      break;
  
 /*   //  ------------------------------------------ ETC
    case 3:     // 3 fois par jour
      {
        // 1er déclenchement à l'heure R1HeureReglerStart
        // 2eme déclenchement après l'interval R1interval
        // 3eme déclenchement après l'interval R1interval
      }
      break;
    case 4:     // 3 fois par jour
      {
        // 1er déclenchement à l'heure R1HeureReglerStart
        // 2eme déclenchement après l'interval R1interval
        // 3eme déclenchement après l'interval R1interval
        // 4eme déclenchement après l'interval R1interval
      }
      break;*/
  }
  Serial.println("************************************************************");
}

Bonjour,

Est-il possible de simplifier ce code, il fonctionne plutôt bien, mais comme je débute, il n'est pas du tout optimiser. Il est pour 1 relai et je dois le modifier pour 3 relais, à part le copier/coller, je ne vois pas trop de solution plus élégante.
Merci par avance pour votre aide.

//  le but final est de pouvoir déclencher 3 relais à des heures programmés et suivant un nbr de déclenchements choisi et une durée programmée.
//ex: R1_Relai sera déclenché 3 fois pendant 20 secondes à un interval de 3 heures. Le premier déclenchement aura lieu à 11h00
//ex: P2_Relai sera déclenché 2 fois pendant 3 minutes à un interval de 2h20. Le premier déclenchement aura lieu à 07h00
//ex: P3_Relai sera déclenché 6 fois pendant 1 minute à un interval de 1 heure. Le premier déclenchement aura lieu à 15h00
//voici ou je souhaiterai arriver.

#include <Wire.h>
#include <RTClib.h>

RTC_DS1307 rtc;
char daysOfTheWeek[7][12] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};

const int R1_Relai  = 48;
const int R2_Relai  = 50;
const int R3_Relai  = 52;

unsigned long R1_H_Start    = 11;                             //Heure de déclenchements du relai
unsigned long R2_H_Start    = 13;
unsigned long R3_H_Start    = 15;

unsigned long R1_FoisJour   = 2;                              //Nbr de déclenchement par 24h
unsigned long R1_Interval   = 86400 / (R1_FoisJour * 2000);   //Supprimer le * XXXX qui sert aux tests //Interval de déclenchement par 24h(86400s)
unsigned long R1_Duree      = 16;                             //Durée d'activation en secondes


//---------------------------------------- Initialisation des pompes Terminer Reglage
void initialiserRelais()
{
  pinMode(R1_Relai, OUTPUT);
  pinMode(R2_Relai, OUTPUT);
  pinMode(R3_Relai, OUTPUT);
  digitalWrite (R1_Relai, HIGH);
  digitalWrite (R2_Relai, HIGH);
  digitalWrite (R3_Relai, HIGH);
}

//---------------------------------------- SETUP
void setup() {
  Serial.begin(9600);
  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! rtc.isrunning()) {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    Serial.println("PROGRAMME DECLENCHEMENT DE RELAI");
  }

  initialiserRelais();
}

//---------------------------------------- LOOP
void loop() {

  DateTime now = rtc.now();
  Serial.println();

  DateTime H_EnCours(2000, 01, 01, now.hour(), now.minute(), now.second());        //Heure actuelle
  DateTime H_Ref(2000, 01, 01, 0, 52, 0);                                          //Heure de Référence pour les calculs 00:00:00 //Après les tests, remplacer les minutes par 0

  unsigned long J_Actuel          = now.dayOfTheWeek();
  unsigned long H_Actuelle        = H_EnCours.unixtime();
  unsigned long H_RefCalcul       = H_Ref.unixtime();
  unsigned long R1_H_ReglerStart  = H_RefCalcul + (R1_H_Start * 3600);
  unsigned long R1_H_StartDans    = R1_H_ReglerStart - H_Actuelle ;

  unsigned long R1_Start00 = (R1_H_ReglerStart + R1_Duree);
  unsigned long R1_Start01 = (R1_Start00 + R1_Interval + R1_Duree);
  unsigned long R1_Start02 = (R1_Start01 + R1_Interval + R1_Duree);
  unsigned long R1_Start03 = (R1_Start02 + R1_Interval + R1_Duree);
  unsigned long R1_Start04 = (R1_Start03 + R1_Interval + R1_Duree);
  unsigned long R1_Start05 = (R1_Start04 + R1_Interval + R1_Duree);
  unsigned long R1_Start06 = (R1_Start05 + R1_Interval + R1_Duree);
  unsigned long R1_Start07 = (R1_Start06 + R1_Interval + R1_Duree);
  unsigned long R1_Start08 = (R1_Start07 + R1_Interval + R1_Duree);
  unsigned long R1_Start09 = (R1_Start08 + R1_Interval + R1_Duree);
  unsigned long R1_Start10 = (R1_Start09 + R1_Interval + R1_Duree);
  unsigned long R1_Start11 = (R1_Start10 + R1_Interval + R1_Duree);
  unsigned long R1_Start12 = (R1_Start11 + R1_Interval + R1_Duree);



  if (R1_FoisJour >= 1 )        //Start 1
  { if ((H_Actuelle >= R1_H_ReglerStart) && (H_Actuelle < R1_Start00))  digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= R1_Start00) && (H_Actuelle < R1_Start01))        digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 2 )       //Start 2
  { if ((H_Actuelle >= R1_Start01) && (H_Actuelle < (R1_Start01 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start01 + R1_Duree)) && (H_Actuelle < R1_Start02)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 3 )       //Start 3
  { if ((H_Actuelle >= R1_Start02) && (H_Actuelle < (R1_Start02 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start02 + R1_Duree)) && (H_Actuelle < R1_Start03)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 4 )       //Start 4
  { if ((H_Actuelle >= R1_Start03) && (H_Actuelle < (R1_Start03 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start03 + R1_Duree)) && (H_Actuelle < R1_Start04)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 5 )       //Start 5
  { if ((H_Actuelle >= R1_Start04) && (H_Actuelle < (R1_Start04 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start04 + R1_Duree)) && (H_Actuelle < R1_Start05)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 6 )       //Start 6
  { if ((H_Actuelle >= R1_Start05) && (H_Actuelle < (R1_Start05 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start05 + R1_Duree)) && (H_Actuelle < R1_Start06)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 7 )       //Start 7
  { if ((H_Actuelle >= R1_Start06) && (H_Actuelle < (R1_Start06 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start06 + R1_Duree)) && (H_Actuelle < R1_Start07)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 8 )       //Start 8
  { if ((H_Actuelle >= R1_Start07) && (H_Actuelle < (R1_Start07 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start07 + R1_Duree)) && (H_Actuelle < R1_Start08)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 9 )       //Start 9
  { if ((H_Actuelle >= R1_Start08) && (H_Actuelle < (R1_Start08 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start08 + R1_Duree)) && (H_Actuelle < R1_Start09)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 10 )       //Start 10
  { if ((H_Actuelle >= R1_Start09) && (H_Actuelle < (R1_Start09 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start09 + R1_Duree)) && (H_Actuelle < R1_Start10)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 11 )       //Start 11
  { if ((H_Actuelle >= R1_Start10) && (H_Actuelle < (R1_Start10 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if ((H_Actuelle >= (R1_Start10 + R1_Duree)) && (H_Actuelle < R1_Start11)) digitalWrite (R1_Relai, HIGH);
  }

  if (R1_FoisJour >= 12 )       //Start 12
  { if ((H_Actuelle >= R1_Start11) && (H_Actuelle < (R1_Start11 + R1_Duree))) digitalWrite (R1_Relai, LOW);
    if  (H_Actuelle >= (R1_Start11 + R1_Duree)) digitalWrite (R1_Relai, HIGH);
  }

    delay(1000);                                                                 // Mettre la valeur a 1000 pour 1 seconde
}

hello
j'ai joué avec ton code mais sans le tester

//  le but final est de pouvoir déclencher 3 relais à des heures programmés et suivant un nbr de déclenchements choisi et une durée programmée.
//ex: R1_Relai sera déclenché 3 fois pendant 20 secondes à un interval de 3 heures. Le premier déclenchement aura lieu à 11h00
//ex: P2_Relai sera déclenché 2 fois pendant 3 minutes à un interval de 2h20. Le premier déclenchement aura lieu à 07h00
//ex: P3_Relai sera déclenché 6 fois pendant 1 minute à un interval de 1 heure. Le premier déclenchement aura lieu à 15h00
//voici ou je souhaiterai arriver.

#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 rtc;
char daysOfTheWeek[7][12] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};

const int R1_Relai  = 48;
const int R2_Relai  = 50;
const int R3_Relai  = 52;

unsigned long R1_H_Start    = 11;                             //Heure de déclenchements du relai
unsigned long R2_H_Start    = 13;
unsigned long R3_H_Start    = 15;

unsigned long R1_FoisJour   = 2;                              //Nbr de déclenchement par 24h
unsigned long R1_Interval   = 86400 / (R1_FoisJour * 2000);   //Supprimer le * XXXX qui sert aux tests //Interval de déclenchement par 24h(86400s)
unsigned long R1_Duree      = 16;                             //Durée d'activation en secondes


//---------------------------------------- Initialisation des pompes Terminer Reglage
void initialiserRelais()
{
  pinMode(R1_Relai, OUTPUT);
  pinMode(R2_Relai, OUTPUT);
  pinMode(R3_Relai, OUTPUT);
  digitalWrite (R1_Relai, HIGH);
  digitalWrite (R2_Relai, HIGH);
  digitalWrite (R3_Relai, HIGH);
}

//---------------------------------------- SETUP
void setup() 
{
  Serial.begin(9600);
  if (! rtc.begin()) 
  {
    Serial.println("Couldn't find RTC");
    while (1);
  }
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    Serial.println("PROGRAMME DECLENCHEMENT DE RELAI");
    initialiserRelais();
    DateTime now = rtc.now(); 
}

//---------------------------------------- LOOP
void loop() {
 DateTime now = rtc.now();
 Serial.print(now.hour());Serial.print(" ");Serial.print(now.minute());Serial.print(" ");Serial.print(now.second());Serial.print(" ");

  DateTime H_EnCours(2000, 01, 01, now.hour(), now.minute(), now.second());        //Heure actuelle
  DateTime H_Ref(2000, 01, 01, 0, 27, 0);                                          //Heure de Référence pour les calculs 00:00:00 //Après les tests, remplacer les minutes par 0

  unsigned long J_Actuel          = now.dayOfTheWeek();
  unsigned long H_Actuelle        = H_EnCours.unixtime();
  unsigned long H_RefCalcul       = H_Ref.unixtime();
  unsigned long R1_H_ReglerStart  = H_RefCalcul + (R1_H_Start * 3600);
  unsigned long R1_H_StartDans    = R1_H_ReglerStart - H_Actuelle ;
  unsigned long R1_Start[13];
   R1_Start[00] = (R1_H_ReglerStart + R1_Duree);
   R1_Start[01] = (R1_Start[00] + R1_Interval + R1_Duree);
   R1_Start[02] = (R1_Start[01] + R1_Interval + R1_Duree);
   R1_Start[03] = (R1_Start[02] + R1_Interval + R1_Duree);
   R1_Start[04] = (R1_Start[03] + R1_Interval + R1_Duree);
   R1_Start[05] = (R1_Start[04] + R1_Interval + R1_Duree);
   R1_Start[06] = (R1_Start[05] + R1_Interval + R1_Duree);
   R1_Start[07] = (R1_Start[06] + R1_Interval + R1_Duree);
   R1_Start[ 8] = (R1_Start[07] + R1_Interval + R1_Duree);
   R1_Start[ 9] = (R1_Start[ 8] + R1_Interval + R1_Duree);
   R1_Start[10] = (R1_Start[ 9] + R1_Interval + R1_Duree);
   R1_Start[11] = (R1_Start[10] + R1_Interval + R1_Duree);
   R1_Start[12] = (R1_Start[11] + R1_Interval + R1_Duree);
//*********************************************************  debut traitement pour relais 1  *********************************************************
 if (R1_FoisJour >= 1 )        //Start 1
  {     
    if ((H_Actuelle >= R1_H_ReglerStart) && (H_Actuelle < R1_Start[00]))         {digitalWrite (R1_Relai, LOW) ;Serial.println(F("relai 1 OFF"));} 
    if ((H_Actuelle >= R1_Start[00]) && (H_Actuelle < R1_Start[01]))             {digitalWrite (R1_Relai, HIGH);Serial.println(F("relai 1 ON "));}
  }
 for(byte F=2;F<12;F++)
 {
  if (R1_FoisJour >= F )        //Start 1 à 11
  {      
 if ((H_Actuelle >= R1_Start[F-1]) && (H_Actuelle < (R1_Start[F-1] + R1_Duree)))  {digitalWrite (R1_Relai, LOW) ;Serial.println(F("relai 1 OFF"));}    
 if ((H_Actuelle >= (R1_Start[F-1] + R1_Duree)) && (H_Actuelle < R1_Start[F]))    {digitalWrite (R1_Relai, HIGH);Serial.println(F("relai 1 ON "));}
  }
}
  if (R1_FoisJour >= 12 )       //Start 12
  { Serial.println("12 eme");
    if ((H_Actuelle >= R1_Start[11]) && (H_Actuelle < (R1_Start[11] + R1_Duree))) {digitalWrite (R1_Relai, LOW) ;Serial.println(F("relai 1 OFF"));}
    if  (H_Actuelle >= (R1_Start[11] + R1_Duree))                                 {digitalWrite (R1_Relai, HIGH);Serial.println(F("relai 1 ON "));}
  }
//***********************************************************  fin traitement pour relais 1 *********************************************************
    delay(1000);                                                                 // Mettre la valeur a 1000 pour 1 seconde
}

Bonsoir,
votre code fonctionne mais juste un truc que je ne comprends pas:

Serial.println(F(" relai 1 ON"));

pourquoi dans cette simple ligne, la variable F ne s'affiche pas avant relai 1 ON, alors que si je fais simplement Serial.print(F) cela s'affiche?

Merci par avance

ce F là n'a rien à voir avec l'autre, c'est une instruction pour le compilateur

Ok, donc si j'ai bien compris c'est pour stocker dans la mémoire du programme et ainsi libérer d'autant de la SRAM.

Merci encore