/*
 * =================================
 * DETECTION DE PRESENCE PAR ARDUINO
 *            CANTON N
 * les feux de canton sont
 * Vert en haut
 * Rouge au milieu
 * Jaune en bas
 * =================================

  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  !            Ce code est distribué gratuitement sous licence              !
  !                 Creativ Commons CC-BY-NC-ND 3.0                         !
  !                                                                         !
  !   Cette licence permet à d'autres utilisateurs d'utiliser ce code       !
  ! à des fins non commerciales,  dans la mesure où le nom de l'auteur est  !
  ! mentionné. Merci de m'informer de toute modification du code ce qui     !
  ! me permettra de continuer à apprendre.                                  !
  !                                                                         !
  ! auteur Philippe GUENET - [email protected] - https://wgnt-train.fr !
  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

  le 05/06/2025 => tout semble OK sur breadboard Nano
*/
// Choix de la carte 
#define IsNano 
//#define IsMiniPro

// Vérification qu'un et un seul des "define" est actif
#if (defined(IsNano) + defined(IsMiniPro)) > 1
    #error "Plusieurs cartes activées ! Définissez une seule carte à la fois."
#elif (defined(IsNano) + defined(IsMiniPro)) == 0
    #error "Aucune carte activée ! Définissez une carte avant de compiler. Pensez à la définir également dans l'IDE."
#endif

#if defined(IsMiniPro)
  /* A décommenter si on utilise les nouveaux PCB 20250608 */
  //#define Is_20250608
  /* ===================================================== */
  #if defined(Is_20250608)
    /* A décommenter si on utilise le décodage DCC */
    //#define isDCC
    #if defined(isDCC)
      /* A décommenter si utilisation de la Sprog3 */
      #define Sprog3ON
      /* ========================================= */

      /* A décommenter si utilisation d'une z21 dont la norme RCN 213 n'est pas activée */
      //#define IsZ21
      /* ============================================================================== */
    #endif
  #endif
#else
  /* A commenter en production */
  #define isDebug
  /* =========================== */
#endif

/* A décommenter si on souhaite un allumage / extinction des leds progressivement
//#define IsProgressif
*/
String Version = "Reprise DP-20250606";

#include <Bounce2.h>
Bounce pin_EtatN = Bounce();
Bounce pin_EtatNp2_to_N = Bounce();
Bounce pin_EtatNp1_to_N = Bounce();
const int dureeAntiRebond = 10;

// les E/S de N
const int pinLitEtatNp2_to_N = 4;                                                // => D7 de N+1
const int pinLitEtatNp1_to_N = 5;                                                // => D6 de N+1
const int pinEcritEtatN_to_Nm1 = 6;                                              // <= D5 de N-1
const int pinEcritEtatNp1_to_Nm1 = 7;                                            // <= D4 de N-1

#if defined(IsNano)
  // Pour les cartes à base de Nao (tests tinkercad ou workwi)
  const int pinLitEtatN  = 3;                                                    // lit l'état détecteur de présence de N
  const int pinRelaisBM1_N = 8;                                                  // commande le relais BM1
  const int pinLedSignalVerte = A5;                                              // pour Nano sur Tinkercad
  const int pinLedSignalRouge = A4;                                              // pour Nano sur Tinkercad
  const int pinLedSignalOrange = A3;                                             // pour Nano sur Tinkercad
  const int pinTemoinVert = A2;                                                  // pour Nano sur Tinkercad
  const int pinTemoinRouge = A1;                                                 // pour Nano sur Tinkercad

  /* DIP 6 digits pour les adresses des cartes */
  const int pinAdresseCarte[] = {A0, 13, 12, 11, 10,9};
  const int nbPinsAdresse = 6;

#else
  // Pour les cartes à base de MiniPro
  #if defined(Is_20250608)
    // Pour les PCB 20250608
    const int pinLitEtatN  = 8;                                                  // lit l'état détecteur de présence de N
    const int pinRelaisBM1_N = 9;                                                // commande le relais BM1
    const int pinLedSignalVerte = 1;                                             // mini pro / carte 20250608
    const int pinLedSignalRouge = 5;                                             // mini pro / carte 20250608                                
    const int pinLedSignalOrange = 4;                                            // mini pro / carte 20250608
    const int pinTemoinRouge = 3;                                                // mini pro / carte 20250608             
    const int pinTemoinVert = 2;                                                 // mini pro / carte 20250608
    
    /* DIP 7 digits pour les adresses des cartes */
    const int pinAdresseCarte[] = {A0, A6, 13, A7, 12, 10, 11};                  // mini pro / carte 20250608 
    const int nbPinsAdresse = 7;                                                 // mini pro / carte 20250608
    
    /* Pour le 74HC295 */
    const byte data_Pin = A3;       // Pin de donnée (DS)
    const byte verrou_Pin = A2;     // Pin de verrouillage (ST_CP)
    const byte horloge_Pin = A1;    // Pin de l'horloge (SH_CP)
    const byte Nombre_74hc595 = 1;  // Nombre de 74HC595 en série
    const byte numOfRegisterPins = Nombre_74hc595 * 8;
    boolean Registres[numOfRegisterPins];
    
  #else
    // Pour les PCB 20241008
    const int pinLitEtatN  = 3;                                                  // lit l'état détecteur de présence de N
    const int pinRelaisBM1_N = 8;                                                // commande le relais BM1
    const int pinLedSignalVerte = A5;                                            // mini pro / carte 20241008
    const int pinLedSignalRouge = A4;                                            // mini pro / carte 20241008                                
    const int pinLedSignalOrange = A3;                                           // mini pro / carte 20241008
    const int pinTemoinRouge = A1;                                               // mini pro / carte 20241008             
    const int pinTemoinVert = A2;                                                // mini pro / carte 20241008
    const int pinAdresseCarte[] = {A0, A6, 13 ,A7, 12, 11, 10, 9};               // mini pro / carte 20241008         
    const int nbPinsAdresse = 8;                                                 // mini pro / carte 20241008
  #endif
#endif
/* ================================ */

/* DEFINITIONS ET VARIABLES POUR LE DCC */
#if defined(isDCC)
  #include <DCC_Decoder.h>
  #define pinInterruptionDCC 2
  #include <NmraDcc.h>
  #define pinACK 3                                                                // envoie l'ordre de coupure ACK
  int adresseLocomotive;
#endif
/* ==================================== */

// les variables
bool etatDetecteur_N = LOW;
bool etatDetecteur_Np1 = LOW;
bool etatDetecteur_Np1_old = LOW;
bool etatVerrou_N = LOW;
bool etatDetecteur_Np2 = LOW;
bool etatDetecteur_Np2_old = LOW;

int valeurDipAdresseCarte;
int adresseCarte = 1;

enum Etat {
  N_Off_Np1_Off_Np2_Off,
  N_Off_Np1_On_Np2_Off,
  N_Off_Np1_Off_Np2_On,
  N_Off_Np1_On_Np2_On,
  N_On_Np1_Off_Np2_Off,
  N_On_Np1_On_Np2_Off,
  N_On_Np1_Off_Np2_On,
  N_On_Np1_On_Np2_On
};

// Variable pour stocker l'état actuel
Etat etatCarte;

void setup() {
  #if defined(isDebug)
    Serial.begin(38400);
    Serial.print(F("Détecteur de présence : "));Serial.print(Version);
  #endif

  #if defined(isDCC)
  // On initialise les pins DCC et autres fonctions
  
  #endif

  #if defined(Is_20250608)
    // Initialiser les pins comme sorties
    pinMode(data_Pin, OUTPUT);
    pinMode(verrou_Pin, OUTPUT);
    pinMode(horloge_Pin, OUTPUT);

    /* Tests des 74HC595 */
    for (int i = 0; i < numOfRegisterPins; i++) {
        ecritRegistre(i, HIGH);
    }
    delay(1000); 

    for (int i = 0; i < numOfRegisterPins; i++) {
        ecritRegistre(i, LOW);
    }
    /* ================= */
   
    // Reset tous les pins du 74HC595
    clearRegisters();
    /* ========================== */  
  #endif

  /* Initalisation des pin d'entrées pour Bounce2 */
  pin_EtatN.attach(pinLitEtatN, INPUT_PULLUP);
  pin_EtatN.interval(dureeAntiRebond);
  pin_EtatNp1_to_N.attach(pinLitEtatNp1_to_N, INPUT_PULLUP);
  pin_EtatNp1_to_N.interval(dureeAntiRebond);
  pin_EtatNp2_to_N.attach(pinLitEtatNp2_to_N, INPUT_PULLUP);
  pin_EtatNp2_to_N.interval(dureeAntiRebond);
  /* ============================================ */
  
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(pinEcritEtatN_to_Nm1, OUTPUT);
  pinMode(pinEcritEtatNp1_to_Nm1, OUTPUT);
  pinMode(pinRelaisBM1_N, OUTPUT);
  pinMode(pinLedSignalRouge, OUTPUT);
  pinMode(pinLedSignalVerte, OUTPUT);
  pinMode(pinLedSignalOrange, OUTPUT);
  pinMode(pinTemoinRouge, OUTPUT);
  pinMode(pinTemoinVert, OUTPUT);

  /* calcul de l'adresse de la carte */
  for (int i = 0; i < nbPinsAdresse; i++) {
    pinMode(pinAdresseCarte[i], INPUT_PULLUP);
    valeurDipAdresseCarte += !digitalRead(pinAdresseCarte[i]) * (1 << i);
  } // Fin de for (int i = 0; i < 6; i++)

  adresseCarte = valeurDipAdresseCarte + 1;
  #if defined(isDebug)
    Serial.print(F(" / Adresse carte = ")); Serial.println(adresseCarte); Serial.println("");
  #endif
  /* ============================== */
  
 // On lit l'état du détecteur de la carte de N
  pin_EtatN.update();
  etatDetecteur_N = !pin_EtatN.read();
  #if defined(isDebug)
    Serial.print(F("Etat initial carte N : ")); Serial.println(etatDetecteur_N);
  #endif
  
  // On envoie l'état de N vers la carte N - 1
  digitalWrite(pinEcritEtatN_to_Nm1, etatDetecteur_N);
  delay(10);

  // On lit l'état du détecteur de présence de N + 1
  pin_EtatNp1_to_N.update();
  etatDetecteur_Np1 = pin_EtatNp1_to_N.read();
  #if defined(isDebug)
    Serial.print(F("Etat initial carte N + 1 : ")); Serial.println(etatDetecteur_Np1);
  #endif

  // On envoie l'état de N + 1 vers la carte N - 1
  digitalWrite(pinEcritEtatNp1_to_Nm1, etatDetecteur_Np1);
  delay(10);

  // On lit l'état du détecteur de présence de N + 2
  pin_EtatNp2_to_N.update();
  etatDetecteur_Np2 = pin_EtatNp2_to_N.read();
 #if defined(isDebug)
    Serial.print(F("Etat initial carte N + 2 : ")); Serial.println(etatDetecteur_Np2);
  #endif

  // On reporte les différents états
  actualiserEtat(); Traitement();
} // Fin de setup()

void loop() {
  /* On vérifie toute modification de l'état de la carte N */
  pin_EtatN.update();
  if (pin_EtatN.changed()) {
    // S'il y a une modification on applique le traitement pour N
    Traitement_N();
  } // Fin de if (pin_EtatN.changed())
  /* ===================================================== */
    
  /* On vérifie toute modification de l'état de la carte N+ 1 */
  pin_EtatNp1_to_N.update();
  if (pin_EtatNp1_to_N.changed()){
    etatDetecteur_Np1 = pin_EtatNp1_to_N.read();
    //s'il y a modification on applique le traitement pour N + 1
    Traitement_Np1();
  } // Fin de  if (pin_EtatNp1_to_N.changed()

  /* On vérifie toute modification de l'état de la carte N + 2 */
  pin_EtatNp2_to_N.update();
  if (pin_EtatNp2_to_N.changed()) {
    etatDetecteur_Np2 = pin_EtatNp2_to_N.read();
    //s'il y a modification eon applique le traitement pour N + 1   
    actualiserEtat(); Traitement();
  } // Fin de if (pin_EtatNp2_to_N.changed()

} // Fin de loop()

void actualiserEtat() {
  /***************************************************/
  /* On actualise la carte N en fonction de son état */
  /***************************************************/

  // Calculer l'état de la carte en fonction des entrées
  if (etatDetecteur_N == LOW && etatDetecteur_Np1 == LOW && etatDetecteur_Np2 == LOW) {
    etatCarte = N_Off_Np1_Off_Np2_Off;
  } else if (etatDetecteur_N == LOW && etatDetecteur_Np1 == LOW && etatDetecteur_Np2 == HIGH) {
    etatCarte = N_Off_Np1_Off_Np2_On;
  } else if (etatDetecteur_N == LOW && etatDetecteur_Np1 == HIGH && etatDetecteur_Np2 == LOW) {
    etatCarte = N_Off_Np1_On_Np2_Off;
  } else if (etatDetecteur_N == LOW && etatDetecteur_Np1 == HIGH && etatDetecteur_Np2 == HIGH) {
    etatCarte = N_Off_Np1_On_Np2_On;
  } else if (etatDetecteur_N == HIGH && etatDetecteur_Np1 == LOW && etatDetecteur_Np2 == LOW) {
    etatCarte = N_On_Np1_Off_Np2_Off;
  } else if (etatDetecteur_N == HIGH && etatDetecteur_Np1 == LOW && etatDetecteur_Np2 == HIGH) {
    etatCarte = N_On_Np1_Off_Np2_On;
  } else if (etatDetecteur_N == HIGH && etatDetecteur_Np1 == HIGH && etatDetecteur_Np2 == LOW) {
    etatCarte = N_On_Np1_On_Np2_Off;
  } else if (etatDetecteur_N == HIGH && etatDetecteur_Np1 == HIGH && etatDetecteur_Np2 == HIGH) {
    etatCarte = N_On_Np1_On_Np2_On;
  } // Fin de if (etat_N == LOW && etat_Np1 == LOW && etat_Np2 == LOW)
} // Fin de procédure actualiserEtat()

void Traitement_N() {
  // On lit l'état du détecteur de la carte de N
  etatDetecteur_N = !pin_EtatN.read();
  
  // On envoie l'état de N vers la carte N-1
  digitalWrite(pinEcritEtatN_to_Nm1, etatDetecteur_N);
  
  // On lit l'état du détecteur de la carte de N + 2
  etatDetecteur_Np2 = pin_EtatNp2_to_N.read();

  // On reporte les différents états
  actualiserEtat(); Traitement();

  #if defined(isDebug)
    Serial.println(F("Traitement N => OK"));
    Serial.print(F("Etat carte ")); Serial.print(adresseCarte);
    Serial.print(F(" passe à ")); Serial.println(etatDetecteur_N);
  #endif
} // Fin de procédure Traitement_N()

void Traitement_Np1() {
  etatDetecteur_Np1 = pin_EtatNp1_to_N.read();
  // On envoie l'état de N+1 vers la carte N-1
  digitalWrite(pinEcritEtatNp1_to_Nm1, etatDetecteur_Np1);
  
  // On lit l'état du détecteur de la carte de N + 2
  etatDetecteur_Np2 = pin_EtatNp2_to_N.read();
  
  // On reporte les différents états
  actualiserEtat();Traitement();
  
   #if defined(isDebug)
    Serial.println(F("Traitement N + 1=> OK"));
    Serial.print(F("Etat carte ")); Serial.print(adresseCarte);
    Serial.print(F(" = ")); Serial.println(etatDetecteur_N);
    Serial.print(F("Etat N + 1 passe à ")); Serial.println(etatDetecteur_Np1);
  #endif
} // Fin de procédure Traitement_Np1

void Traitement() {
  // On met à jour la led témoin
  #if defined (Is_20250608) // PCB miniPro 20250608
    ecritRegistre(pinTemoinRouge, etatDetecteur_N);
    ecritRegistre(pinTemoinVert, !etatDetecteur_N);
  #else  
    digitalWrite(pinTemoinRouge, etatDetecteur_N);
    digitalWrite(pinTemoinVert, !etatDetecteur_N);
  #endif
  
  #if defined(IsProgressif)
    // Gérer l'état actuel
    switch (etatCarte) {
      case N_Off_Np1_Off_Np2_Off:
      /* tout est à OFF 
      * donc pas de convoi dans l'espace
      * signal au vert
      */
        #if defined(isDebug)
          Serial.println(F("Cas 1 !"));
        #endif
        controleLed(pinLedSignalRouge, "OFF");
        controleLed(pinLedSignalVerte, "ON");
        controleLed(pinLedSignalOrange, "OFF");
        //digitalWrite(pinRelaisBM1_N, "OFF");
        break;
      
      case N_Off_Np1_Off_Np2_On:
    /* seul Np2 est à ON
      * donc le wagon de queue est encore sur Np2
      * le signal de N est à l'orange
      * le ralentisseur de N est activé par la carte Np1
      */
        #if defined(isDebug)
          Serial.println(F("Cas 2 !"));
        #endif
        controleLed(pinLedSignalRouge, "OFF");
        controleLed(pinLedSignalVerte, "OFF");
        controleLed(pinLedSignalOrange, "ON");
        //digital.Write(pinRelaisBM1_N, "ON");
        break;

      case N_Off_Np1_On_Np2_Off:
      /* seul Np1 est à ON 
      * donc le convoi est en entier sur Np1
      * le signal de N est au rouge
      * le ralentisseur de N est activé
      */
        #if defined(isDebug)
          Serial.println(F("Cas 3 !"));
        #endif
        controleLed(pinLedSignalRouge, "ON");
        controleLed(pinLedSignalVerte, "OFF");
        controleLed(pinLedSignalOrange, "OFF");
        //digital.Write(pinRelaisBM1_N, "ON");
        break;

      case N_Off_Np1_On_Np2_On:
      /* Np1 et Np2 sont à ON
      * donc la locomotive est sur Np2 mais le
      * wagon de queue est encore sur Np1
      * le signal de N est au rouge
      * le ralentisseur de N est activé
      */
        #if defined(isDebug)
          Serial.println(F("Cas 4 !"));
        #endif
        controleLed(pinLedSignalRouge, "ON");
        controleLed(pinLedSignalVerte, "OFF");
        controleLed(pinLedSignalOrange, "OFF");
        //digital.Write(pinRelaisBM1_N, "ON");
        break;

      case N_On_Np1_Off_Np2_Off:
      /* seul N est à On
      * donc au moins la locomotive est sur N
      * le signal de N est au vert
      * le ralentisseur de N est désactivé
      */
        #if defined(isDebug)
          Serial.println(F("Cas 5 !"));
        #endif
        controleLed(pinLedSignalRouge, "OFF");
        controleLed(pinLedSignalVerte, "ON");
        controleLed(pinLedSignalOrange, "OFF");
        //digital.Write(pinRelaisBM1_N, "OFF");
        break;

      case N_On_Np1_Off_Np2_On:
      /* Np2 et N sont à ON
      * donc au moins une loco est sur N
      * et un wagon de fin de queue est encore sur Np2
      * le signal de N est à l'orange
      * le ralentisseur de N est activé
      * A VERIFIER
      */
        #if defined(isDebug)
          Serial.println(F("Cas 6 !"));
        #endif
        controleLed(pinLedSignalRouge, "OFF");
        controleLed(pinLedSignalVerte, "OFF");
        controleLed(pinLedSignalOrange, "ON");
        //digital.Write(pinRelaisBM1_N, "ON");
        break;

      case N_On_Np1_On_Np2_Off:
        #if defined(isDebug)
          Serial.println(F("Cas 7 !"));
        #endif
        controleLed(pinLedSignalRouge, "OFF");
        controleLed(pinLedSignalVerte, "ON");
        controleLed(pinLedSignalOrange, "OFF");
        //digital.Write(pinRelaisBM1_N, "OFF");
        break;

      case N_On_Np1_On_Np2_On:
        #if defined(isDebug)
          Serial.println(F("Cas 8 !"));
        #endif
        controleLed(pinLedSignalRouge, "ON");
        controleLed(pinLedSignalVerte, "OFF");
        controleLed(pinLedSignalOrange, "ON");
        //digital.Write(pinRelaisBM1_N, "ON");
        break;
    } // Fin de switch (etatCarte)
  #else // si pas progressif
    // Gérer l'état actuel
     #if defined (Is_20250608) // PCB miniPro 20250608
        switch (etatCarte) {
        case N_Off_Np1_Off_Np2_Off:
        /* tout est à OFF 
        * donc pas de convoi dans l'espace
        * signal au vert
        */
          #if defined(isDebug)
            Serial.println(F("Cas 1 !"));
          #endif
          ecritRegistre(pinLedSignalRouge, LOW);
          ecritRegistre(pinLedSignalVerte, HIGH);
          ecritRegistre(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, LOW);
          break;
      
        case N_Off_Np1_Off_Np2_On:
          #if defined(isDebug)
            Serial.println(F("Cas 2 !"));
          #endif
          ecritRegistre(pinLedSignalRouge, LOW);
          ecritRegistre(pinLedSignalVerte, LOW);
          ecritRegistre(pinLedSignalOrange, HIGH);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;

        case N_Off_Np1_On_Np2_Off:
          #if defined(isDebug)
            Serial.println(F("Cas 3 !"));
          #endif
          ecritRegistre(pinLedSignalRouge, HIGH);
          ecritRegistre(pinLedSignalVerte, LOW);
          ecritRegistre(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;

        case N_Off_Np1_On_Np2_On:
          #if defined(isDebug)
            Serial.println(F("Cas 4 !"));
          #endif
          ecritRegistre(pinLedSignalRouge, HIGH);
          ecritRegistre(pinLedSignalVerte, LOW);
          ecritRegistre(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;

        case N_On_Np1_Off_Np2_Off:
          #if defined(isDebug)
            Serial.println(F("Cas 5 !"));
          #endif
          ecritRegistre(pinLedSignalRouge, LOW);
          ecritRegistre(pinLedSignalVerte, HIGH);
          ecritRegistre(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, LOW);
          break;

        case N_On_Np1_Off_Np2_On:
          #if defined(isDebug)
            Serial.println(F("Cas 6 !"));
          #endif
          ecritRegistre(pinLedSignalRouge, LOW);
          ecritRegistre(pinLedSignalVerte, LOW);
          ecritRegistre(pinLedSignalOrange, HIGH);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;

        case N_On_Np1_On_Np2_Off:
          #if defined(isDebug)
            Serial.println(F("Cas 7 !"));
          #endif
          ecritRegistre(pinLedSignalRouge, LOW);
          ecritRegistre(pinLedSignalVerte, HIGH);
          ecritRegistre(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, LOW);
          break;

        case N_On_Np1_On_Np2_On:
          #if defined(isDebug)
            Serial.println(F("Cas 8 !"));
          #endif
          ecritRegistre(pinLedSignalRouge, HIGH);
          ecritRegistre(pinLedSignalVerte, LOW);
          ecritRegistre(pinLedSignalOrange, HIGH);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;
      } // Fin de switch (etatCarte)
     
     #else // autres cartes
      switch (etatCarte) {
        case N_Off_Np1_Off_Np2_Off:
        /* tout est à OFF 
        * donc pas de convoi dans l'espace
        * signal au vert
        */
          #if defined(isDebug)
            Serial.println(F("Cas 1 !"));
          #endif
          digitalWrite(pinLedSignalRouge, LOW);
          digitalWrite(pinLedSignalVerte, HIGH);
          digitalWrite(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, LOW);
          break;
      
        case N_Off_Np1_Off_Np2_On:
          #if defined(isDebug)
            Serial.println(F("Cas 2 !"));
          #endif
          digitalWrite(pinLedSignalRouge, LOW);
          digitalWrite(pinLedSignalVerte, LOW);
          digitalWrite(pinLedSignalOrange, HIGH);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;

        case N_Off_Np1_On_Np2_Off:
          #if defined(isDebug)
            Serial.println(F("Cas 3 !"));
          #endif
          digitalWrite(pinLedSignalRouge, HIGH);
          digitalWrite(pinLedSignalVerte, LOW);
          digitalWrite(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;

        case N_Off_Np1_On_Np2_On:
          #if defined(isDebug)
            Serial.println(F("Cas 4 !"));
          #endif
          digitalWrite(pinLedSignalRouge, HIGH);
          digitalWrite(pinLedSignalVerte, LOW);
          digitalWrite(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;

        case N_On_Np1_Off_Np2_Off:
          #if defined(isDebug)
            Serial.println(F("Cas 5 !"));
          #endif
          digitalWrite(pinLedSignalRouge, LOW);
          digitalWrite(pinLedSignalVerte, HIGH);
          digitalWrite(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, LOW);
          break;

        case N_On_Np1_Off_Np2_On:
          #if defined(isDebug)
            Serial.println(F("Cas 6 !"));
          #endif
          digitalWrite(pinLedSignalRouge, LOW);
          digitalWrite(pinLedSignalVerte, LOW);
          digitalWrite(pinLedSignalOrange, HIGH);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;

        case N_On_Np1_On_Np2_Off:
          #if defined(isDebug)
            Serial.println(F("Cas 7 !"));
          #endif
          digitalWrite(pinLedSignalRouge, LOW);
          digitalWrite(pinLedSignalVerte, HIGH);
          digitalWrite(pinLedSignalOrange, LOW);
          digitalWrite(pinRelaisBM1_N, LOW);
          break;

        case N_On_Np1_On_Np2_On:
          #if defined(isDebug)
            Serial.println(F("Cas 8 !"));
          #endif
          digitalWrite(pinLedSignalRouge, HIGH);
          digitalWrite(pinLedSignalVerte, LOW);
          digitalWrite(pinLedSignalOrange, HIGH);
          digitalWrite(pinRelaisBM1_N, HIGH);
          break;
      } // Fin de switch (etatCarte)
    #endif
  #endif
} // Fin de procédure Traitement()

void controleLed(int ledPin, String action) {
  #if defined(isDebug)
    Serial.print(F("Led : ")); Serial.print(ledPin);
    Serial.print(F(" est a ")); Serial.println(action);
  #endif
  
  if (action == "ON") {
    for (int i = 100; i <= 255; i++) {
      analogWrite(ledPin, i); // Augmenter progressivement la luminosité
      //delay(5); // Ajuster ce délai pour contrôler la vitesse de l'allumage
    } // Fin de for (int i = 0; i <= 255; i++)
  } else if (action == "OFF") {
    for (int i = 255; i >= 100; i--) {
      analogWrite(ledPin, i); // Diminuer progressivement la luminosité
      //delay(5); // Ajuster ce délai pour contrôler la vitesse de l'extinction
    } // Fin de for (int i = 0; i <= 255; i++)
  } // Fin de if (action == "ON")
} // Fin de procédure controleLed(int ledPin, String action)

#if defined(Is_20250608)
  void clearRegisters() {  
    // Place tous les pins du 74HC595 à l'état "OFF"
    for (int i = 0; i < numOfRegisterPins; i++) {
        Registres[i] = LOW;
    } // Fin de for (int i = 0; i < numOfRegisterPins; i++)
    // Met à jour les registres avec les valeurs initialisées
    updateRegisters();
  } // Fin de procédure clearRegisters()

  void ecritRegistre(int index, int value) {
    // Enregistrer la valeur dans le registre
    Registres[index] = value;
    // Met à jour les registres avec la nouvelle valeur
    updateRegisters();
  } // Fin de procédure ecritRegistre(int index, int value)

  void updateRegisters() {
    // Mettre à jour et afficher les valeurs dans le registre
    digitalWrite(verrou_Pin, LOW);

    for (int i = numOfRegisterPins - 1; i >= 0; i--) {
        digitalWrite(horloge_Pin, LOW);
        digitalWrite(data_Pin, Registres[i]);
        digitalWrite(horloge_Pin, HIGH);
    } // Fin de for (int i = numOfRegisterPins - 1; i >= 0; i--)
    digitalWrite(verrou_Pin, HIGH);
  } // Fin de procedure updateRegisters()
#endif