/*
    ***********************************************
    *      Gestion d'aiguillages à bobines        *
    *              version 20240304               *
    *     Utilisation avec les BP en PULL_UP      *
    *               et Bounce2                    *
    *              Arduino Nano                   *
    *       Exemple pour 4 aiguillages            *
    ***********************************************

      
  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  !            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é. Toute modification du code devra être soumise à              !
  ! l'autorisation expresse de l'auteur.                                    !
  !                                                                         !
  ! auteur Philippe GUENET - [email protected] - https://wgnt-train.fr  !
  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*/
 
#include <EEPROM.h>
#include <Bounce2.h>
   
const int Nb_Aiguillages = 4;
const int pinPoussoir[Nb_Aiguillages] = {3, 4, 5, 6};
const int pinDirectAiguillages[Nb_Aiguillages] = {7, 9, 11, 13};
const int pinDevieAiguillages[Nb_Aiguillages] = {8, 10, 12, 14};
const int pinDirectLeds[Nb_Aiguillages] = {A0, A2, A4, A6};
const int pinDevieLeds[Nb_Aiguillages] = {A1, A3, A5, A7};

enum EtatDirection{ DIRECT = 1, DEVIE = 2 };
struct aiguillage {
    int adresse;
    int pinDirect;
    int pinDevie;
    int pinDirectLed;
    int pinDevieLed;
    EtatDirection DernierePosition;
};
aiguillage Aiguillage[Nb_Aiguillages];

const uint32_t dureeAntiRebond = 50;
Bounce clavierBP[Nb_Aiguillages] = Bounce();

int CompteurLoop = 0;
const uint32_t dureeImpulsion = 200ul;
uint32_t  tempsDebutImpulsion = 0;

void setup() {
  //Serial.begin(115200);

  for (int i = 0; i < Nb_Aiguillages; i++) {
    clavierBP[i].attach(pinPoussoir[i], INPUT_PULLUP);
    clavierBP[i].interval(dureeAntiRebond);
    pinMode(pinDirectAiguillages[i], OUTPUT);
    pinMode(pinDevieAiguillages[i], OUTPUT);
    pinMode(pinDirectLeds[i], OUTPUT);
    pinMode(pinDevieLeds[i], OUTPUT);
    Aiguillage[i].pinDirect = pinDirectAiguillages[i];
    Aiguillage[i].pinDevie = pinDevieAiguillages[i];
    Aiguillage[i].pinDirectLed = pinDirectLeds[i];
    Aiguillage[i].pinDevieLed = pinDevieLeds[i];

    // Lire la dernière position depuis l'EEPROM
    byte valeurStockee = EEPROM.read(i);

    // Vérifier la validité et définir l'état initial de l'aiguillage
    if (valeurStockee == DIRECT || valeurStockee == DEVIE) {
      Aiguillage[i].DernierePosition = static_cast<EtatDirection>(valeurStockee);
    } else {
      // Valeur invalide, on positionne à DIRECT par déaut
      Aiguillage[i].DernierePosition = DIRECT;
      EEPROM.update(i, DIRECT);  // Sauvegarder la valeur par défaut
    } // Fin de if (valeurStockee == DIRECT || valeurStockee == DEVIE)

    // Appliquer l'état initial de l'aiguillage
    mettreAJourAiguillage(i);
  } // Fin de for (int i = 0; i < Nb_Aiguillages; i++)
} // Fin de setup


void loop() {
  /* on se sert de la boucle du loop */
  CompteurLoop++; if (CompteurLoop == Nb_Aiguillages) {CompteurLoop = 0;} 
  //Serial.println(CompteurLoop);
  /* ========================================= */
  
  clavierBP[CompteurLoop].update();                                                                     // on surveille les BP du clavier digital
  if (clavierBP[CompteurLoop].fell()){
    /* Bouton appuyé, basculer l'état de l'aiguillage */
    Aiguillage[CompteurLoop].DernierePosition = (Aiguillage[CompteurLoop].DernierePosition == DIRECT) ? DEVIE : DIRECT;   
    /* Mettre à jour physiquement l'aiguillage et gérer les leds*/
    mettreAJourAiguillage(CompteurLoop);
  } // Fin de if (clavierBP[CompteurLoop].fell())
} // Fin de loop

void mettreAJourAiguillage(int indiceAiguillage) {
  switch(Aiguillage[indiceAiguillage].DernierePosition) {
    case DIRECT:      
      digitalWrite(Aiguillage[indiceAiguillage].pinDirect, HIGH);
      delay(dureeImpulsion);
      digitalWrite(Aiguillage[indiceAiguillage].pinDirect, LOW);
      digitalWrite(Aiguillage[indiceAiguillage].pinDirectLed,HIGH);
      digitalWrite(Aiguillage[indiceAiguillage].pinDevieLed,LOW);      
      //fadeOut(Aiguillage[indiceAiguillage].pinDevieLed);
      //fadeIn(Aiguillage[indiceAiguillage].pinDirectLed);
      break;
  
    case DEVIE:       
      digitalWrite(Aiguillage[indiceAiguillage].pinDevie, HIGH);
      delay(dureeImpulsion);
      digitalWrite(Aiguillage[indiceAiguillage].pinDevie, LOW);
      digitalWrite(Aiguillage[indiceAiguillage].pinDirectLed,LOW);
      digitalWrite(Aiguillage[indiceAiguillage].pinDevieLed,HIGH); 
      //fadeOut(Aiguillage[indiceAiguillage].pinDevieLed);
      //fadeIn(Aiguillage[indiceAiguillage].pinDirectLed);    
      break;
  } // Fin de switch(Aiguillage[indiceAiguillage].dernierEtat)

  // Sauvegarder le nouvel état dans l'EEPROM
  EEPROM.update(indiceAiguillage, static_cast<byte>(Aiguillage[indiceAiguillage].DernierePosition));
} // Fin de procédure mettreAJourAiguillage()

void fadeIn(int pin) {
// Procédure pour l'allumage progressif d'une LED
  for (int i = 100; i <= 255; i++) {
    analogWrite(pin, i);
    delay(5);
  } // Fin de for (int i = 100; i <= 255; i++)
} // Fin de procédure fadeIn(int pin)

void fadeOut(int pin) {
// Procédure pour l'extinction progressive d'une LED
  for (int i = 255; i >= 100; i--) {
    analogWrite(pin, i);
    delay(5);
  } // Fin de for (int i = 255; i >= 100; i--)
} // Fin de procédure fadeOut(int pin)