//--- Gestion des informations reçues sur le port série  --------------------------

//*** /!\ A modifier si nécessaire /!\ ***

//#define Moniteur_PortSerie

//*** Fin des modifications ***
//**********************************************************************************************************************

unsigned long EntreeCaractere;
byte SelectionChar, NbreCaractere;
boolean ValideConsigne;

void SerialEvent()
{
  while (Serial.available())
  {
    char inChar = (char)Serial.read();
    int c = (int)inChar;
    NbreCaractere++;
    if (c > 47 && c < 58)   EntreeCaractere =  EntreeCaractere * 10 + c - 48;

    if (c == 36 && NbreCaractere == 1)    // Caractère $
    {
      ValideConsigne = true;
    }

    if (NbreCaractere == 2 && ValideConsigne == true)
    {
      switch (inChar)
      {
        case 'N':
          SelectionChar = 1;  //*** Numéro de la Carte Arduino BM1
          break;

        case 'Z':
          SelectionChar = 2;  //*** Définition du type de centrale DCC
          break;

        case 'A':
          SelectionChar = 3;  //*** Affiche Etat des BM
          break;

        case 'B':
          SelectionChar = 4;  //*** Activation / Desactivation BM_System
          break;

        case 'E':
          SelectionChar = 5;  //*** Activation / Desactivation individuelle BM Sens 0
          break;

        case 'e':
          SelectionChar = 6;  //*** Activation / Desactivation individuelle BM Sens 1
          break;

        case 'R':
          SelectionChar = 7;  //*** Efface toutes les configurations des Itineraires
          break;

        case 'r':
          SelectionChar = 8;   //*** Efface toutes les configurations des Feux
          break;

        case 'I':
          SelectionChar = 9;  //*** Enregistrement d'un itineraire possible
          break;

        case 'M':
          SelectionChar = 10; //*** Affichage du Moniteur Série
          break;

        case 'm':
          SelectionChar = 11; //*** Affichage du Moniteur Série
          break;

        case 'S':
          SelectionChar = 12; //*** Adresse DCC Generale BM_Systeme
          break;

        case 'T':
          SelectionChar = 13; //*** Adresse DCC Individuel BM_Systeme
          break;

        case 'U':
          SelectionChar = 14; //*** Adresse DCC BM1 Général sens 0
          break;

        case 'V':
          SelectionChar = 15; //*** Adresse DCC BM1 Général sens 1
          break;

        case 'W':
          SelectionChar = 16; //*** Adresse DCC BM1 Individuel sens 0
          break;

        case 'X':
          SelectionChar = 17; //*** Adresse DCC BM1 Individuel sens 1
          break;

        case 'f':
          SelectionChar = 21; //*** Enregistrement configuration feu
          break;

        case 'g':
          SelectionChar = 22;
          break;

        case '@':
          SelectionChar = 23;
          break;

        case 'a':
          SelectionChar = 24; //*** Définition du commun des LED des feux de signalisation
          break;

        case '!':
          SelectionChar = 25;
          break;

        case 'F':
          SelectionChar = 26; //*** Commande manuelle Feux Signalisation
          break;

        case 'j':
          SelectionChar = 27; //*** Adresse I2C
          break;

        case 'y':
          SelectionChar = 28; //*** Etat BM1 au démarrage si gestion activée
          break;

        case 'H':
          SelectionChar = 98; //*** Consignes / Aide
          break;

        case '?':
          SelectionChar = 99; //*** Envoi de la configuration
          break;

        case 'C':
          SelectionChar = 100;  //*** Configuration
          break;

        case 's':
          SelectionChar = 101;  //*** Scanner I2C
          break;
      }
    }

    if (inChar == '\n' || inChar == '\r')
    {
      if (ValideConsigne == true)
      {
        byte NumBorne;
        int ItineraireCorrige;
        switch (SelectionChar)
        {
          case 1: //*** Numéro de la Carte Arduino BM1
            if (EntreeCaractere > 0 && EntreeCaractere < 256)
            {
              NumeroCarte = EntreeCaractere;
              EEPROM.update(EepromNumeroCarte, NumeroCarte);
              delay(10);
              Serial.print(F("Numero Carte : ")); Serial.println(NumeroCarte);
            }
            break;

          case 2: //*** Définition du type de centrale DCC
            if (EntreeCaractere == 0 || EntreeCaractere == 1)
            {
              Centrale = EntreeCaractere;
              EEPROM.update(EepromCentrale, Centrale);
              delay(10);
              Serial.print(F("Centrale DCC = ")); Serial.println(Centrale);
            }
            break;

          case 3: //*** Affiche Etat des BM
            for (byte Sens = 0; Sens < 2; Sens++)
            {
              AffichageSysteme(Sens, true);
            }
            break;

          case 4: //*** Activation / Desactivation BM_System
            if (EntreeCaractere == 0 || EntreeCaractere == 1)
            {
              BM_Systeme = EntreeCaractere;
              EEPROM.update(EepromBM1, BM_Systeme);
              delay(10);
              Initialisation = false;
              if (BM_Systeme)
              {
                EtatLed[0] = Carre;
                EtatLed[1] = Carre;
                digitalWrite(BM_Relais_Borne[0], 1);
                digitalWrite(BM_Relais_Borne[1], 0);
                digitalWrite(BM_Relais_Borne[2], 1);
                digitalWrite(BM_Relais_Borne[3], 0);
                BM_Passant[0] = 0;
                BM_Passant[1] = 0;
                MouvementRelais = 1;
                compteurtempsInitialisation = millis();
              } else {
                EtatLed[0] = Vert;
                EtatLed[1] = Vert;
                digitalWrite(BM_Relais_Borne[0], 0);
                digitalWrite(BM_Relais_Borne[1], 1);
                digitalWrite(BM_Relais_Borne[2], 0);
                digitalWrite(BM_Relais_Borne[3], 1);
                BM_Passant[0] = 1;
                BM_Passant[1] = 1;
                MouvementRelais = 1;
                compteurtempsRelais = millis();
              }
              Pcf8575_Envoi();
              Serial.print(F("$P")); Serial.print(1); Serial.print(BM_Passant[0]); Serial.println(BM_Force[0]); delay(50);
              Serial.print(F("$P")); Serial.print(2); Serial.print(BM_Passant[1]); Serial.println(BM_Force[1]); delay(50);
            }
            break;

          case 5: //*** Activation / Desactivation individuelle BM Sens 0
            if (EntreeCaractere == 0 || EntreeCaractere == 1)
            {
              if (BM_Consigne[0] == 1)
              {
                BM_Force[0] = EntreeCaractere;
              } else {
                BM_Force[0] = 0;
              }
              ChangeEtatBM_Consigne(0);
              if (ProcessingSerie)
              {
                Serial.print(F("$E")); Serial.println(EntreeCaractere);
              }
            }
            break;

          case 6: //*** Activation / Desactivation individuelle BM Sens 1
            if (EntreeCaractere == 0 || EntreeCaractere == 1)
            {
              if (BM_Consigne[1] == 1)
              {
                BM_Force[1] = EntreeCaractere;
              } else {
                BM_Force[1] = 0;
              }
              ChangeEtatBM_Consigne(1);
              if (ProcessingSerie)
              {
                Serial.print(F("$e")); Serial.println(EntreeCaractere);
              }
              Serial.print(F("BM_Force[1] = ")); Serial.println(BM_Force[1]);
            }
            break;

          case 7: //*** Efface toutes les configurations des Itineraires
            MaxTotalItineraires = 0;
            EEPROM.update(EepromNbreItineraires, MaxTotalItineraires);
            delay(10);
            EtatLed[0] = Carre;
            EtatLed[1] = Carre;
            Pcf8575_Envoi();
            Serial.println(F("*** Tous les itineraires ont ete efface ! ***"));
            ListeItineraires();
            InitialisationFeux();
            Serial.println(F("$t1"));
            Serial.println(F("$t2"));
            BM_Passant[0] = 0;
            BM_Passant[1] = 0;
            BM_Force[0] = 1;
            BM_Force[1] = 1;
            Serial.print(F("$P")); Serial.print(1); Serial.print(BM_Passant[0]); Serial.println(BM_Force[0]); delay(50);
            Serial.print(F("$P")); Serial.print(2); Serial.print(BM_Passant[1]); Serial.println(BM_Force[1]); delay(50);
            break;

          case 8: //*** Efface toutes les configurations des Feux
            NbreItinerairesFeux = 0;
            EEPROM.update(EepromNbreFeux, NbreItinerairesFeux);
            EtatLed[0] = Carre;
            EtatLed[1] = Carre;
            Pcf8575_Envoi();
            delay(10);
            Serial.println(F("*** Tous les itineraires des feux ont ete efface ! ***"));
            ListeItineraires();
            InitialisationFeux();
            EtatCapteursOld = EtatCapteurs + 1;
            ChangementFeux();
            break;

          case 9: //*** Enregistrement d'un itineraire possible
            //Serial.print(F("MaxTotalItineraires = ")); Serial.println(MaxTotalItineraires);
            AdresEeprom = EepromItineraire;
            AdresEeprom += MaxTotalItineraires * 2;
            MaxTotalItineraires++;
            EEPROM.update(EepromNbreItineraires, MaxTotalItineraires);
            delay(20);
            Itineraire[MaxTotalItineraires - 1][0] = bitRead(EntreeCaractere,  0);      // Sens
            Itineraire[MaxTotalItineraires - 1][1] = bitRead(EntreeCaractere,  1);      // Numero
            Itineraire[MaxTotalItineraires - 1][1] += bitRead(EntreeCaractere, 2) * 2;
            Itineraire[MaxTotalItineraires - 1][1] += bitRead(EntreeCaractere, 3) * 4;
            Itineraire[MaxTotalItineraires - 1][1] += bitRead(EntreeCaractere, 4) * 8;
            Itineraire[MaxTotalItineraires - 1][1] += bitRead(EntreeCaractere, 5) * 16;
            Itineraire[MaxTotalItineraires - 1][2] = bitRead(EntreeCaractere,  6);       // Borne
            Itineraire[MaxTotalItineraires - 1][2] += bitRead(EntreeCaractere, 7) * 2;
            Itineraire[MaxTotalItineraires - 1][2] += bitRead(EntreeCaractere, 8) * 4;
            Itineraire[MaxTotalItineraires - 1][2] += bitRead(EntreeCaractere, 9) * 8;
            Itineraire[MaxTotalItineraires - 1][2] += bitRead(EntreeCaractere, 10) * 16;
            Itineraire[MaxTotalItineraires - 1][3] = bitRead(EntreeCaractere, 11);       // Etat
            Itineraire[MaxTotalItineraires - 1][4] = bitRead(EntreeCaractere, 12);       // Consigne Feu RAL30/60
#ifdef Moniteur_PortSerie
            Serial.print(AdresEeprom); Serial.print(F(" * "));
            Serial.print(EntreeCaractere); Serial.print(F(" -> "));
            Serial.print(Itineraire[MaxTotalItineraires - 1][0]); Serial.print(F(" | "));
            Serial.print(Itineraire[MaxTotalItineraires - 1][1]); Serial.print(F(" | "));
            Serial.print(Itineraire[MaxTotalItineraires - 1][2]); Serial.print(F(" | "));
            Serial.print(Itineraire[MaxTotalItineraires - 1][3]); Serial.print(F(" | "));
            Serial.println(Itineraire[MaxTotalItineraires - 1][4]);
#endif
            EEPROM.put(AdresEeprom, EntreeCaractere);
            delay(20);
            ListeItineraires();
            InitialisationFeux();
            EtatCapteursOld = EtatCapteurs + 1;
            if (BM_Systeme == 1)
            {
              BM_Consigne[0] = 1;
              BM_Consigne[1] = 1;
              BM_Force[0] = 1;
              BM_Force[1] = 1;
              DetermineItineraires();
              DetermineEtatBM();
            }
            break;

          case 10: //*** Affichage du Moniteur Série
            if (EntreeCaractere == 0 || EntreeCaractere == 1)
            {
              MoniteurSerie = EntreeCaractere;
              EEPROM.update(EepromMoniteurSerie, MoniteurSerie);
              delay(10);
              Serial.print(F("\nAffichage Moniteur Serie Actif : ")); Serial.println(MoniteurSerie);
            }
            break;

          case 11: //*** Affichage du Moniteur Série
            if (EntreeCaractere == 0 || EntreeCaractere == 1)
            {
              MoniteurSerie = !EntreeCaractere;
              ProcessingSerie = EntreeCaractere;
            }
            break;

          case 12: //*** Adresse DCC Generale BM_Systeme
            if (EntreeCaractere > 4 && EntreeCaractere < 10000)
            {
              AdresseDCC_BM[0] = EntreeCaractere;
              EEPROM.put(EepromDCCBM1, AdresseDCC_BM[0]);
              delay(10);
              if (MoniteurSerie) Serial.print(F("Adresse DCC Sytem BM General = ")); Serial.println(AdresseDCC_BM[0]);
            }
            break;

          case 13: //*** Adresse DCC Individuel BM_Systeme
            if (EntreeCaractere > 4 && EntreeCaractere < 10000)
            {
              AdresseDCC_BM[1] = EntreeCaractere;
              EEPROM.put(EepromDCCBM1 + 2, AdresseDCC_BM[1]);
              delay(10);
              Serial.print(F("Adresse DCC Sytem BM Individuel = ")); Serial.println(AdresseDCC_BM[1]);
            }
            break;

          case 14: //*** Adresse DCC BM1 Général sens 0
            if (EntreeCaractere > 4 && EntreeCaractere < 10000)
            {
              AdresseDCC_BM[2] = EntreeCaractere;
              EEPROM.put(EepromDCCBM1 + 4, AdresseDCC_BM[2]);
              delay(10);
              Serial.print(F("Adresse DCC BM1 sens 0 General = ")); Serial.println(AdresseDCC_BM[2]);
            }
            break;

          case 15: //*** Adresse DCC BM1 Général sens 1
            if (EntreeCaractere > 4 && EntreeCaractere < 10000)
            {
              AdresseDCC_BM[3] = EntreeCaractere;
              EEPROM.put(EepromDCCBM1 + 6, AdresseDCC_BM[3]);
              delay(10);
              Serial.print(F("Adresse DCC BM1 sens 1 General = ")); Serial.println(AdresseDCC_BM[3]);
            }
            break;

          case 16: //*** Adresse DCC BM1 Individuel sens 0
            if (EntreeCaractere > 4 && EntreeCaractere < 10000)
            {
              AdresseDCC_BM[4] = EntreeCaractere;
              EEPROM.put(EepromDCCBM1 + 8, AdresseDCC_BM[4]);
              delay(10);
              if (MoniteurSerie) Serial.print(F("Adresse DCC BM1 sens 0 Indiv = ")); Serial.println(AdresseDCC_BM[4]);
            }
            break;

          case 17: //*** Adresse DCC BM1 Individuel sens 1
            if (EntreeCaractere > 4 && EntreeCaractere < 10000)
            {
              AdresseDCC_BM[5] = EntreeCaractere;
              EEPROM.put(EepromDCCBM1 + 10, AdresseDCC_BM[5]);
              delay(10);
              Serial.print(F("Adresse DCC BM1 sens 1 Indiv = ")); Serial.println(AdresseDCC_BM[5]);
            }
            break;

          case 21:
            AdresEeprom = EepromFeux;
            AdresEeprom += NbreItinerairesFeux * 4;
            NbreItinerairesFeux++;
            EEPROM.update(EepromNbreFeux, NbreItinerairesFeux);
            Serial.print(F("NbreItinerairesFeux = ")); Serial.println(NbreItinerairesFeux);
            delay(20);
            FeuItineraire[NbreItinerairesFeux - 1][0] = bitRead(EntreeCaractere,  0);      // Sens
            FeuItineraire[NbreItinerairesFeux - 1][1] = bitRead(EntreeCaractere,  1);      // Numero
            FeuItineraire[NbreItinerairesFeux - 1][1] += bitRead(EntreeCaractere, 2) * 2;
            FeuItineraire[NbreItinerairesFeux - 1][1] += bitRead(EntreeCaractere, 3) * 4;
            FeuItineraire[NbreItinerairesFeux - 1][1] += bitRead(EntreeCaractere, 4) * 8;
            FeuItineraire[NbreItinerairesFeux - 1][1] += bitRead(EntreeCaractere, 5) * 16;
            FeuItineraire[NbreItinerairesFeux - 1][2] = bitRead(EntreeCaractere,  6);       // Borne
            FeuItineraire[NbreItinerairesFeux - 1][2] += bitRead(EntreeCaractere, 7) * 2;
            FeuItineraire[NbreItinerairesFeux - 1][2] += bitRead(EntreeCaractere, 8) * 4;
            FeuItineraire[NbreItinerairesFeux - 1][2] += bitRead(EntreeCaractere, 9) * 8;
            FeuItineraire[NbreItinerairesFeux - 1][2] += bitRead(EntreeCaractere, 10) * 16;
            FeuItineraire[NbreItinerairesFeux - 1][3] = bitRead(EntreeCaractere,  11);      // Type de signalisation
            FeuItineraire[NbreItinerairesFeux - 1][3] += bitRead(EntreeCaractere, 12) * 2;
            FeuItineraire[NbreItinerairesFeux - 1][3] += bitRead(EntreeCaractere, 13) * 4;
            FeuItineraire[NbreItinerairesFeux - 1][3] += bitRead(EntreeCaractere, 14) * 8;
            FeuItineraire[NbreItinerairesFeux - 1][4] = bitRead(EntreeCaractere,  15);       // Borne pré-avertissment
            FeuItineraire[NbreItinerairesFeux - 1][4] += bitRead(EntreeCaractere, 16) * 2;
            FeuItineraire[NbreItinerairesFeux - 1][4] += bitRead(EntreeCaractere, 17) * 4;
            FeuItineraire[NbreItinerairesFeux - 1][4] += bitRead(EntreeCaractere, 18) * 8;
            FeuItineraire[NbreItinerairesFeux - 1][4] += bitRead(EntreeCaractere, 19) * 16;

#ifdef Moniteur_PortSerie
            Serial.print(F("Enreg => ")); Serial.print(EntreeCaractere); Serial.print(F(" -> "));
            Serial.print(FeuItineraire[NbreItinerairesFeux - 1][0]); Serial.print(F(" | "));
            Serial.print(FeuItineraire[NbreItinerairesFeux - 1][1]); Serial.print(F(" | "));
            Serial.print(FeuItineraire[NbreItinerairesFeux - 1][2]); Serial.print(F(" | "));
            Serial.print(FeuItineraire[NbreItinerairesFeux - 1][3]); Serial.print(F(" | "));
            Serial.println(FeuItineraire[NbreItinerairesFeux - 1][4]);
#endif
            Serial.print(F("AdresEeprom = ")); Serial.print(AdresEeprom); Serial.print(F(" | EntreeCaractere = ")); Serial.println(EntreeCaractere);
            EEPROM.put(AdresEeprom, EntreeCaractere);
            delay(20);
            Serial.print(F("$G")); Serial.println(EntreeCaractere);
            Clignotement[0] = false;
            Clignotement[1] = false;
            EtatCapteursOld = EtatCapteurs + 1;
            ListeItineraires();
            InitialisationFeux();
            EtatCapteursOld = EtatCapteurs + 1;
            if (BM_Systeme == 1)
            {
              BM_Consigne[0] = 1;
              BM_Consigne[1] = 1;
              DetermineItineraires();
              DetermineEtatBM();
            }
            break;

          case 22:
            for (byte Scan = 0; Scan < NbreItinerairesFeux; Scan++)
            {
              byte AdresEeprom = EepromFeux + Scan * 2;
              int EntreeCaractere;
              EEPROM.get(AdresEeprom, EntreeCaractere);
              Serial.print(F("$G")); Serial.println(EntreeCaractere);
            }
            break;

          case 23:
            if (EntreeCaractere > 0)
            {
              int FeuCouleur = EntreeCaractere / 10;
              int FeuClignotement = EntreeCaractere - FeuCouleur * 10;
              EtatLed[0] = FeuCouleur;
              EtatLed[1] = FeuCouleur;
              if (FeuClignotement > 0)
              {
                Clignotement[0] = true;
                Clignotement[1] = true;
                OrdreClignotement[0] = FeuClignotement;
                OrdreClignotement[1] = FeuClignotement;
                OrdreClignotement[2] = 0;
                OrdreClignotement[3] = 0;
                if (FeuClignotement == 9)
                {
                  OrdreClignotement[0] = 6;
                  OrdreClignotement[1] = 6;
                  OrdreClignotement[2] = 4;
                  OrdreClignotement[3] = 4;
                }
              } else {
                Clignotement[0] = false;
                Clignotement[1] = false;
              }
              Manuel = true;
              Pcf8575_Envoi();
            } else {
              Manuel = false;
              EtatCapteursOld = EtatCapteurs + 1;
            }
            break;

          case 24: //*** Définition du commun des LED des feux de signalisation
            if (EntreeCaractere == 0 || EntreeCaractere == 1)
            {
              AnodeCommun = EntreeCaractere;
              EEPROM.update(EepromFeuCathodeAnode, AnodeCommun);
              delay(10);
              Serial.print(F("Commun Anode LED Feux Signalisation = ")); Serial.println(AnodeCommun);
              dataOld++;
              Pcf8575_Envoi();
            }
            break;

          case 25:
            for (byte Scan = 0; Scan < MaxTotalItineraires; Scan++)
            {
              byte AdresEeprom = EepromItineraire + Scan * 2;
              unsigned int Valeur;
              EEPROM.get(AdresEeprom, Valeur);
              Serial.print(F("$i")); Serial.println(Valeur);
              delay(50);
            }
            delay(100);
            for (byte Scan = 0; Scan < NbreItinerairesFeux; Scan++)
            {
              byte AdresEeprom = EepromFeux + Scan * 2;
              int EntreeCaractere;
              EEPROM.get(AdresEeprom, EntreeCaractere);
              Serial.print(F("$G")); Serial.println(EntreeCaractere);
            }
            break;

          case 26: //*** Commande manuelle Feux Signalisation
            Pcf8575_Envoi();
            break;

          case 27: //*** Adresse I2C
            if (EntreeCaractere > 31 && EntreeCaractere < 40)
            {
              AdresseI2C = EntreeCaractere;
              EEPROM.update(EepromI2C, AdresseI2C);
              delay(10);
              dataOld++;
              Pcf8575_Envoi();
            }
            break;

          case 28: //*** Etat BM1 au démarrage si gestion activée
            if (EntreeCaractere < 4)
            {
              InitialisationBM0 = bitRead(EntreeCaractere, 0);
              EEPROM.update(EepromIniBM0, InitialisationBM0);

              InitialisationBM1 =  bitRead(EntreeCaractere, 1);
              EEPROM.update(EepromIniBM1, InitialisationBM1);

              bitWrite(InitilisationBM, 0, InitialisationBM0);
              bitWrite(InitilisationBM, 1, InitialisationBM1);
            }
            break;

          case 98: //*** Consignes / Aide
            Serial.println(F("\nAffichage des consignes de commande\n"));
            Serial.println(F("$?    Envoie la configuration"));
            Serial.println(F("$Mx   Affichage des informations dans le Moniteur Serie(0 ou 1)"));
            Serial.println(F("$Nxx  Numero de la carte Arduino"));
            Serial.println(F("$Zx   Type de centrale DCC (0 = Lenz / 1 = Roco"));
            Serial.println(F("$A    Affiche Etat des BM"));
            Serial.println(F("$Bx   Active / Desactive Gestion du systeme BM1 (0 ou 1)"));
            Serial.println(F("$Ex   Active / Desactive Systeme BM1 - Sens 0 (0 ou 1)"));
            Serial.println(F("$ex   Active / Desactive Systeme BM1 - Sens 1 (0 ou 1)"));
            Serial.println(F("$R    Efface tous les itineraires"));
            Serial.println(F("$r    Efface toutes les configurations des feux"));
            Serial.println(F("$Ixx  Ajoute la définition d'un ititneraire"));
            Serial.println(F("$fxx  Ajoute la définition d'un feu"));
            Serial.println(F("$Sxx  Adresse DCC Systeme BM pour gestion generale"));
            Serial.println(F("$Txx  Adresse DCC Systeme BM pour gestion individuelle"));
            Serial.println(F("$Uxx  Adresse DCC consigne BM pour commande generale Sens 0"));
            Serial.println(F("$Vxx  Adresse DCC consigne BM pour commande generale Sens 1"));
            Serial.println(F("$Wxx  Adresse DCC consigne BM pour commande individuelle Sens 0"));
            Serial.println(F("$Xxx  Adresse DCC consigne BM pour commande individuelle Sens 1"));
            break;

          case 99: //*** Envoi de la configuration
            if (EntreeCaractere == 0)
            {
              Serial.print(F("$N")); Serial.println(NumeroCarte); delay(50);
              Serial.print(F("$Z")); Serial.println(Centrale); delay(50);
              Serial.print(F("$S")); Serial.println(AdresseDCC_BM[0]); delay(50);
              Serial.print(F("$T")); Serial.println(AdresseDCC_BM[1]); delay(50);
              Serial.print(F("$U")); Serial.println(AdresseDCC_BM[2]); delay(50);
              Serial.print(F("$V")); Serial.println(AdresseDCC_BM[3]); delay(50);
              Serial.print(F("$W")); Serial.println(AdresseDCC_BM[4]); delay(50);
              Serial.print(F("$X")); Serial.println(AdresseDCC_BM[5]); delay(50);
              Serial.print(F("$a")); Serial.println(AnodeCommun); delay(50);
              Serial.print(F("$J")); Serial.println(AdresseI2C); delay(50);
              Serial.print(F("$Y")); Serial.println(InitilisationBM); delay(50);
              for (byte Scan = 0; Scan < MaxTotalItineraires; Scan++)
              {
                byte AdresEeprom = EepromItineraire + Scan * 2;
                unsigned int Val = EEPROM.get(AdresEeprom, Val);
                delay(10);
                Serial.print(F("$i")); Serial.println(Val); delay(50);
              }
              for (byte Scan = 0; Scan < NbreItinerairesFeux; Scan++)
              {
                byte AdresEeprom = EepromFeux + Scan * 2;
                int EntreeCaractere;
                EEPROM.get(AdresEeprom, EntreeCaractere);
                Serial.print(F("$G")); Serial.println(EntreeCaractere);
              }
              InitialisationFeux();
            } else {
              switch (EntreeCaractere)
              {
                case 1:
                  Serial.print(F("$S")); Serial.println(AdresseDCC_BM[0]); delay(50);
                  break;
                case 2:
                  Serial.print(F("$T")); Serial.println(AdresseDCC_BM[1]); delay(50);
                  break;
                case 3:
                  Serial.print(F("$U")); Serial.println(AdresseDCC_BM[2]); delay(50);
                  break;
                case 4:
                  Serial.print(F("$V")); Serial.println(AdresseDCC_BM[3]); delay(50);
                  break;
                case 5:
                  Serial.print(F("$W")); Serial.println(AdresseDCC_BM[4]); delay(50);
                  break;
                case 6:
                  Serial.print(F("$X")); Serial.println(AdresseDCC_BM[5]); delay(50);
                  break;
                case 7:
                  Serial.print(F("$N")); Serial.println(NumeroCarte); delay(50);
                  break;
                case 8:
                  Serial.print(F("$Z")); Serial.println(Centrale); delay(50);
                  break;
                case 9:
                  Serial.print(F("$J")); Serial.println(AdresseI2C); delay(50);
                  break;
              }
            }
            break;

          case 100: //*** Configuration
            Serial.print(F("\n\nCarte Numero ")); Serial.println(NumeroCarte);
            Serial.print(F("Version ")); Serial.println(Date_Compilation);
            Serial.print(F("Gestion Canton DCC avec BM1 compatible avec "));
            switch (Centrale)
            {
              case 0:
                Serial.println(F("Centrale Roco, NanoX,...\n"));
                break;
              case 1:
                Serial.println(F("Centrale Lenz\n"));
                break;
            }
            ListeItineraires();
            Serial.print(F("Nbre Total de Capteurs = ")); Serial.println(MaxCapteurBornes);
            Serial.print(F("Affichage Moniteur Serie Actif : ")); Serial.println(MoniteurSerie);
            InitialisationBM();
            Initialisation = false;
            break;

          case 101: //*** Scanner I2C
            Serial.println(F("Scan Adresse Bus I2C"));
            ScannerI2C();
            break;
        }
      }
      //*** Remise à zéro des variables ***
      EntreeCaractere = 0;
      SelectionChar = 0;
      NbreCaractere = 0;
      ValideConsigne = false;
    }
  }
}