/*
    ***********************************************
    *     Feux de passage à niveau français       *
    *           version 20230701 mini             *
    *   pour transfert sur ATtiny 88 MH&Live      *
    *             Arduino Nano                    *
    *        https://youtu.be/-hZ-K13oVk4         *
    ***********************************************

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

  /*
  Déroulement :
  Détection de présence ON  => Feux rouges + sonnerie
  8" après                  => fermeture barrière
  barrières fermées         => arrêt sonnerie
  Détection de présence OFF => arrêt feux rouges + ouverture barrières
  
  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.

  le 01/07/2023 => tests pour configuration mini => changer les pins des leds rouges => OK
  le 02/07/2023 => ajout de la possibilité d'inverser les valeurs des angles ffermé / ouvert
  */
  
  /* 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
  */
  const int pinDetection = 2;                                              // BP - Relais détection connectés à D2
  // pin 3 réservé pour les leds blanches du code Belgique                         
  const int pinLedsRouge1 = 5;
  const int pinLedsRouge2 = 6;
  const int pinBPMilieu = 7;
  const int pinServo1 = 8;                                                 // Les servos sont connectés sur D8 et D9
  const int pinServo2 = 9;
  
  const int pinRelaisSon = 12;                                             // Déclanche le relais qui va déclancher le lecteur MP3    
  const int pinLedPM = A7;                                                 // 16 sur ATTiny88
  /* =============== */

  /* 
  pour ATtiny88 MH&Live 
   VIN    =|    |=  D2    
   GND    =|    |=  D1
   5V     =|    |=  D0
   D3     =|    |=  RESET 
   D4     =|    |=  D25     
   D5     =|    |=  D24-SCL-A5    
   D6     =|    |=  D23-SDA-A4 
   D7     =|    |=  D22-A3 
   D8     =|    |=  D21-A2     
  ~D9     =|    |=  D20-A1
  ~D10    =|    |=  D19-A0
   D11    =|    |=  D18-A7 
   D12    =|    |=  D17-A8  
   D13    =|    |=  D16 
   D14    =|    |=  D15

  /!\ La bibliothèque Servo désactive le PWM sur D10&D11

  const int pinDetection = 2;                                              // BP - Relais détection connectés à D2
  // pin 3 réservé pour les leds blanches du code Belgique                         
  const int pinLedsRouge1 = 9;
  const int pinLedsRouge2 = 10;
  const int pinServo1 = 7;                                                 // Les servos sont connectés sur D8 et D9
  const int pinServo2 = 8;
  const int pinBPMilieu = 11;
  const int pinRelaisSon = 12;                                             // Déclanche le relais qui va déclancher le lecteur MP3    
  const int pinLedPM = 16;                                                 // A6 sur Nano
  =============== */


  /* POUR LA DETECTION */
  bool etatDetection = false;
  bool etatDetectionPrecedent = false;
  unsigned long departChronoDetection = 0ul;                               // initialise la tempo de démarrage de détection
  bool blocageDetection = false;
  /* ================= */

  /* POUR LES SERVOMOTEURS */
  //#include <SoftwareServo.h>
  //SoftwareServo servoPassageNiveau1;
  //SoftwareServo servoPassageNiveau2;
  #include <Servo.h>
  Servo servoPassageNiveau1;
  Servo servoPassageNiveau2;
  const int angleFerme = 105;                                              // * à déterminer. PaN fermé
  const int angleOuvert = 75;                                              // * à déterminer. PaN ouvert 
  const byte ralentissementServos = 50;                                    // * 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 = 8; //16;                                    // * angles de dépacement maxi de rebonds. Doit être un multiple de 2
  const int angleRebondsUp = 8; //16;   
  unsigned long actuelTempsRebonds;
  unsigned long precedentTempsRebonds;
  int amplitudeRebonds; 
  int angleRebonds;
  int pasRebonds = 1; //2;
  const unsigned long delaisFermetureBarrieres = 3000ul;                   // * interval de temps pour la fermeture des barrière (7" / 2)
  unsigned long precedentMillisBarrieres = 0ul; 
  unsigned long precedentMillisServos = 0ul; 
  bool etatPointMilieu;
  bool etatPinPM = false;
  bool etatPrecedentPinPM = false;
  
  
  enum barrieres {
    INIT_FERMETURE,
    FERMETURE,
    FERME,
    INIT_OUVERTURE,
    OUVERTURE,
    OUVERT
  };
  barrieres etatBarrieres;
  
  enum rebonds {
    UP,
    DOWN
  };
  rebonds sensRebonds;
  /* ======================= */

  /* POUR LA SONNERIE */
  const unsigned long delaisRelaisSon = 0ul;                                    // * interval de temps pour le déclanchement de la sonnerie
  bool etatSonnerie = false;
  /* ============ */

  /* 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 int intervalRouges = 15;                                           // * Délai entre 2 incrémentations
  const int luminositeMiniRouges = 0;                                      // *
  const int luminositeMaxiRouges = 250;                                    // *
  int luminositeLedsRouges = luminositeMiniRouges;    
  unsigned long previousMillisRouges = 0ul;                                     // Temps précédent état led rouge en millisecondes   
  
  enum etatRouges {
    Rouges_INIT,
    Rouges_UP,
    Rouges_DOWN, 
    Rouges_OFF
  }; 
  etatRouges etatLedsRouges = Rouges_INIT;

  bool flagExtinction = false;
  /* ==================== */

  /* système de réglage des angles */

  const int pinSelectAngles = 3;
  const int pinAnglePlus = 10;
  const int pinAngleMoins = 11;

  /* ============================= */

  void setup() {
    pinMode(pinLedsRouge1, OUTPUT);
    pinMode(pinLedsRouge2, OUTPUT);
    pinMode(pinDetection, INPUT);
    pinMode(pinServo1, OUTPUT);
    pinMode(pinServo2, OUTPUT);
    pinMode(pinBPMilieu, INPUT);
    pinMode(pinRelaisSon, OUTPUT);
    pinMode(LED_BUILTIN, OUTPUT);
    pinMode(pinLedPM, OUTPUT);
    
    if (!servoPassageNiveau1.attached()) {servoPassageNiveau1.attach(pinServo1); }
    if (!servoPassageNiveau2.attached()) {servoPassageNiveau2.attach(pinServo2); }

    delay(50);
    etatDetection = digitalRead(pinDetection);
    etatDetectionPrecedent = etatDetection;
    if(etatDetection == true){
    // 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)
    servoPassageNiveau1.write(angleIntermediaire);
    servoPassageNiveau2.write(angleIntermediaire);
    delay(500);   
    //SoftwareServo::refresh();
    if (servoPassageNiveau1.attached()) {servoPassageNiveau1.detach(); }
    if (servoPassageNiveau2.attached()) {servoPassageNiveau2.detach(); }
    delay(150);
  } // Fin de setup

  void loop() {     
    etatPinPM = digitalRead(pinBPMilieu);
    if (etatPinPM != etatPrecedentPinPM) {
      etatPrecedentPinPM = etatPinPM;
      if (etatPinPM == HIGH){
        etatPointMilieu = !etatPointMilieu;
        pointMilieu();  
      } // Fin de if (etatPinPM == HIGH)
    } // Fin de if (etatPinPM != etatPrecedentPinPM)
        
    if (blocageDetection == false){
      litDetection();
    } // Fin de if ((blocageDetection == false) && (BPDetection.changed()))
    actionsBarrieres();
    afficheLedsRouges();
  } // Fin de loop
 
  void litDetection() { 
    /* si le nouvel état est différent de l'ancien c'est qu'il y a eu une modification. 
    Si le nouvel état est passé à "true" c'est qu'une présence est 
    détectée. On déclanche donc la fermeture des barrières.
    Si au contraire le nouvel état passe à "false" c'est qu'il n'y a plus  
    d'occupation de voie et on déclanche l'ouverture des barrières.
    Pendant ces deux actions, on empêche toute lecture de la détection.

    Si le nouvel état de détection est égal à l'ancien, c'est que rien n'est changé. On maintient
    l'état des barrières à OUVERT si la détection est à "false" ou à FERME si la détection est 
    à "true".
    */

    etatDetection = digitalRead(pinDetection);
    //Serial.print(etatDetectionPrecedent);Serial.print(F(" / "));Serial.println(etatDetection);
    if (etatDetection != etatDetectionPrecedent) {
      etatDetectionPrecedent = etatDetection;
      if (etatDetection == true) {
        etatBarrieres = INIT_FERMETURE;
      } else {
        etatBarrieres = INIT_OUVERTURE;
      } // Fin de if (etatDetection == true)
      etatDetectionPrecedent = etatDetection;
    } else {
      if (etatDetection == true) {
        etatBarrieres = FERME;
      } else {
        etatBarrieres = OUVERT;
      } // Fin de if (etatDetection == true)
    } // Fin de if (etatDetection != etatDetectionPrecedent)
  } // 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(); 
         
          /* On met à jour l'état de l'action sur les barrières. */
          etatBarrieres = FERMETURE;
        break;

        case FERMETURE :  
          /* On allume les leds rouges. */
          if (etatLedsRouges == Rouges_INIT){
            etatLedsRouges = Rouges_UP;
          }

          if ((millis() - departChronoDetection) >= delaisRelaisSon) {
            /* On déclanche la sonnerie. */
            if (etatSonnerie == false){
              etatSonnerie = true; 
              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"));
         /* On arrête la sonnerie. */
          if (etatSonnerie == true){
              etatSonnerie = false;
              digitalWrite(pinRelaisSon, LOW);
          } // Fin de if (etatSonnerie == true)

          if (etatLedsRouges == Rouges_INIT){
            etatLedsRouges = Rouges_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 éteint les leds rouges */
          if (etatLedsRouges != Rouges_INIT){
            flagExtinction = 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 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 afficheLedsRouges(){
    unsigned long actuelMillisRouges = millis();
    if (actuelMillisRouges - previousMillisRouges >= intervalRouges) {
      previousMillisRouges = actuelMillisRouges;

      switch (etatLedsRouges) {
        case Rouges_UP:
          luminositeLedsRouges += incrementLuminositeRouges;
          if (luminositeLedsRouges >= luminositeMaxiRouges) {
            etatLedsRouges = Rouges_DOWN;
          }
          break;
        
        case Rouges_DOWN:
          luminositeLedsRouges -= incrementLuminositeRouges;
          if (luminositeLedsRouges <= luminositeMiniRouges) {
            if (flagExtinction){
              flagExtinction = false;
              etatLedsRouges = Rouges_INIT; 
            } else {
              etatLedsRouges = Rouges_UP;
            } // Fin de if (flagExtinction)
          } // Fin de if (luminositeLedsRouges <= luminositeMiniRouges)
          break;
      } // Fin de switch (etatLedsRouges) 
      analogWrite(pinLedsRouge1, luminositeLedsRouges);
      analogWrite(pinLedsRouge2, luminositeLedsRouges);
    }  // Fin de if (actuelMillisRouges - 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
      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 = 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
        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 = 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
      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 = 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
        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 = 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.write(angleOuvert - angleRebonds);
          servoPassageNiveau2.write(angleOuvert - angleRebonds);
          //SoftwareServo::refresh();
          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.write(angleOuvert - angleRebonds);
            servoPassageNiveau2.write(angleOuvert - angleRebonds);
            //SoftwareServo::refresh();
            precedentTempsRebonds = actuelTempsRebonds;
          } // Fin de if (actuelTempsRebonds - precedentTempsRebonds >= 10)
        } else {
          amplitudeRebonds -= pasRebonds;
          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.write(angleFerme + angleRebonds);
          servoPassageNiveau2.write(angleFerme + angleRebonds);
          //SoftwareServo::refresh();
          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.write(angleFerme + angleRebonds);
          servoPassageNiveau2.write(angleFerme + angleRebonds); 
          //SoftwareServo::refresh();
          precedentTempsRebonds = actuelTempsRebonds;
        } // Fin de if (actuelTempsRebonds - precedentTempsRebonds >= 10)
      } else {
        amplitudeRebonds -= pasRebonds;
        angleRebonds = 0;
        sensRebonds = UP;
      } // Fin de if (angleRebonds > 0)
      break;  
    } // Fin de switch (sensRebond)
  } // Fin de procédure rebondsDown 

  void pointMilieu(){
    if (!servoPassageNiveau1.attached()) {servoPassageNiveau1.attach(pinServo1); }
    if (!servoPassageNiveau2.attached()) {servoPassageNiveau2.attach(pinServo2); }
    delay(150);    
    if (etatPointMilieu == true){   
      // Si le drapeau etatMilieu est vrai on positionne à angle moyen.   
      digitalWrite(pinLedPM, HIGH); digitalWrite(LED_BUILTIN, HIGH);
      angleIntermediaire = (angleFerme + angleOuvert) / 2;
      servoPassageNiveau1.write(angleIntermediaire);
      servoPassageNiveau2.write(angleIntermediaire);
      delay(300);   
      //SoftwareServo::refresh();
      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.
          angleIntermediaire = angleOuvert;
          servoPassageNiveau1.write(angleIntermediaire);
          servoPassageNiveau2.write(angleIntermediaire);
          delay(300);
          //SoftwareServo::refresh();   
        } else if (etatBarrieres == FERME) {
          // Les voies étaient occupées. On repositionne les barrières à fermées.
          angleIntermediaire = angleFerme;
          servoPassageNiveau1.write(angleIntermediaire);
          servoPassageNiveau2.write(angleIntermediaire);
          delay(300);   
          //SoftwareServo::refresh();
        } // Fin de if (etatBarrieres == OUVERT)
        if (servoPassageNiveau1.attached()) {servoPassageNiveau1.detach(); }
        if (servoPassageNiveau2.attached()) {servoPassageNiveau2.detach(); }
        delay(150); 
    } // Fin de if (etatPointMilieu == true)
  } // Fin de procédure pointMilieu()