/*
      *************************************************
      *        Feux de passage à niveau belge         *
      *             version 20240514                  *
      *               Arduino Nano                    *
      *               simulation sur                  * 
      * https://wokwi.com/projects/397832582894494721 *                                             *
      *  https://www.youtube.com/watch?v=-7yB8j9FtAk  *
      *************************************************

        
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    !            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  !
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    */

    /*
      la luminosité peut se régler de 0 à 255 ... mais on pourra prendre des valeurs plus faibles pour plus de visibliyé
      les paramètres dont les commentaires commencent par * peuvent être modifiés.
      
    

      Testé le 09/05/2023 => OK
      le 09/05/2023 => test pour utiliser un moteur à états pour gérer les leds blanches.
      le 10/05/2023 => OK
      le 26/05/2023 => Elimination des "delay()"" dans les procédures de rebonds.
      le 27/05/2023 => Elimination des boucles "for" dans les procédures de rebonds.
      le 01/06/2023 => Elimination des boucles "while" dans les procédures de rebonds
      le 11/06/2023 => Utilisation de debounce pour la détection. => bug à l'initialisation
      barrières ouvertes = allumage d'une led rouge au démarrage.
      le 13/06/2023 => tout semble OK
      le 02/07/2023 => ajout possibilité d'inverser les angles ouvert / fermé
      le 14/05/2024 => modification des procédures d'extinction en utilisant un drapeau
    */

    /* LES CONNECTEURS 
        pour Nano 
    D13    =|    |=  D12    
   +3.3V   =|    |= ~D11  /!\ 
    AREF   =|    |= ~D10  /!\ La bibliothèque Servo désactive le PWM sur D10&D11
    A0     =|    |= ~D9  
    A1     =|    |=  D8     
    A2     =|    |=  D7    
    A3     =|    |= ~D6 
    A4-SDA =|    |= ~D5 
    A5-SCL =|    |=  D4     
    A6     =|    |= ~D3 - INT1
    A7     =|    |=  D2 - INT0
    5V     =|    |=  GND 
    RESET  =|    |=  RESET  
    GND    =|    |=  D0-RX 
    VIN    =|    |=  D1-TX
    */
    
    #include <Bounce2.h>
    const int dureeAntiRebond = 10;

    /* LES CONNECTEURS */
    const int pinDetection = 2;                                             // BP / Relais détection connectés à D2
    const int pinLedsBlanches = 3;                                          // Les leds blanches sont connectées sur une sortie pwm    
    const int pinLedRouge1 = 5;
    const int pinLedRouge2 = 6;
    const int pinBPMilieu = 7;
    const int pinServo1 = 8;                                                // Les servos sont connectés sur D8 et D9
    const int pinServo2 = 9;
    const int pinBPEqualizer = 10; 
    const int pinBPVolume = 11;
    const int pinRelaisSon = 12;                                            // Déclanche le relais qui va déclancher le lecteur MP3
    const int pinLedPM = A7;                                                // 16 sur ATTiny88
    /* =============== */

    /* POUR LA DETECTION */
    Bounce2::Button BPDetection = Bounce2::Button();                        // syntaxe pour tests
    uint32_t departChronoDetection = 0ul;                                   // initialise la tempo de démarrage de détection                                            // interval de temps pour le déclanchement de la sonnerie
    bool blocageDetection = false;
    /* ================= */

    /* POUR LES SERVOMOTEURS */
    #include <Servo.h>
    Servo servoPassageNiveau1;
    Servo servoPassageNiveau2;
    const int angleFerme = 550;                                             // * à déterminer. PaN fermé
    const int angleOuvert = 1500;                                           // * à déterminer. PaN ouvert 
    const byte ralentissementServos = 3;                                    // * Règle la vitesse de rotation du servo en introduisant une pause entre chaque rotation.
    int angleIntermediaire;                                                 // valeur de l'angle intermédiaire pendant le mouvement 
    const int angleRebondsDown = 140;                                       // * angles de dépacement maxi de rebonds. Doit être un multiple de 22
    const int angleRebondsUp = 140; 
    const int pasRebonds = 10;
    int amplitudeRebonds; 
    int angleRebonds;
    uint32_t actuelTempsRebonds;
    uint32_t precedentTempsRebonds;
    const uint32_t delaisFermetureBarrieres = 7000ul;                       // * interval de temps pour la fermeture des barrière (14" / 2)
    uint32_t precedentMillisBarrieres = 0ul; 
    uint32_t precedentMillisServos = 0ul; 
    Bounce BPMilieu = Bounce();
    bool etatMilieu;

    enum barrieres {
      INIT_FERMETURE,
      FERMETURE,
      FERME,
      INIT_OUVERTURE,
      OUVERTURE,
      OUVERT
    };
    barrieres etatBarrieres;

    enum rebonds {
      UP,
      DOWN
    };
    rebonds sensRebonds;
    /* ======================= */

  /* POUR LA SONNERIE */
  #include <EEPROM.h>
  #include <DFPlayerMini_Fast.h>
  DFPlayerMini_Fast Sonnerie;
  Bounce BPVolume = Bounce(); 
  Bounce BPEqualizer = Bounce();
  const uint32_t delaisRelaisSon = 1500ul;                                 // * interval de temps pour le déclanchement de la sonnerie
  bool etatSonnerie = false;
  int volumeSonnerie = 20;                                                 // de 0 à 30. BP de réglage au pas de 5
  int equalizerSonnerie = 0;                                               // de 0 à 5
  /* ============ */

    /* POUR LES LEDS BLANCHES */
    int incrementLuminositeBlanches = 2;                                    // * Pas d'incrémentation de la luminosité. Plus la valeur est grande, moins la variation de luminosité sera progressive
    const uint32_t intervalBlanches = 15;                                   // * Délai entre 2 incrémentations
    const int luminositeMiniBlanches = 0;                                   // *
    const int luminositeMaxiBlanches = 250;                                 // *
    int luminositeLedsBlanches = luminositeMiniBlanches;          
    const uint32_t delaiBlanches_Rouges = 1000;                             // * temps entre l'extinction des leds blanches et l'allumage des leds rouges         
    uint32_t previousMillisBlanches = 0ul;                                  // Temps précédent état led blanche en millisecondes   

    enum etatBlanches {
      Blanches_INIT,
      Blanches_UP,
      Blanches_DOWN, 
      Blanches_OFF
    };
    etatBlanches etatLedsBlanches = Blanches_INIT;
    /* ==================== */

    /* POUR LES LEDS ROUGES */
    const int incrementLuminositeRouges = 6;                                 // * Pas d'incrémentation de la luminosité. Plus la valeur est grande, moins la variation de luminosité sera progressive
    const uint32_t intervalRouges = 4;                                       // * Délai entre 2 incrémentations
    const int luminositeMiniRouges = 0;                                      // *
    const int luminositeMaxiRouges = 250;                                    // *
    int luminositeLedRouge1 = luminositeMiniRouges;    
    int luminositeLedRouge2 = luminositeMiniRouges;  
    const uint32_t delaiRouges_Blanches = 1500;                              // * temps entre l'extinction des rouges et l'allumage des blanches                
    uint32_t previousMillisRouges = 0ul;                                     // Temps précédent état led rouge en millisecondes   
    
    enum etatRouges {
      Rouges_INIT,
      Rouge1_UP,
      Rouge1_DOWN, 
      Rouge2_UP, 
      Rouge2_DOWN, 
      Rouges_OFF
    }; 
    etatRouges etatLedsRouges = Rouges_INIT;
    int precedentEtatLedsRouges; 
    /* ==================== */
  
    /* LES DRAPEAUX */
    bool flagDetection;
    byte X = 0;
    bool flagExtinctionBlanches = false;
    bool flagExtinctionRouges = false;
    /* ============ */

    void setup() {
      Serial.begin(9600);
      pinMode(pinLedsBlanches, OUTPUT);
      pinMode(pinLedRouge1, OUTPUT);
      pinMode(pinLedRouge2, OUTPUT);
      pinMode(pinServo1, OUTPUT);
      pinMode(pinServo2, OUTPUT);
      pinMode(pinLedPM, OUTPUT);
      pinMode(LED_BUILTIN, OUTPUT);

      BPDetection.attach(pinDetection, INPUT);
      BPDetection.interval(dureeAntiRebond);
      BPMilieu.attach(pinBPMilieu, INPUT);
      BPMilieu.interval(dureeAntiRebond);
      BPVolume.attach(pinBPVolume, INPUT);
      BPVolume.interval(dureeAntiRebond);
      BPEqualizer.attach(pinBPEqualizer, INPUT);
      BPEqualizer.interval(dureeAntiRebond);
      
      delay(10);
      if(digitalRead(pinDetection) == HIGH){
      // Voies occupées on ferme les barrières
        angleIntermediaire = angleFerme;
        etatBarrieres = FERME;
      } else {
        // Voies libres on ouvre les barrières
        angleIntermediaire = angleOuvert;
        etatBarrieres = OUVERT;
      } // Fin de if(etatDetection)

      if (!servoPassageNiveau1.attached()) {servoPassageNiveau1.attach(pinServo1); }
      if (!servoPassageNiveau2.attached()) {servoPassageNiveau2.attach(pinServo2); }
      delay(50);
      servoPassageNiveau1.writeMicroseconds(angleIntermediaire);
      servoPassageNiveau2.writeMicroseconds(angleIntermediaire);
      delay(400);   
      if (servoPassageNiveau1.attached()) {servoPassageNiveau1.detach(); }
      if (servoPassageNiveau2.attached()) {servoPassageNiveau2.detach(); }
      delay(100);

      BPDetection.update();
      initDFPlayer();                                                        // initialisation de la carte DFPlayer
      lectureEEprom ();                                                      // lecture de la valeur du volume enregistrée en EEprom 
    } // Fin de setup

    void loop() {
      BPDetection.update();
      BPMilieu.update();
      BPVolume.update();
      BPEqualizer.update();
      if (BPDetection.changed()){
        if (blocageDetection == false){
          litDetection();
        } // Fin de if (blocageDetection == false)
      }

      if (BPVolume.changed()) {
        reglageVolume();
      } // Fin de if (BPVolume.changed())

      if (BPEqualizer.changed()) {
        reglageEqualizer();
      } // Fin de if (BPEqualizer.changed())

      if (BPMilieu.changed() && BPMilieu.read() == HIGH){
        etatMilieu =! etatMilieu;
        pointMilieu();
      } // Fin de if (BPMilieu.changed && BPMilieu.read == HIGH)

      actionsBarrieres();
      afficheLedsBlanches();
      afficheLedsRouges();
    } // Fin de loop

    void litDetection() {      
        if (BPDetection.read() == HIGH) {
          etatBarrieres = INIT_FERMETURE;
        } else {
          etatBarrieres = INIT_OUVERTURE;
        } // Fin de if (BPDetection.read() == HIGH)
    } // Fin de procédure litDetection()

    void actionsBarrieres () {
        switch (etatBarrieres) {
          case INIT_FERMETURE :
            //Serial.println(F("Changent vers fermeture"));   
            /* On bloque la lecture de la détection le temps du mouvement des servos. */
            if (blocageDetection == false) {blocageDetection = true;}                             
          
            /* On démarre le chrono pour déclancher la sonnerie et la fermeture des barrières. */
            departChronoDetection = millis(); 
            if (etatLedsBlanches != Blanches_INIT){
              flagExtinctionBlanches = true;
            } // Fin de if (etatLedsBlanches != Blanches_INIT)

            /* On met à jour l'état de l'action sur les barrières. */
            etatBarrieres = FERMETURE;
          break;

          case FERMETURE :   
            if ((millis() - departChronoDetection) >= delaisRelaisSon) {
              /* On déclanche la sonnerie. */
              if (etatSonnerie == false){
                etatSonnerie = true;
                Sonnerie.loop(1);
                digitalWrite(pinRelaisSon, HIGH);            
              } // Fin de if (etatSonnerie == false)
            } // Fin de if ((millis() - departChronoDetection) >= delaisRelaisSon)

            if ((millis() - departChronoDetection) >= delaisFermetureBarrieres) {
              /* On abaisse les barrières. */
              if (angleFerme > angleOuvert){
                fermetureBarrieres_Inverse();
              } else {
                fermetureBarrieres();
              } // Fin de if (angleFerme > angleOuvert){
            } // Fin de if ((millis() - departChronoDetection) >= delaisFermetureBarrieres)
            break;

          case FERME :
            //Serial.println(F("Restent fermees"));
            X = 0;
            /* On arrête la sonnerie. */
            if (etatSonnerie == true){
                etatSonnerie = false;
                Sonnerie.pause();
                digitalWrite(pinRelaisSon, LOW);
            } // Fin de if (etatSonnerie == true)

            if (etatLedsRouges == Rouges_INIT){
              etatLedsRouges = Rouge1_UP;
            }

            /* On débloque la lecture de l'état de la détection. */
            if (blocageDetection == true) {blocageDetection = false;}
            break;

          case INIT_OUVERTURE :
            //Serial.println(F("Changent vers ouverture"));

            /* On bloque la lecture de la détection le temps du mouvement des servos. */
            if (blocageDetection == false) {blocageDetection = true;} 

            /* On met à jour l'état de l'action sur les barrières. */
            etatBarrieres = OUVERTURE;
            break;

          case OUVERTURE :
            /* On ouvre les barrières */ 
            if (angleFerme > angleOuvert){
              ouvertureBarrieres_Inverse();
            } else {
              ouvertureBarrieres();
            } // Fin de if (angleFerme > angleOuvert){
            break;

          case OUVERT :
            //Serial.println(F("Restent ouvertes"));      
            /* On éteint les leds rouges */
            if (etatLedsRouges != Rouges_INIT){
              if (X == 0){
                X = 1;
                precedentEtatLedsRouges = etatLedsRouges;
                //Serial.println(precedentEtatLedsRouges);
              }
              flagExtinctionRouges = true;
            } else {
              if (etatLedsBlanches == Blanches_INIT){etatLedsBlanches = Blanches_UP;}
            }

            /* On débloque la lecture de l'état de la détection. */
            if (blocageDetection == true) {blocageDetection = false;}
            break;

        } // Fin de switch (etatBarriere)
    } // Fin de procédure actionsBarrieres()

    void afficheLedsBlanches(){
      uint32_t currentMillisBlanches = millis();
      if (currentMillisBlanches - previousMillisBlanches >= intervalBlanches) {
        previousMillisBlanches = currentMillisBlanches;

        switch (etatLedsBlanches) {
          case Blanches_UP:
            luminositeLedsBlanches += incrementLuminositeBlanches;
            if (luminositeLedsBlanches >= luminositeMaxiBlanches) {
              etatLedsBlanches = Blanches_DOWN;
            }
            break;
          
          case Blanches_DOWN:
            luminositeLedsBlanches -= incrementLuminositeBlanches;
            if (luminositeLedsBlanches <= luminositeMiniBlanches) {
              if (flagExtinctionBlanches) {
                flagExtinctionBlanches = false;
                etatLedsBlanches = Blanches_INIT;    
                delay(delaiBlanches_Rouges);                                                            // blocage volontaire
                etatLedsRouges = Rouge1_UP;    
              } else {
                etatLedsBlanches = Blanches_UP;
              } // Fin de flagExtinctionBlanches
            } // Fin de if (luminositeLedsBlanches <= luminositeMiniBlanches) 
            break;
        } // Fin de switch (etatLedsBlanches) 
        analogWrite(pinLedsBlanches, luminositeLedsBlanches);
      }  // Fin de if (currentMillisBlanches - previousMillisBlanches >= intervalBlanches)
    } // Fin de procédure afficheLedsBlanches()

    void afficheLedsRouges(){
      uint32_t currentMillisRouges = millis();
      if (currentMillisRouges - previousMillisRouges >= intervalRouges) {
        previousMillisRouges = currentMillisRouges;

        switch (etatLedsRouges) {
          case Rouge1_UP:
            luminositeLedRouge1 += incrementLuminositeRouges;
            if (luminositeLedRouge1 >= luminositeMaxiRouges) {
              etatLedsRouges = Rouge1_DOWN;
            } // Fin de if (luminositeLedRouge1 >= luminositeMaxiRouges) 
            break;
          
          case Rouge1_DOWN:
            luminositeLedRouge1 -= incrementLuminositeRouges;
            if (luminositeLedRouge1 <= luminositeMiniRouges) {
              if (flagExtinctionRouges) {
                flagExtinctionRouges = false;
                etatLedsRouges = Rouges_INIT;
                delay(delaiRouges_Blanches);                                                            // Blocage volontaire
                etatLedsBlanches = Blanches_UP;  
              } else {
                etatLedsRouges = Rouge2_UP;
              } // Fin de if (flagExtinctionRouges)
            } // Fin de if (luminositeLedRouge1 <= luminositeMiniRouges)
            break;
          
          case Rouge2_UP:
            luminositeLedRouge2 += incrementLuminositeRouges;
            if (luminositeLedRouge2 >= luminositeMaxiRouges) {
              etatLedsRouges = Rouge2_DOWN;
            } // Fin de if (luminositeLedRouge2 >= luminositeMaxiRouges)
            break;
          
          case Rouge2_DOWN:
            luminositeLedRouge2 -= incrementLuminositeRouges;
            if (luminositeLedRouge2 <= luminositeMiniRouges) {
              if (flagExtinctionRouges) {
                flagExtinctionRouges = false;
                etatLedsRouges = Rouges_INIT;
                delay(delaiRouges_Blanches);                                                            // Blocage volontaire
                etatLedsBlanches = Blanches_UP;  
              } else {
                etatLedsRouges = Rouge1_UP;
              } // Fin de if (flagExtinctionRouges)
            } // Fin de if (luminositeLedRouge2 <= luminositeMiniRouges)
          break;
        } // Fin de switch (etatLedsRouges) 
        analogWrite(pinLedRouge1, luminositeLedRouge1);
        analogWrite(pinLedRouge2, luminositeLedRouge2);
      }  // Fin de if (currentMillisRouges - previousMillisRouges >= tempoRouges)
    } // Fin de procédure afficheLedRouge()

  void ouvertureBarrieres(){
    //Serial.println(F("Barrieres en ouverture"));
      if (!servoPassageNiveau1.attached()) {servoPassageNiveau1.attach(pinServo1); }
      if (!servoPassageNiveau2.attached()) {servoPassageNiveau2.attach(pinServo2); }
          
      if (angleIntermediaire < angleOuvert) {
        // Si l'angle intermédiaire n'est pas arrivé à la valeur angle ouvert, on continue
        //en appiquant un ralentissement pour diminuer la vitesse d'ouverture
        uint32_t currentMillis = millis();
        if (currentMillis - precedentMillisBarrieres >= ralentissementServos) {
          precedentMillisBarrieres = currentMillis;
          angleIntermediaire += 1;
          servoPassageNiveau1.writeMicroseconds(angleIntermediaire);
          servoPassageNiveau2.writeMicroseconds(angleIntermediaire);
          //if (angleIntermediaire == angleOuvert){rebondsUp();}
        } // Fin de if (currentMillis - previousMillis >= Ralentissement)
        amplitudeRebonds = angleRebondsUp;  
        angleRebonds = 0;
        sensRebonds = DOWN;
      } else {
        // Si l'angle intermédiaire est arrivé à la valeur angle ouvert,
        /* Effet de rebonds à l'ouverture' */
        if (amplitudeRebonds > 0){   
          rebondsUp();
        } else {
          // on débranche le servo, on met à jour etatBarriere
          uint32_t currentMillis = millis(); // Obtenir le temps actuel
          if (currentMillis - precedentMillisServos >= 150) {
            if (servoPassageNiveau1.attached()) {servoPassageNiveau1.detach(); }
            if (servoPassageNiveau2.attached()) {servoPassageNiveau2.detach(); }
          } // Fin de if (currentMillis - previousMillis >= 150) 
          angleIntermediaire = angleOuvert;
          etatBarrieres = OUVERT;
        } // Fin de if (amplitudeRebonds > 0)     
      } // Fin de if (angleIntermediaire < angleOuvert)
    } // Fin de procédure ouvertureBarrieres()

    void fermetureBarrieres(){
      if (!servoPassageNiveau1.attached()) {servoPassageNiveau1.attach(pinServo1);}
      if (!servoPassageNiveau2.attached()) {servoPassageNiveau2.attach(pinServo2);}

      if (angleIntermediaire > angleFerme) {
        // Si l'angle intermédiaire n'est pas arrivé à la valeur angle fermé, on continue
        //en appiquant un ralentissement pour diminuer la vitesse de fermeture
        uint32_t currentMillis = millis(); 
          if (currentMillis - precedentMillisBarrieres >= ralentissementServos) {
            precedentMillisBarrieres = currentMillis; 
            angleIntermediaire -= 1;
            servoPassageNiveau1.writeMicroseconds(angleIntermediaire);
            servoPassageNiveau2.writeMicroseconds(angleIntermediaire);
          }
          amplitudeRebonds = angleRebondsDown; 
          angleRebonds = 0;
          sensRebonds = UP;
      } else {
        // Si l'angle intermédiaire est arrivé à la valeur angle fermé,
        /* Effet de rebonds à la fermeture */
        if (amplitudeRebonds > 0){
          rebondsDown();      
        } else {
          // on débranche le servo, on met à jour etatBarriere et on arrête le son
          uint32_t currentMillis = millis(); 
          if (currentMillis - precedentMillisServos >= 150) {
            if (servoPassageNiveau1.attached()) {servoPassageNiveau1.detach();} 
            if (servoPassageNiveau2.attached()) {servoPassageNiveau2.detach();} 
          } // Fin de if (currentMillis - previousMillisServos >= 150)
          angleIntermediaire = angleFerme;
          etatBarrieres = FERME;
          //Serial.println(F("Barrieres fermees"));
        } // Fin de if (amplitudeRebonds > 0)
      } // Fin de if (angleIntermediaire > angleFerme)
    } // Fin de procédure fermetureBarrieres()

    void ouvertureBarrieres_Inverse(){
    if (!servoPassageNiveau1.attached()) {servoPassageNiveau1.attach(pinServo1);}
    if (!servoPassageNiveau2.attached()) {servoPassageNiveau2.attach(pinServo2);}

    if (angleIntermediaire > angleOuvert) {
      // Si l'angle intermédiaire n'est pas arrivé à la valeur angle fermé, on continue
      //en appiquant un ralentissement pour diminuer la vitesse de fermeture
      unsigned long actuelMillis = millis(); 
        if (actuelMillis - precedentMillisBarrieres >= ralentissementServos) {
          precedentMillisBarrieres = actuelMillis; 
          angleIntermediaire -= 1;
          servoPassageNiveau1.write(angleIntermediaire);
          servoPassageNiveau2.write(angleIntermediaire);
          //SoftwareServo::refresh();
        }
        amplitudeRebonds = angleRebondsDown; 
        angleRebonds = 0;
        sensRebonds = DOWN;
    } else {
      // Si l'angle intermédiaire est arrivé à la valeur angle fermé,
      /* Effet de rebonds à la fermeture */
      if (amplitudeRebonds > 0){
        rebondsUp();      
      } else {
        // on débranche le servo, on met à jour etatBarriere et on arrête le son
        unsigned long actuelMillis = millis(); 
        if (actuelMillis - precedentMillisServos >= 150) {
          if (servoPassageNiveau1.attached()) {servoPassageNiveau1.detach();} 
          if (servoPassageNiveau2.attached()) {servoPassageNiveau2.detach();} 
        } // Fin de if (actuelMillis - previousMillisServos >= 150)
        angleIntermediaire = angleOuvert;
        etatBarrieres = OUVERT;
        //Serial.println(F("Barrieres fermees"));
      } // Fin de if (amplitudeRebonds > 0)
    } // Fin de if (angleIntermediaire > angleFerme)
  } // Fin de procédure fermetureBarrieres()

   void fermetureBarrieres_Inverse(){
  //Serial.println(F("Barrieres en ouverture"));
    if (!servoPassageNiveau1.attached()) {servoPassageNiveau1.attach(pinServo1); }
    if (!servoPassageNiveau2.attached()) {servoPassageNiveau2.attach(pinServo2); }
        
    if (angleIntermediaire < angleFerme) {
      // Si l'angle intermédiaire n'est pas arrivé à la valeur angle ouvert, on continue
      //en appiquant un ralentissement pour diminuer la vitesse d'ouverture
      unsigned long actuelMillis = millis();
      if (actuelMillis - precedentMillisBarrieres >= ralentissementServos) {
        precedentMillisBarrieres = actuelMillis;
        angleIntermediaire += 1;
        servoPassageNiveau1.write(angleIntermediaire);
        servoPassageNiveau2.write(angleIntermediaire);
        //SoftwareServo::refresh();
      } // Fin de if (actuelMillis - previousMillis >= Ralentissement)
      amplitudeRebonds = angleRebondsUp;  
      angleRebonds = 0;
      sensRebonds = UP;
    } else {
      // Si l'angle intermédiaire est arrivé à la valeur angle ouvert,
      /* Effet de rebonds à l'ouverture' */
      if (amplitudeRebonds > 0){   
        rebondsDown();
      } else {
        // on débranche le servo, on met à jour etatBarriere
        unsigned long actuelMillis = millis(); // Obtenir le temps actuel
        if (actuelMillis - precedentMillisServos >= 150) {
          if (servoPassageNiveau1.attached()) {servoPassageNiveau1.detach(); }
          if (servoPassageNiveau2.attached()) {servoPassageNiveau2.detach(); }
        } // Fin de if (actuelMillis - previousMillis >= 150) 
        angleIntermediaire = angleFerme;
        etatBarrieres = FERME;
      } // Fin de if (amplitudeRebonds > 0)     
    } // Fin de if (angleIntermediaire < angleOuvert)
  } // Fin de procédure ouvertureBarrieres()

  void rebondsUp(){  
    switch (sensRebonds) {
      case DOWN :
        /* Le rebond redescend */
        if (angleRebonds < amplitudeRebonds) {    
          actuelTempsRebonds = millis();
          if (actuelTempsRebonds - precedentTempsRebonds >= 10) {
            angleRebonds += pasRebonds;
            servoPassageNiveau1.writeMicroseconds(angleOuvert - angleRebonds);
            servoPassageNiveau2.writeMicroseconds(angleOuvert - angleRebonds);
            precedentTempsRebonds = actuelTempsRebonds;
          } // Fin de if (actuelTempsRebonds - precedentTempsRebonds >= 10)
        } else {
          angleRebonds = amplitudeRebonds;
          sensRebonds = UP;
        } // Fin de if (angleRebonds < amplitudeRebonds)
        break;

      case UP :
        if (angleRebonds > 0) {
          actuelTempsRebonds = millis();
          if (actuelTempsRebonds - precedentTempsRebonds >= 10) {
            angleRebonds -= pasRebonds;
            servoPassageNiveau1.writeMicroseconds(angleOuvert - angleRebonds);
            servoPassageNiveau2.writeMicroseconds(angleOuvert - angleRebonds);
            precedentTempsRebonds = actuelTempsRebonds;
          } // Fin de if (actuelTempsRebonds - precedentTempsRebonds >= 10)
        } else {
          amplitudeRebonds -= 20;
          angleRebonds = 0;
          sensRebonds = DOWN; 
        } // Fin de  (angleRebonds > 0)
        break;
      } // Fin de switch (sensRebond)
    } // Fin de procédure rebondsDown 

  void rebondsDown(){  
    /* angleRebonds s'incrémente de 0 à  la valeur de amplitudeRebonds par pas de 10
    quand la valeur angleRebondsDown est atteinte angleRebond se décrémente par pas de 10 
    jusque la valeur 0.
    Quand ce cycle est termnié on recommence en décrémentant la valeur amplitude rebonds
    de 20 et ainsi de suite jusqu'à ce que amplitudeRebonds soit égal à 
    */ 
    switch (sensRebonds) {
      case UP:
      /* Le rebond remonte */
        if (angleRebonds < amplitudeRebonds) {    
          actuelTempsRebonds = millis();
          if (actuelTempsRebonds - precedentTempsRebonds >= 10) {
            angleRebonds += pasRebonds;
            servoPassageNiveau1.writeMicroseconds(angleFerme + angleRebonds);
            servoPassageNiveau2.writeMicroseconds(angleFerme + angleRebonds);
            precedentTempsRebonds = actuelTempsRebonds;
          } // Fin de if (actuelTempsRebonds - precedentTempsRebonds >= 10)
        } else {
          angleRebonds = amplitudeRebonds;
          sensRebonds = DOWN;
        } // Fin de if (angleRebonds < amplitudeRebonds)
        break;

      case DOWN :
      /* Le rebond redescend */
        if (angleRebonds > 0) {
          actuelTempsRebonds = millis();
          if (actuelTempsRebonds - precedentTempsRebonds >= 10) {
            angleRebonds -= pasRebonds;
            servoPassageNiveau1.writeMicroseconds(angleFerme + angleRebonds);
            servoPassageNiveau2.writeMicroseconds(angleFerme + angleRebonds); 
            precedentTempsRebonds = actuelTempsRebonds;
          } // Fin de if (actuelTempsRebonds - precedentTempsRebonds >= 10)
        } else {
          amplitudeRebonds -= 20;
          angleRebonds = 0;
          sensRebonds = UP;
        } // Fin de if (angleRebonds > 0)
        break;
    } // Fin de switch (sensRebond)
  } // Fin de procédure rebondsDown 

  void initDFPlayer(){
    Serial.end();      
    Sonnerie.begin(Serial);
    Serial.begin(9600);
    Sonnerie.volume(volumeSonnerie);                                  // de 0 à 30
    Sonnerie.EQSelect(equalizerSonnerie);
    
    /*----Set different EQ----
    myDFPlayer.EQ(DFPLAYER_EQ_NORMAL);
    myDFPlayer.EQ(DFPLAYER_EQ_POP);
    myDFPlayer.EQ(DFPLAYER_EQ_ROCK);
    myDFPlayer.EQ(DFPLAYER_EQ_JAZZ);
    myDFPlayer.EQ(DFPLAYER_EQ_CLASSIC);
    myDFPlayer.EQ(DFPLAYER_EQ_BASS);
    */
  } // Fin de procédure initDFPlayer

  void lectureEEprom(){
    volumeSonnerie = EEPROM.read(200);                            
    if ((volumeSonnerie < 5) || (volumeSonnerie > 30)) {
      volumeSonnerie = 20;
      EEPROM.update(200, volumeSonnerie);
    } else {
      for (byte J = 0; J < (volumeSonnerie / 5); J += 1){
        digitalWrite(13, HIGH);
        delay(100);
        digitalWrite(13, LOW);
        delay(100);
      } // Fin de for (byte J = 0; J < (volumeSonnerie / 5); J += 1)
    } // Fin de if ((volumeSonnerie < 5) || (volumeSonnerie > 30))
  
    equalizerSonnerie = EEPROM.read(220);
    if ((equalizerSonnerie > 5) || (equalizerSonnerie < 0)) {
      equalizerSonnerie = 0;
      EEPROM.update(220, equalizerSonnerie);
    } // Fin de if (equalierSonnerie > 5)
  } // Fin de procédure lectureEEprom()

  void reglageVolume(){  
    if (BPVolume.read() == HIGH) {
      volumeSonnerie += 5; if(volumeSonnerie > 30) volumeSonnerie = 5;
    } else {
      EEPROM.update(200, volumeSonnerie); 
      //Serial.print(F("Volume :")); Serial.println(volumeSonnerie);
      for (byte J = 0; J < (volumeSonnerie / 5); J += 1){
        digitalWrite(13, HIGH);
        delay(100);
        digitalWrite(13, LOW);
        delay(100);
      } // Fin de for (byte J = 0; J < (volumeSonnerie / 5); J += 1)
    } // Fin de if (BPVolume.read() == HIGH)
  } // Fin de procédure reglageVolume()

  void reglageEqualizer(){
    if (BPEqualizer.read() == HIGH) {
      equalizerSonnerie += 1; if(equalizerSonnerie > 5) equalizerSonnerie = 0;
    } else {
      EEPROM.update(220, volumeSonnerie);  
      //Serial.print(F("Eqalizer :")); Serial.println(equalizerSonnerie);
      for (byte J = 0; J < equalizerSonnerie; J += 1){
        digitalWrite(13, HIGH);
        delay(100);
        digitalWrite(13, LOW);
        delay(100);
      } // Fin de for (byte J = 0; J < equalizerSonnerie; J += 1)
    } // Fin de if (BPEqualizer.read() == HIGH)
  } // Fin de procédure reglageEqualizer()

  void pointMilieu(){
    if (!servoPassageNiveau1.attached()) {servoPassageNiveau1.attach(pinServo1); }
    if (!servoPassageNiveau2.attached()) {servoPassageNiveau2.attach(pinServo2); }
    delay(150);    
    if (etatMilieu == true){   
      // Si le drapeau etatMilieu est vrai on positionne à angle moyen.
      digitalWrite(pinLedPM, HIGH); digitalWrite(LED_BUILTIN, HIGH);    
      servoPassageNiveau1.writeMicroseconds((angleFerme + angleOuvert) / 2);
      servoPassageNiveau2.writeMicroseconds((angleFerme + angleOuvert) / 2);
      delay(150);   
      if (servoPassageNiveau1.attached()) {servoPassageNiveau1.detach(); }
      if (servoPassageNiveau2.attached()) {servoPassageNiveau2.detach(); }
      delay(150);    
    } else {
      // Si le drapeau etatMilieu est faux on repositionne à la position initiale.  
      digitalWrite(pinLedPM, LOW);digitalWrite(LED_BUILTIN, LOW);
      if (etatBarrieres == OUVERT){
        // Les voies étaient libres. On repositionne les barrières à ouvertes.
        servoPassageNiveau1.writeMicroseconds(angleOuvert);
        servoPassageNiveau2.writeMicroseconds(angleOuvert);
        delay(150); 
      } else if (etatBarrieres == FERME) {
        // Les voies étaient occupées. On repositionne les barrières à fermées.
        servoPassageNiveau1.writeMicroseconds(angleFerme);
        servoPassageNiveau2.writeMicroseconds(angleFerme);
        delay(150); 
      } // Fin de if (etatBarrieres == OUVERT)
      if (servoPassageNiveau1.attached()) {servoPassageNiveau1.detach(); }
      if (servoPassageNiveau2.attached()) {servoPassageNiveau2.detach(); }
      delay(150); 
    } // Fin de if (etatMilieu == true)
  } // Fin de procédure pointMilieu()