/*  Claude EMERY - 10/08/2026 - Version 06
    RETOUR EN UNE FOIS EN 27.5 secondes A 21H30
    **************************************************************************************************
    Code Arduino pour piloter deux relais avec un module RTC et deux led 
    pour indiquer le relais qui est en fonctionnement. 
    Le relais 1 commute toutes les heures pendant 2.5 secondes de 09h00 à 20h00 avec le relais 2 OFF,
    puis le relais 2 commute à 21h30 pendant 27.5 secondes, avec le relais 1 OFF. 
    **************************************************************************************************
    Relais 1 :
      de 09:00 à 20:00
      déclenchement toutes les heures : 09:00, 10:00, …, 20:00 -> ON pendant 2,5 secondes
      Relais 2 forcé OFF
      LED 1 allumée pendant l'activation
    Relais 2 :
      déclenchement à 21:30 -> ON pendant 27,5 secondes
      Relais 1 forcé OFF
      LED 2 allumée pendant l'activation
    Les temporisations sont réalisées avec millis()
    Le RTC est ici un DS3231 avec la bibliothèque RTClib
*/

// =====================================================
// LIBRAIRIES 
// =====================================================
#include <Wire.h>       // Pour la gestion I2C (SDA/SCL)
#include <RTClib.h>     // Pour la gestion du module RTC

// =====================================================
// CONFIGURATION DES BROCHES
// =====================================================
const byte LED1 = 6;          // Pin 6 Led Rouge
const byte LED2 = 7;          // Pin 7 Led Verte
const byte RELAIS1 = 8;       // Pin 8 Relais 1 pour la journée
const byte RELAIS2 = 9;       // Pin 9 Relais 2 pour la nuit

// =====================================================
// CONFIGURATION DU MODULE RELAIS
// =====================================================
// Beaucoup de modules relais sont ACTIFS à LOW.
// Mettre true si le relais s'active avec LOW.
// Mettre false si le relais s'active avec HIGH.
const bool RELAIS_ACTIF_LOW = true;

// =====================================================
// DURÉES
// =====================================================
const unsigned long DUREE_RELAIS1 = 2500UL;   // 2,5 secondes pour la journée
const unsigned long DUREE_RELAIS2 = 27500UL;  // 27,5 secondes pour la nuit

// =====================================================
// RTC
// =====================================================
RTC_DS3231 rtc;    // Initialisation du RTC

// =====================================================
// ÉTAT DU PROGRAMME
// =====================================================
enum Etat {
  REPOS,
  RELAIS1_ACTIF,
  RELAIS2_ACTIF
};
Etat etat = REPOS;
unsigned long debutActivation = 0;

// Mémorisation du dernier déclenchement
int derniereHeureRelais1 = -1;
int dernierJourRelais1 = -1;
int dernierJourRelais2 = -1;

// =====================================================
// FONCTIONS RELAIS
// =====================================================
void relais1ON() {
  digitalWrite(RELAIS1, RELAIS_ACTIF_LOW ? HIGH : LOW);
  digitalWrite(LED1, HIGH);
}

void relais1OFF() {
  digitalWrite(RELAIS1, RELAIS_ACTIF_LOW ? LOW : HIGH);
  digitalWrite(LED1, LOW);
}

void relais2ON() {
  digitalWrite(RELAIS2, RELAIS_ACTIF_LOW ? HIGH : LOW);
  digitalWrite(LED2, HIGH);
}

void relais2OFF() {
  digitalWrite(RELAIS2, RELAIS_ACTIF_LOW ? LOW : HIGH);
  digitalWrite(LED2, LOW);
}

// =====================================================
// ARRÊT DE TOUS LES RELAIS
// =====================================================
void tousRelaisOFF() { 
  relais1OFF();
  relais2OFF();
}

// =====================================================
// SETUP
// =====================================================
void setup() {
  Serial.begin(9600);         // Initialisation Moniteur série
  Wire.begin();               // Initialisation I2C (Pour le RTC)
  pinMode(RELAIS1, OUTPUT);   // Pin 8 - Relais 1 en OUTPUT
  pinMode(RELAIS2, OUTPUT);   // Pin 9 - Relais 2 en OUTPUT
  pinMode(LED1, OUTPUT);      // Pin 7 - Led 1 Rouge en OUTPUT
  pinMode(LED2, OUTPUT);      // Pin 8 - Led 2 Verte en OUTPUT
  tousRelaisOFF();            // Sécurité : tout couper au démarrage

  if (!rtc.begin()) {         // Initialisation du RTC
    Serial.println("ERREUR : RTC DS3231 introuvable !");
    // Sécurité : relais coupés
    tousRelaisOFF();
    while (1) {
      // Blocage volontaire car le RTC est indispensable
    }
  }

  // Si le RTC a perdu son alimentation,
  // il est réglé avec la date/heure de compilation.

  if (rtc.lostPower()) {  // Si RTC non détecté !
    Serial.println("RTC : perte d'alimentation !");
    Serial.println("Réglage de l'heure avec la date de compilation.");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  // Si RTC détecté => Message Systeme demarre ...
  Serial.println("Systeme demarre.");
}

// =====================================================
// LOOP
// =====================================================
void loop() {
  DateTime maintenant = rtc.now();
  int heure = maintenant.hour();
  int minute = maintenant.minute();
  int seconde = maintenant.second();
  unsigned long maintenantMillis = millis();

  // ===================================================
  // GESTION DU RELAIS 1
  // ===================================================

  // Le relais 1 fonctionne à chaque heure pleine
  // entre 09:00 et 20:00 inclus.
  //
  // Exemple :
  // 09:00:00
  // 10:00:00
  // ...
  // 20:00:00
  if (etat == REPOS) {
    if (minute == 0 &&
        seconde == 0 &&
        heure >= 9 &&
        heure <= 20) {
      // Évite plusieurs déclenchements pendant la même seconde
      if (derniereHeureRelais1 != heure ||
          dernierJourRelais1 != maintenant.day()) {
        // Relais 2 doit impérativement être OFF
        relais2OFF();
        // Activation relais 1
        relais1ON();
        debutActivation = maintenantMillis;
        etat = RELAIS1_ACTIF;
        derniereHeureRelais1 = heure;
        dernierJourRelais1 = maintenant.day();
        Serial.print("Relais 1 ON - ");
        Serial.print(heure);
        Serial.println(":00");
      }
    }
  }

  // ===================================================
  // FIN DU RELAIS 1 APRÈS 2,5 SECONDES
  // ===================================================
  if (etat == RELAIS1_ACTIF) {
    if (maintenantMillis - debutActivation >= DUREE_RELAIS1) {
      relais1OFF();
      etat = REPOS;
      Serial.println("Relais 1 OFF");
    }
  }

  // ===================================================
  // GESTION DU RELAIS 2
  // ===================================================
  // Activation à 21:30:00
  // pendant 27,5 secondes.

  if (etat == REPOS) {
    if (heure == 21 &&
        minute == 30 &&
        seconde == 0) {
      // Évite plusieurs déclenchements le même jour
      if (dernierJourRelais2 != maintenant.day()) {
        // Relais 1 doit impérativement être OFF
        relais1OFF();
        // Activation relais 2
        relais2ON();
        debutActivation = maintenantMillis;
        etat = RELAIS2_ACTIF;
        dernierJourRelais2 = maintenant.day();
        Serial.println("Relais 2 ON - 21:30");
      }
    }
  }

  // ===================================================
  // FIN DU RELAIS 2 APRÈS 27,5 SECONDES
  // ===================================================
  if (etat == RELAIS2_ACTIF) {
    if (maintenantMillis - debutActivation >= DUREE_RELAIS2) {
      relais2OFF();
      etat = REPOS;
      Serial.println("Relais 2 OFF");
    }
  }

  // ===================================================
  // AFFICHAGE OPTIONNEL DANS LE MONITEUR SÉRIE
  // ===================================================
  static int derniereSecondeAffichee = -1;
  if (seconde != derniereSecondeAffichee) {
    derniereSecondeAffichee = seconde;
    Serial.print(heure);
    Serial.print(":");
    if (minute < 10) Serial.print("0");
    Serial.print(minute);
    Serial.print(":");
    if (seconde < 10) Serial.print("0");
    Serial.println(seconde);
  }
}