MAJ affichage DUE récepteur port Série

[eric93]

Bonjour
je n'arrive pas a avoir sur le port série de la carte DUE récepteur la lise a jour des codes au fur à mesure des envois de le carte DUE émettrice.
Le seul moyen trouvé est de mettre 1 WATCHDOG dans le programme de la carte récepteur.
Cela fait clignoté la carte et n'est pas compatible de mon besoin.
Quelqu'un a-t-il une idée pour que les nouveaux codes reçus soient pris en compte
A savoir que je ne suis pas 1 expert d'ARDUINO
Merci pour votre aide

[fdufnews]

Bonjour et bienvenue,

Merci de prendre quelques minutes pour lire "Les bonnes pratiques du forum francophone" et les appliquer.

Les bonnes pratiques du Forum Francophone

QUELQUES RÈGLES SIMPLES À LIRE IMPÉRATIVEMENT AVANT DE POSTER Elles faciliteront la vie de tous et contribueront à rendre votre expérience la plus enrichissante possible. Bienvenue !!! Vous rejoignez une communauté : nous incitons très fortement les nouveaux arrivants sur la partie francophone à rédiger dans ce fil de discussion une rapide présentation personnelle. Aidez nous à vous aider : les réponses qui sont faites sur le forum francophone arduino sont majorit…

Si tu veux de l'aide, il faudrait donner un peu plus de détail sur ta configuration matérielle et poster les codes qui te posent problème.

[terwal]

Franchement, je suis désolé, mais je n’ai rien compris à ta demande.
On ne sait pas si tu utilises le port série pour communiquer ou visualiser les informations que tu reçois par un autre périphérique.
Si tu as configurer correctement le port série de chaque coté, si tu l’utilise comme moyen de communication.
On ne sait pas ce qu’est tes codes, je suppose des chiffres envoyé sous forme de chaine de caractères ?

A lire ta description, on suppose(encore ), que ton attente d’information sur le port série n’est pas correcte.
Tu attends bien sois dans une boucle infinie, sois régulièrement dans la loop?

[eric93]

Ok je vais essayer de clarifier
2 carte DUE avec port série 1 activé
La 1ere envoie à la 2eme 1 code pour allumer des Led en fonction de l'état détectée par le prog de la 1ere

`void setup() {
  // put your setup code here, to run once:

Serial.begin(9600); // init impression ecran
Serial1.begin(250000);`

void loop() {

Serial.flush(); // effacement message ecran

//Allumage du signal au Vert

Serial1.write(22); // Envoi Code

Serial.println("Vert");

f (EtatCARRE1 ==LOW) {Serial1.write(25);} else {Serial1.write(23);};  // Envoi Code avec ou sans le Carré
Serial.println("Rouge");

Serial1.write(24); // Envoi Code
Serial.println("Orange");

La carte 2 qui reçoit

void setup()

{

Serial.begin(9600); 
Serial1.begin(250000);

void loop()

{

Serial.flush(); // effacement message ecran


CodeRecu =Serial1.available();

Serial.print("CodeRecu ");Serial.println(CodeRecu);

x = Serial1.read();

Serial.print("x ");Serial.println(x);

i=0;

while (CodeRecu>0)

{

Serial.flush();

x = Serial1.read();

Serial.print("x ");Serial.println(x);

i=i+1;

Serial.println(i);

if ( i == 1) { C1=x;} else {C1=0;}

if ( i == 2) { C2=x;} else {C2=0;}

if ( i == 3) { C3=x;} else {C3=0;}

if ( i == 4) { C4=x;} else {C4=0;}

if ( i == 5) { C5=x;} else {C5=0;}

if ( i == 6) { C6=x;} else {C6=0;}

if ( i == 7) { C7=x;} else {C7=0;}

if ( i == 8) { C8=x;} else {C8=0;}

Serial.print("C1 ");Serial.println(C1);

Serial.print("C2 ");Serial.println(C2);

Serial.print("C3 ");Serial.println(C3);

Serial.print("C4 ");Serial.println(C4);

Serial.print("C5 ");Serial.println(C5);

Serial.print("C6 ");Serial.println(C6);

Serial.print("C7 ");Serial.println(C7);

Serial.print("C8 ");Serial.println(C8);

Et donc le résultat

Carte émettrice Etat 1 sur écran PC

19:02:27.625 -> ---------- Début de boucle -------------
19:02:27.657 -> Vert

Carte réceptrice Etat 1 sur écran PC
19:04:02.686 -> x 22
19:04:02.719 -> 1
19:04:02.719 -> C1 22
je reçois bien le code 22

Carte émettrice Etat 2 sur écran PC
19:06:00.136 -> ---------- Début de boucle -------------
19:06:00.200 -> Rouge

Carte réceptrice Etat 2 sur écran PC
19:09:47.721 -> x 22
19:09:47.721 -> 1
19:09:47.721 -> C1 22
Le code n'a pas évolué, je devrais recevoir le CODE 23

Si je met 1 watchdog dans le prog de la carte 2 alors le code 23 apparait
mais le watchdog bloque le prog et ce n'est pas compatible du projet
En espérant avoir éclairer le sujet.
Je ne peux pas mettre le code des 2 cartes entièrement car ils font plusieurs centaines de lignes
Merci pour votre lecture

[fdufnews]

Merci de mettre le code entre balise comme demandé dans "Les bonnes pratiques du forum francophone"

[terwal]

Ok, c’est mieux, mais je vais encore jouer le rabat-joie, mais pourquoi nous donner un code partiel, qui risque du coup de ne pas montrer ton erreur ?
De plus pour nous c’est plus difficile de lire un tel code et surtout plus long finalement

La première remarque qui me vient avec les informations que tu nous a donné et pourquoi entre l’état 1 et l’état 2 de la carte réceptrice i n’a pas évolué ?
D’ailleurs on ne voit pas non plus “CodeRecu”, mais je suppose que c’est parce que tu ne l’a pas copié/collé ?

Remarque plus cosmétique:
Tu n’indique pas ton code, donc il est plus compliqué à lire.
si tu veux faire un if sur une seul ligne tu peux faire ça

if (EtatCARRE1 ==LOW) Serial.write(25); else Serial.write(23);
//Ou
Serial1.write(EtatCARRE1 ==LOW ? 25 : 23);  

[jpbbricole]

Bonjour eric93

@eric93

En espérant avoir éclairer le sujet.

Ton code me semble rudement "alambiqué", dis moi ce que tu veux faire avec ces transmissions, pour voir s'il n'y a pas moyen de simplifier et rendre plus pratique.

A+
Cordialement
jpbbricole

[fdufnews]

@eric93

CodeRecu =Serial1.available();

Serial.print("CodeRecu ");Serial.println(CodeRecu);

x = Serial1.read();

Il ne faut pas faire un Serial1.read() (et tout le code qui suit) si CodeRecu == 0.

---

@eric93

Serial.flush(); // effacement message ecran

Flush n'efface rien, flush() attend que le buffer de transmission soit vide, ce qui bloque l'exécution du reste du programme.
Ce n'est pas très malin car Serial est configuré à 9600 bauds ce qui veut dire que la transmission est relativement lente et cela peut poser des problèmes avec Serial1 qui est configuré à 250000 bauds.

---

Et même remarque que @terwal on a qu'un morceau de code sorti de son contexte donc on a qu'une information partielle sur le déroulement de ton code.

[eric93]

Donc tu me suggère quoi?
surpression du serial.flush et que me conseilles-tu comme vitesse de COM ?
sachant que le prog de la carte émettrice me pose des pb si j'augmente la vitesse au delà de 9600 bauds
Pour le code je vous le mets en entier.
Vous trouverez des "traces" de bus IC2 dans le code car j'ai fait 1 variante I2C mais qui ne fonctionne pas car la transmission se bloque dans le temps aléatoirement et bloque le prog.
Cela pourra faire un sujet ultérieur.

Carte émettrice

//      05/07/2025      N° de Programme = 20         Nb cantons progammés = 4      Avec   Evitement ou Garage           Type de carte Relais=   SIMPLE

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>







int LedZC9 = 54;   // Pour allumage Led sur plaquette
int LedZA9 = 55;   // Pour allumage Led sur plaquette
int LedZC10 = 56;  // Pour allumage Led sur plaquette
int LedZA10 = 57;  // Pour allumage Led sur plaquette

int LedZC1 = 58;  // Pour allumage Led ZC9 sur plaquette
int LedZA1 = 59;  // Pour allumage Led ZA9 sur plaquette
int LedZC2 = 60;  //Pour allumage Led ZC10 sur plaquette
int LedZA2 = 61;  // Pour allumage Led ZA10 sur plaquette

int SortieZC1 = 64;  // Pour envoi info ZC9 sur carte précédante
int SortieZA1 = 65;  // Pour envoi info ZA9 sur carte précédante
int SortieZC2 = 62;  // Pour envoi info ZC10 sur carte précédante
int SortieZA2 = 63;  // Pour envoi info ZA10 sur carte précédante

int TimeI2CMini;
int TimeI2CMaxi;

// Valeur pour affichage des commentaires 0 = pas d'affiche  1 = affiche des commentaires à l'écran, voir vers ligne 520
int Affichage;     // Affichage ZC, ZA, carré, Feu
int Affichage1;    // Affichage de la Pousse dans le canton
int Affichage2;    // Affichage de l'état des relais
int Affichage3;    // Affichage des tempos de redémarrage
int PosiAig1 = 2;  // Donne la position de la 1ere aiguille utilisée
int PosiAig2 = 3;  // Donne la position de la 2eme aiguille utilisée
int PosiAig3 = 8;  // Donne la position de la 3eme aiguille utilisée
int PosiAig4 = 9;  // Donne la position de la 4eme aiguille utilisée
int EtatPosiAig1;
int EtatPosiAig2;
int EtatPosiAig3;
int EtatPosiAig4;
unsigned long TimeI2C = 0;  // Minuteur pour ré initialisation du BUS I2C toutes les 30mn
int NbI2C;                  // pour ré initialisation du BUS I2C toutes les 30mn


// Canton C1 -      Pleine voie ou Garage
const int RC1ZCNR = 45;
const int RC1ZC0V = 44;
const int DC1 = 33;
const int DZA1 = 31;
const int CARRE1 = 11;
int EtatDC1;
int EtatDZA1;
int EtatCARRE1;
int FeuRouge1;
unsigned long Tempo1 = 0;
unsigned long PreviousTempo1 = 0;
int Pousse1;
int EtatRC1ZCNR;
int EtatRC1ZC0V;
unsigned long TimeDC1L = 0;          // Time où est détecté 1 train dans la zone Canton
unsigned long TimeDZA1L = 0;         // Time où est détecté 1 train dans la zone Arret
unsigned long TimeDC1ML = 0;         // Mis en mémoire du temps où a été  détecté 1 train dans la zone Canton
unsigned long TimeDZA1ML = 0;        // Mis en mémoire du temps où a été  détecté 1 train dans la zone Arret
int I1DC;                            // Permet de de mémoriser l'état de la zone Canton, 1 utilisée que pour le calcul de la pousse
int I1DZA;                           // Permet de de mémoriser l'état de la zone Arret, 1 utilisée que pour le calcul de la pousse
int TZC1;                            // Mémoire d'activation de la tempo ZC du canton
unsigned long TempoZC1 = 0;          // 1 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZC1 = 0;  // 1 de mise mémoire du temps après la fin d'occupation de la zC
int TZA1;                            // Mémoire d'activation de la tempo ZA du canton
unsigned long TempoZA1 = 0;          // 1 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZA1 = 0;  // 1 de mise mémoire du temps après la fin d'occupation de la zC
int EtatFeuOrange1;
int StockEtatDC1;   // Mémorisation de l'état de la 1 pour remettre la valeur  initiale à la fin du travail
int StockEtatDZA1;  // Mémorisation de l'état de la 1 pour remettre la valeur  initiale à la fin du travail


// Canton C2 -      Pleine voie ou Garage
const int RC2ZCNR = 47;
const int RC2ZC0V = 46;
const int DC2 = 37;
const int DZA2 = 35;
const int CARRE2 = 12;
int EtatDC2;
int EtatDZA2;
int EtatCARRE2;
int FeuRouge2;
unsigned long Tempo2 = 0;
unsigned long PreviousTempo2 = 0;
int Pousse2;
int EtatRC2ZCNR;
int EtatRC2ZC0V;
unsigned long TimeDC2L = 0;          // Time où est détecté 1 train dans la zone Canton
unsigned long TimeDZA2L = 0;         // Time où est détecté 1 train dans la zone Arret
unsigned long TimeDC2ML = 0;         // Mis en mémoire du temps où a été  détecté 1 train dans la zone Canton
unsigned long TimeDZA2ML = 0;        // Mis en mémoire du temps où a été  détecté 1 train dans la zone Arret
int I2DC;                            // Permet de de mémoriser l'état de la zone Canton, 2 utilisée que pour le calcul de la pousse
int I2DZA;                           // Permet de de mémoriser l'état de la zone Arret, 2 utilisée que pour le calcul de la pousse
int TZC2;                            // Mémoire d'activation de la tempo ZC du canton
unsigned long TempoZC2 = 0;          // 2 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZC2 = 0;  // 2 de mise mémoire du temps après la fin d'occupation de la zC
int TZA2;                            // Mémoire d'activation de la tempo ZA du canton
unsigned long TempoZA2 = 0;          // 2 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZA2 = 0;  // 2 de mise mémoire du temps après la fin d'occupation de la zC
int EtatFeuOrange2;
int StockEtatDC2;   // Mémorisation de l'état de la 2 pour remettre la valeur  initiale à la fin du travail
int StockEtatDZA2;  // Mémorisation de l'état de la 2 pour remettre la valeur  initiale à la fin du travail


// Canton C3 -      Pleine voie ou Garage
const int RC3ZCNR = 43;
const int RC3ZC0V = 42;
const int DC3 = 32;
const int DZA3 = 30;
const int CARRE3 = 19;
int EtatDC3;
int EtatDZA3;
int EtatCARRE3;
int FeuRouge3;
unsigned long Tempo3 = 0;
unsigned long PreviousTempo3 = 0;
int Pousse3;
int EtatRC3ZCNR;
int EtatRC3ZC0V;
unsigned long TimeDC3L = 0;          // Time où est détecté 1 train dans la zone Canton
unsigned long TimeDZA3L = 0;         // Time où est détecté 1 train dans la zone Arret
unsigned long TimeDC3ML = 0;         // Mis en mémoire du temps où a été  détecté 1 train dans la zone Canton
unsigned long TimeDZA3ML = 0;        // Mis en mémoire du temps où a été  détecté 1 train dans la zone Arret
int I3DC;                            // Permet de de mémoriser l'état de la zone Canton, 3 utilisée que pour le calcul de la pousse
int I3DZA;                           // Permet de de mémoriser l'état de la zone Arret, 3 utilisée que pour le calcul de la pousse
int TZC3;                            // Mémoire d'activation de la tempo ZC du canton
unsigned long TempoZC3 = 0;          // 3 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZC3 = 0;  // 3 de mise mémoire du temps après la fin d'occupation de la zC
int TZA3;                            // Mémoire d'activation de la tempo ZA du canton
unsigned long TempoZA3 = 0;          // 3 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZA3 = 0;  // 3 de mise mémoire du temps après la fin d'occupation de la zC
int EtatFeuOrange3;
int StockEtatDC3;   // Mémorisation de l'état de la 3 pour remettre la valeur  initiale à la fin du travail
int StockEtatDZA3;  // Mémorisation de l'état de la 3 pour remettre la valeur  initiale à la fin du travail


// Canton C4 -      Pleine voie ou Garage
const int RC4ZCNR = 49;
const int RC4ZC0V = 48;
const int DC4 = 36;
const int DZA4 = 34;
const int CARRE4 = 14;
int EtatDC4;
int EtatDZA4;
int EtatCARRE4;
int FeuRouge4;
unsigned long Tempo4 = 0;
unsigned long PreviousTempo4 = 0;
int Pousse4;
int EtatRC4ZCNR;
int EtatRC4ZC0V;
unsigned long TimeDC4L = 0;          // Time où est détecté 1 train dans la zone Canton
unsigned long TimeDZA4L = 0;         // Time où est détecté 1 train dans la zone Arret
unsigned long TimeDC4ML = 0;         // Mis en mémoire du temps où a été  détecté 1 train dans la zone Canton
unsigned long TimeDZA4ML = 0;        // Mis en mémoire du temps où a été  détecté 1 train dans la zone Arret
int I4DC;                            // Permet de de mémoriser l'état de la zone Canton, 4 utilisée que pour le calcul de la pousse
int I4DZA;                           // Permet de de mémoriser l'état de la zone Arret, 4 utilisée que pour le calcul de la pousse
int TZC4;                            // Mémoire d'activation de la tempo ZC du canton
unsigned long TempoZC4 = 0;          // 4 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZC4 = 0;  // 4 de mise mémoire du temps après la fin d'occupation de la zC
int TZA4;                            // Mémoire d'activation de la tempo ZA du canton
unsigned long TempoZA4 = 0;          // 4 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZA4 = 0;  // 4 de mise mémoire du temps après la fin d'occupation de la zC
int EtatFeuOrange4;
int StockEtatDC4;   // Mémorisation de l'état de la 4 pour remettre la valeur  initiale à la fin du travail
int StockEtatDZA4;  // Mémorisation de l'état de la 4 pour remettre la valeur  initiale à la fin du travail


// Canton C5 -      Pleine voie ou Garage
const int RC5ZCNR = 66;
const int RC5ZC0V = 67;
const int DC5 = 5;
const int DZA5 = 4;
const int CARRE5 = 72;
int EtatDC5;
int EtatDZA5;
int EtatCARRE5;
int FeuRouge5;
unsigned long Tempo5 = 0;
unsigned long PreviousTempo5 = 0;
int Pousse5;
int EtatRC5ZCNR;
int EtatRC5ZC0V;
unsigned long TimeDC5L = 0;          // Time où est détecté 1 train dans la zone Canton
unsigned long TimeDZA5L = 0;         // Time où est détecté 1 train dans la zone Arret
unsigned long TimeDC5ML = 0;         // Mis en mémoire du temps où a été  détecté 1 train dans la zone Canton
unsigned long TimeDZA5ML = 0;        // Mis en mémoire du temps où a été  détecté 1 train dans la zone Arret
int I5DC;                            // Permet de de mémoriser l'état de la zone Canton, 5 utilisée que pour le calcul de la pousse
int I5DZA;                           // Permet de de mémoriser l'état de la zone Arret, 5 utilisée que pour le calcul de la pousse
int TZC5;                            // Mémoire d'activation de la tempo ZC du canton
unsigned long TempoZC5 = 0;          // 5 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZC5 = 0;  // 5 de mise mémoire du temps après la fin d'occupation de la zC
int TZA5;                            // Mémoire d'activation de la tempo ZA du canton
unsigned long TempoZA5 = 0;          // 5 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZA5 = 0;  // 5 de mise mémoire du temps après la fin d'occupation de la zC
int EtatFeuOrange5;
int StockEtatDC5;   // Mémorisation de l'état de la 5 pour remettre la valeur  initiale à la fin du travail
int StockEtatDZA5;  // Mémorisation de l'état de la 5 pour remettre la valeur  initiale à la fin du travail


// Canton C6 -      Pleine voie ou Garage
const int RC6ZCNR = 73;
const int RC6ZC0V = 74;
const int DC6 = 7;
const int DZA6 = 6;
const int CARRE6 = 76;
int EtatDC6;
int EtatDZA6;
int EtatCARRE6;
int FeuRouge6;
unsigned long Tempo6 = 0;
unsigned long PreviousTempo6 = 0;
int Pousse6;
int EtatRC6ZCNR;
int EtatRC6ZC0V;
unsigned long TimeDC6L = 0;          // Time où est détecté 1 train dans la zone Canton
unsigned long TimeDZA6L = 0;         // Time où est détecté 1 train dans la zone Arret
unsigned long TimeDC6ML = 0;         // Mis en mémoire du temps où a été  détecté 1 train dans la zone Canton
unsigned long TimeDZA6ML = 0;        // Mis en mémoire du temps où a été  détecté 1 train dans la zone Arret
int I6DC;                            // Permet de de mémoriser l'état de la zone Canton, 6 utilisée que pour le calcul de la pousse
int I6DZA;                           // Permet de de mémoriser l'état de la zone Arret, 6 utilisée que pour le calcul de la pousse
int TZC6;                            // Mémoire d'activation de la tempo ZC du canton
unsigned long TempoZC6 = 0;          // 6 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZC6 = 0;  // 6 de mise mémoire du temps après la fin d'occupation de la zC
int TZA6;                            // Mémoire d'activation de la tempo ZA du canton
unsigned long TempoZA6 = 0;          // 6 servant au calcul de la tempo de de maintien de la ZC à l'état occupée
unsigned long PreviousTempoZA6 = 0;  // 6 de mise mémoire du temps après la fin d'occupation de la zC
int EtatFeuOrange6;
int StockEtatDC6;   // Mémorisation de l'état de la 6 pour remettre la valeur  initiale à la fin du travail
int StockEtatDZA6;  // Mémorisation de l'état de la 6 pour remettre la valeur  initiale à la fin du travail



void setup() {
  // put your setup code here, to run once:

  Serial.begin(9600);  // init impression ecran
  Serial1.begin(250000);


  pinMode(PosiAig1, INPUT_PULLUP);
  pinMode(PosiAig2, INPUT_PULLUP);
  pinMode(PosiAig3, INPUT_PULLUP);
  pinMode(PosiAig4, INPUT_PULLUP);

  pinMode(LedZC1, OUTPUT);
  pinMode(LedZA1, OUTPUT);
  pinMode(LedZC2, OUTPUT);
  pinMode(LedZA2, OUTPUT);

  pinMode(SortieZC1, OUTPUT);
  pinMode(SortieZA1, OUTPUT);
  pinMode(SortieZC2, OUTPUT);
  pinMode(SortieZA2, OUTPUT);

  pinMode(LedZC9, OUTPUT);
  pinMode(LedZA9, OUTPUT);
  pinMode(LedZC10, OUTPUT);
  pinMode(LedZA10, OUTPUT);

  TimeI2CMini = 300000;
  TimeI2CMaxi = 300100;

  // Canton C1 -      Pleine voie ou Garage
  pinMode(RC1ZCNR, OUTPUT);
  pinMode(RC1ZC0V, OUTPUT);
  pinMode(DC1, INPUT_PULLUP);
  pinMode(DZA1, INPUT_PULLUP);
  pinMode(CARRE1, INPUT_PULLUP);
  digitalWrite(RC1ZCNR, LOW);
  digitalWrite(RC1ZC0V, LOW);
  FeuRouge1 = 1;  // mise à l'état 1 -- initialisation des cantons au feu vert
  Pousse1 = 0;    // pousse inactive
  EtatRC1ZCNR = 0;
  EtatFeuOrange1 = 1;
  EtatRC1ZC0V = 0;
  I1DC = 0;
  I1DZA = 0;
  TZC1 = 1;
  TZA1 = 1;


  // Canton C2 -      Pleine voie ou Garage
  pinMode(RC2ZCNR, OUTPUT);
  pinMode(RC2ZC0V, OUTPUT);
  pinMode(DC2, INPUT_PULLUP);
  pinMode(DZA2, INPUT_PULLUP);
  pinMode(CARRE2, INPUT_PULLUP);
  digitalWrite(RC2ZCNR, LOW);
  digitalWrite(RC2ZC0V, LOW);
  FeuRouge2 = 1;  // mise à l'état 1 -- initialisation des cantons au feu vert
  Pousse2 = 0;    // pousse inactive
  EtatRC2ZCNR = 0;
  EtatFeuOrange2 = 1;
  EtatRC2ZC0V = 0;
  I2DC = 0;
  I2DZA = 0;
  TZC2 = 1;
  TZA2 = 1;


  // Canton C3 -      Pleine voie ou Garage
  pinMode(RC3ZCNR, OUTPUT);
  pinMode(RC3ZC0V, OUTPUT);
  pinMode(DC3, INPUT_PULLUP);
  pinMode(DZA3, INPUT_PULLUP);
  pinMode(CARRE3, INPUT_PULLUP);
  digitalWrite(RC3ZCNR, LOW);
  digitalWrite(RC3ZC0V, LOW);
  FeuRouge3 = 1;  // mise à l'état 1 -- initialisation des cantons au feu vert
  Pousse3 = 0;    // pousse inactive
  EtatRC3ZCNR = 0;
  EtatFeuOrange3 = 1;
  EtatRC3ZC0V = 0;
  I3DC = 0;
  I3DZA = 0;
  TZC3 = 1;
  TZA3 = 1;


  // Canton C4 -      Pleine voie ou Garage
  pinMode(RC4ZCNR, OUTPUT);
  pinMode(RC4ZC0V, OUTPUT);
  pinMode(DC4, INPUT_PULLUP);
  pinMode(DZA4, INPUT_PULLUP);
  pinMode(CARRE4, INPUT_PULLUP);
  digitalWrite(RC4ZCNR, LOW);
  digitalWrite(RC4ZC0V, LOW);
  FeuRouge4 = 1;  // mise à l'état 1 -- initialisation des cantons au feu vert
  Pousse4 = 0;    // pousse inactive
  EtatRC4ZCNR = 0;
  EtatFeuOrange4 = 1;
  EtatRC4ZC0V = 0;
  I4DC = 0;
  I4DZA = 0;
  TZC4 = 1;
  TZA4 = 1;


  // Canton C5 -      Pleine voie ou Garage
  pinMode(RC5ZCNR, OUTPUT);
  pinMode(RC5ZC0V, OUTPUT);
  pinMode(DC5, INPUT_PULLUP);
  pinMode(DZA5, INPUT_PULLUP);
  pinMode(CARRE5, INPUT_PULLUP);
  digitalWrite(RC5ZCNR, LOW);
  digitalWrite(RC5ZC0V, LOW);
  FeuRouge5 = 1;  // mise à l'état 1 -- initialisation des cantons au feu vert
  Pousse5 = 0;    // pousse inactive
  EtatRC5ZCNR = 0;
  EtatFeuOrange5 = 1;
  EtatRC5ZC0V = 0;
  I5DC = 0;
  I5DZA = 0;
  TZC5 = 1;
  TZA5 = 1;


  // Canton C6 -      Pleine voie ou Garage
  pinMode(RC6ZCNR, OUTPUT);
  pinMode(RC6ZC0V, OUTPUT);
  pinMode(DC6, INPUT_PULLUP);
  pinMode(DZA6, INPUT_PULLUP);
  pinMode(CARRE6, INPUT_PULLUP);
  digitalWrite(RC6ZCNR, LOW);
  digitalWrite(RC6ZC0V, LOW);
  FeuRouge6 = 1;  // mise à l'état 1 -- initialisation des cantons au feu vert
  Pousse6 = 0;    // pousse inactive
  EtatRC6ZCNR = 0;
  EtatFeuOrange6 = 1;
  EtatRC6ZC0V = 0;
  I6DC = 0;
  I6DZA = 0;
  TZC6 = 1;
  TZA6 = 1;
}

void loop() {
  Serial.flush();  // effacement message ecran
                   //Serial.println("------Début de Boucle------");

  // Valeurs pour affichage des 1s et des commentaires
  // 0 = pas d'affiche, 1 = affichage des 1s

  Affichage = 0;   // Affichage ZC, ZA, carré, Feu
  Affichage1 = 0;  // Affichage de la Pousse dans le canton
  Affichage2 = 0;  // Affichage de l'etat des relais
  Affichage3 = 0;  // Affichage des tempos de redémarrage
  if (Affichage == 1) {
    Serial.println(" ");
  } else {
  }
  if (Affichage2 == 1) {
    Serial.print("EtatRC1ZCNR = ");
    Serial.print(EtatRC1ZCNR);
    Serial.println("       ||       0 = Normal      1 = Ralenti ");
    Serial.print("EtatRC1ZC0V = ");
    Serial.print(EtatRC1ZC0V);
    Serial.println("       ||       0 = 12V         1 = 0V ");
    Serial.println();
    Serial.print("EtatRC2ZCNR = ");
    Serial.print(EtatRC2ZCNR);
    Serial.println("       ||       0 = Normal      1 = Ralenti ");
    Serial.print("EtatRC2ZC0V = ");
    Serial.print(EtatRC2ZC0V);
    Serial.println("       ||       0 = 12V         1 = 0V ");
    Serial.println();  // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.print("EtatRC3ZCNR = ");
    Serial.print(EtatRC3ZCNR);
    Serial.println("       ||       0 = Normal      1 = Ralenti ");  // Ligne à supprimer en fonction du Nb de cantons programmés;
    Serial.print("EtatRC3ZC0V = ");
    Serial.print(EtatRC3ZC0V);
    Serial.println("       ||       0 = 12V         1 = 0V ");  // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.println();                                           // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.print("EtatRC4ZCNR = ");
    Serial.print(EtatRC4ZCNR);
    Serial.println("       ||       0 = Normal      1 = Ralenti ");  // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.print("EtatRC4ZC0V = ");
    Serial.print(EtatRC4ZC0V);
    Serial.println("       ||       0 = 12V         1 = 0V ");  // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.println();                                           // Ligne à supprimer en fonction du Nb de cantons programmés   // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.print("EtatRC5ZCNR = ");
    Serial.print(EtatRC5ZCNR);
    Serial.println("       ||       0 = Normal      1 = Ralenti ");  // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.print("EtatRC5ZC0V = ");
    Serial.print(EtatRC5ZC0V);
    Serial.println("       ||       0 = 12V         1 = 0V ");  // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.println();                                           // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.print("EtatRC6ZCNR = ");
    Serial.print(EtatRC6ZCNR);
    Serial.println("       ||       0 = Normal      1 = Ralenti ");  // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.print("EtatRC6ZC0V = ");
    Serial.print(EtatRC6ZC0V);
    Serial.println("       ||       0 = 12V         1 = 0V ");  // Ligne à supprimer en fonction du Nb de cantons programmés
    Serial.println("-----------------------");
  } else {
  }
  EtatPosiAig1 = digitalRead(PosiAig1);
  EtatPosiAig2 = digitalRead(PosiAig2);
  EtatPosiAig3 = digitalRead(PosiAig3);
  EtatPosiAig4 = digitalRead(PosiAig4);
  if (Affichage == 1) {
    Serial.print("EtatPosiAig1=");
    Serial.println(EtatPosiAig1);
  } else {
  }
  if (Affichage == 1) {
    Serial.print("EtatPosiAig2=");
    Serial.println(EtatPosiAig2);
  } else {
  }
  if (Affichage == 1) {
    Serial.print("EtatPosiAig3=");
    Serial.println(EtatPosiAig3);
  } else {
  }
  if (Affichage == 1) {
    Serial.print("EtatPosiAig4=");
    Serial.println(EtatPosiAig4);
  } else {
  }
  if (Affichage == 1) { Serial.println("-----------------------"); }

  // Ré initialisation du BUS I2C toutes les 5 minutes  (300 000 ms) ============================================











  //==================================================================


  // Canton 1      ***************************************     Pleine voie    *******************************************************
  EtatDC1 = digitalRead(DC1);
  TempoZC1 = millis();
  if (TZC1 == 1) {
    PreviousTempoZC1 = millis();
  } else {
  }
  if (EtatDC1 == LOW)  // Zone détectée
  {
    if ((TempoZC1 - PreviousTempoZC1) < 2000) {
      EtatDC1 = LOW;
      TZC1 = 0;
    } else {
      EtatDC1 = LOW;
      PreviousTempoZC1 = millis();
      TZC1 = 0;
    }
  } else {
    if (TZC1 == 0) {
      if ((TempoZC1 - PreviousTempoZC1) < 4000) {
        EtatDC1 = LOW;
        TZC1 = 0;
      } else {
        PreviousTempoZC1 = millis();
        TZC1 = 1;
      }
    }
  }

  EtatDZA1 = digitalRead(DZA1);

  TempoZA1 = millis();
  if (TZA1 == 1) {
    PreviousTempoZA1 = millis();
  } else {
  }
  if (EtatDZA1 == LOW)  // Zone détectée
  {
    if ((TempoZA1 - PreviousTempoZA1) < 2000) {
      EtatDZA1 = LOW;
      TZA1 = 0;
    }
  } else {
    if (TZA1 == 0) {
      if ((TempoZA1 - PreviousTempoZA1) < 4000) {
        EtatDZA1 = LOW;
        TZA1 = 0;
      } else {
        PreviousTempoZA1 = millis();
        TZA1 = 1;
      }
    }
  }
  EtatCARRE1 = digitalRead(CARRE1);  // lecture de la position de l'interupteur du carré
  if (EtatDC1 == LOW) {
    TimeDC1L = millis();
  } else {
  }
  if (EtatDZA1 == LOW) {
    TimeDZA1L = millis();
  } else {
  }
  TimeDC1L = TimeDC1L / 1000;
  TimeDZA1L = TimeDZA1L / 1000;
  if (EtatDC1 == LOW) {
    (I1DC = I1DC + 1);
  } else {
  }
  if (EtatDZA1 == LOW) {
    (I1DZA = I1DZA + 1);
  } else {
  }

  if (Affichage == 1) {
    Serial.print("EtatDC1 = ");
    Serial.println(EtatDC1);
    Serial.print("EtatDZA1 = ");
    Serial.println(EtatDZA1);
    Serial.print("EtatCARRE1 = ");
    Serial.println(EtatCARRE1);
    Serial.print("FeuRouge1 = ");
    Serial.println(FeuRouge1);
    Serial.println("-----------------------");
  } else {
  }

  StockEtatDC1 = EtatDC1;
  StockEtatDZA1 = EtatDZA1;


  // Canton 2      ***************************************     Pleine voie    *******************************************************
  EtatDC2 = digitalRead(DC2);
  TempoZC2 = millis();
  if (TZC2 == 1) {
    PreviousTempoZC2 = millis();
  } else {
  }
  if (EtatDC2 == LOW)  // Zone détectée
  {
    if ((TempoZC2 - PreviousTempoZC2) < 2000) {
      EtatDC2 = LOW;
      TZC2 = 0;
    } else {
      EtatDC2 = LOW;
      PreviousTempoZC2 = millis();
      TZC2 = 0;
    }
  } else {
    if (TZC2 == 0) {
      if ((TempoZC2 - PreviousTempoZC2) < 4000) {
        EtatDC2 = LOW;
        TZC2 = 0;
      } else {
        PreviousTempoZC2 = millis();
        TZC2 = 1;
      }
    }
  }

  EtatDZA2 = digitalRead(DZA2);

  TempoZA2 = millis();
  if (TZA2 == 1) {
    PreviousTempoZA2 = millis();
  } else {
  }
  if (EtatDZA2 == LOW)  // Zone détectée
  {
    if ((TempoZA2 - PreviousTempoZA2) < 2000) {
      EtatDZA2 = LOW;
      TZA2 = 0;
    }
  } else {
    if (TZA2 == 0) {
      if ((TempoZA2 - PreviousTempoZA2) < 4000) {
        EtatDZA2 = LOW;
        TZA2 = 0;
      } else {
        PreviousTempoZA2 = millis();
        TZA2 = 1;
      }
    }
  }
  EtatCARRE2 = digitalRead(CARRE2);  // lecture de la position de l'interupteur du carré
  if (EtatDC2 == LOW) {
    TimeDC2L = millis();
  } else {
  }
  if (EtatDZA2 == LOW) {
    TimeDZA2L = millis();
  } else {
  }
  TimeDC2L = TimeDC2L / 1000;
  TimeDZA2L = TimeDZA2L / 1000;
  if (EtatDC2 == LOW) {
    (I2DC = I2DC + 1);
  } else {
  }
  if (EtatDZA2 == LOW) {
    (I2DZA = I2DZA + 1);
  } else {
  }

  if (Affichage == 1) {
    Serial.print("EtatDC2 = ");
    Serial.println(EtatDC2);
    Serial.print("EtatDZA2 = ");
    Serial.println(EtatDZA2);
    Serial.print("EtatCARRE2 = ");
    Serial.println(EtatCARRE2);
    Serial.print("FeuRouge2 = ");
    Serial.println(FeuRouge2);
    Serial.println("-----------------------");
  } else {
  }

  StockEtatDC2 = EtatDC2;
  StockEtatDZA2 = EtatDZA2;


  // Canton 3      ***************************************     Garage    *******************************************************
  EtatDC3 = digitalRead(DC3);
  TempoZC3 = millis();
  if (TZC3 == 1) {
    PreviousTempoZC3 = millis();
  } else {
  }
  if (EtatDC3 == LOW)  // Zone détectée
  {
    if ((TempoZC3 - PreviousTempoZC3) < 2000) {
      EtatDC3 = LOW;
      TZC3 = 0;
    } else {
      EtatDC3 = LOW;
      PreviousTempoZC3 = millis();
      TZC3 = 0;
    }
  } else {
    if (TZC3 == 0) {
      if ((TempoZC3 - PreviousTempoZC3) < 4000) {
        EtatDC3 = LOW;
        TZC3 = 0;
      } else {
        PreviousTempoZC3 = millis();
        TZC3 = 1;
      }
    }
  }

  EtatDZA3 = digitalRead(DZA3);

  TempoZA3 = millis();
  if (TZA3 == 1) {
    PreviousTempoZA3 = millis();
  } else {
  }
  if (EtatDZA3 == LOW)  // Zone détectée
  {
    if ((TempoZA3 - PreviousTempoZA3) < 2000) {
      EtatDZA3 = LOW;
      TZA3 = 0;
    }
  } else {
    if (TZA3 == 0) {
      if ((TempoZA3 - PreviousTempoZA3) < 4000) {
        EtatDZA3 = LOW;
        TZA3 = 0;
      } else {
        PreviousTempoZA3 = millis();
        TZA3 = 1;
      }
    }
  }
  EtatCARRE3 = digitalRead(CARRE3);  // lecture de la position de l'interupteur du carré
  if (EtatDC3 == LOW) {
    TimeDC3L = millis();
  } else {
  }
  if (EtatDZA3 == LOW) {
    TimeDZA3L = millis();
  } else {
  }
  TimeDC3L = TimeDC3L / 1000;
  TimeDZA3L = TimeDZA3L / 1000;
  if (EtatDC3 == LOW) {
    (I3DC = I3DC + 1);
  } else {
  }
  if (EtatDZA3 == LOW) {
    (I3DZA = I3DZA + 1);
  } else {
  }

  if (Affichage == 1) {
    Serial.print("EtatDC3 = ");
    Serial.println(EtatDC3);
    Serial.print("EtatDZA3 = ");
    Serial.println(EtatDZA3);
    Serial.print("EtatCARRE3 = ");
    Serial.println(EtatCARRE3);
    Serial.print("FeuRouge3 = ");
    Serial.println(FeuRouge3);
    Serial.println("-----------------------");
  } else {
  }

  StockEtatDC3 = EtatDC3;
  StockEtatDZA3 = EtatDZA3;


  // Canton 4      ***************************************     Pleine voie    *******************************************************
  EtatDC4 = digitalRead(DC4);
  TempoZC4 = millis();
  if (TZC4 == 1) {
    PreviousTempoZC4 = millis();
  } else {
  }
  if (EtatDC4 == LOW)  // Zone détectée
  {
    if ((TempoZC4 - PreviousTempoZC4) < 2000) {
      EtatDC4 = LOW;
      TZC4 = 0;
    } else {
      EtatDC4 = LOW;
      PreviousTempoZC4 = millis();
      TZC4 = 0;
    }
  } else {
    if (TZC4 == 0) {
      if ((TempoZC4 - PreviousTempoZC4) < 4000) {
        EtatDC4 = LOW;
        TZC4 = 0;
      } else {
        PreviousTempoZC4 = millis();
        TZC4 = 1;
      }
    }
  }

  EtatDZA4 = digitalRead(DZA4);

  TempoZA4 = millis();
  if (TZA4 == 1) {
    PreviousTempoZA4 = millis();
  } else {
  }
  if (EtatDZA4 == LOW)  // Zone détectée
  {
    if ((TempoZA4 - PreviousTempoZA4) < 2000) {
      EtatDZA4 = LOW;
      TZA4 = 0;
    }
  } else {
    if (TZA4 == 0) {
      if ((TempoZA4 - PreviousTempoZA4) < 4000) {
        EtatDZA4 = LOW;
        TZA4 = 0;
      } else {
        PreviousTempoZA4 = millis();
        TZA4 = 1;
      }
    }
  }
  EtatCARRE4 = digitalRead(CARRE4);  // lecture de la position de l'interupteur du carré
  if (EtatDC4 == LOW) {
    TimeDC4L = millis();
  } else {
  }
  if (EtatDZA4 == LOW) {
    TimeDZA4L = millis();
  } else {
  }
  TimeDC4L = TimeDC4L / 1000;
  TimeDZA4L = TimeDZA4L / 1000;
  if (EtatDC4 == LOW) {
    (I4DC = I4DC + 1);
  } else {
  }
  if (EtatDZA4 == LOW) {
    (I4DZA = I4DZA + 1);
  } else {
  }

  if (Affichage == 1) {
    Serial.print("EtatDC4 = ");
    Serial.println(EtatDC4);
    Serial.print("EtatDZA4 = ");
    Serial.println(EtatDZA4);
    Serial.print("EtatCARRE4 = ");
    Serial.println(EtatCARRE4);
    Serial.print("FeuRouge4 = ");
    Serial.println(FeuRouge4);
    Serial.println("-----------------------");
  } else {
  }

  StockEtatDC4 = EtatDC4;
  StockEtatDZA4 = EtatDZA4;


  // Canton 5      ***************************************     Pleine voie    *******************************************************
  EtatDC5 = digitalRead(DC5);
  TempoZC5 = millis();
  if (TZC5 == 1) {
    PreviousTempoZC5 = millis();
  } else {
  }
  if (EtatDC5 == LOW)  // Zone détectée
  {
    if ((TempoZC5 - PreviousTempoZC5) < 2000) {
      EtatDC5 = LOW;
      TZC5 = 0;
    } else {
      EtatDC5 = LOW;
      PreviousTempoZC5 = millis();
      TZC5 = 0;
    }
  } else {
    if (TZC5 == 0) {
      if ((TempoZC5 - PreviousTempoZC5) < 4000) {
        EtatDC5 = LOW;
        TZC5 = 0;
      } else {
        PreviousTempoZC5 = millis();
        TZC5 = 1;
      }
    }
  }

  EtatDZA5 = digitalRead(DZA5);

  TempoZA5 = millis();
  if (TZA5 == 1) {
    PreviousTempoZA5 = millis();
  } else {
  }
  if (EtatDZA5 == LOW)  // Zone détectée
  {
    if ((TempoZA5 - PreviousTempoZA5) < 2000) {
      EtatDZA5 = LOW;
      TZA5 = 0;
    }
  } else {
    if (TZA5 == 0) {
      if ((TempoZA5 - PreviousTempoZA5) < 4000) {
        EtatDZA5 = LOW;
        TZA5 = 0;
      } else {
        PreviousTempoZA5 = millis();
        TZA5 = 1;
      }
    }
  }
  EtatCARRE5 = digitalRead(CARRE5);  // lecture de la position de l'interupteur du carré
  if (EtatDC5 == LOW) {
    TimeDC5L = millis();
  } else {
  }
  if (EtatDZA5 == LOW) {
    TimeDZA5L = millis();
  } else {
  }
  TimeDC5L = TimeDC5L / 1000;
  TimeDZA5L = TimeDZA5L / 1000;
  if (EtatDC5 == LOW) {
    (I5DC = I5DC + 1);
  } else {
  }
  if (EtatDZA5 == LOW) {
    (I5DZA = I5DZA + 1);
  } else {
  }

  if (Affichage == 1) {
    Serial.print("EtatDC5 = ");
    Serial.println(EtatDC5);
    Serial.print("EtatDZA5 = ");
    Serial.println(EtatDZA5);
    Serial.print("EtatCARRE5 = ");
    Serial.println(EtatCARRE5);
    Serial.print("FeuRouge5 = ");
    Serial.println(FeuRouge5);
    Serial.println("-----------------------");
  } else {
  }

  StockEtatDC5 = EtatDC5;
  StockEtatDZA5 = EtatDZA5;


  // Canton 6      ***************************************     Pleine voie    *******************************************************
  EtatDC6 = digitalRead(DC6);
  TempoZC6 = millis();
  if (TZC6 == 1) {
    PreviousTempoZC6 = millis();
  } else {
  }
  if (EtatDC6 == LOW)  // Zone détectée
  {
    if ((TempoZC6 - PreviousTempoZC6) < 2000) {
      EtatDC6 = LOW;
      TZC6 = 0;
    } else {
      EtatDC6 = LOW;
      PreviousTempoZC6 = millis();
      TZC6 = 0;
    }
  } else {
    if (TZC6 == 0) {
      if ((TempoZC6 - PreviousTempoZC6) < 4000) {
        EtatDC6 = LOW;
        TZC6 = 0;
      } else {
        PreviousTempoZC6 = millis();
        TZC6 = 1;
      }
    }
  }

  EtatDZA6 = digitalRead(DZA6);

  TempoZA6 = millis();
  if (TZA6 == 1) {
    PreviousTempoZA6 = millis();
  } else {
  }
  if (EtatDZA6 == LOW)  // Zone détectée
  {
    if ((TempoZA6 - PreviousTempoZA6) < 2000) {
      EtatDZA6 = LOW;
      TZA6 = 0;
    }
  } else {
    if (TZA6 == 0) {
      if ((TempoZA6 - PreviousTempoZA6) < 4000) {
        EtatDZA6 = LOW;
        TZA6 = 0;
      } else {
        PreviousTempoZA6 = millis();
        TZA6 = 1;
      }
    }
  }
  EtatCARRE6 = digitalRead(CARRE6);  // lecture de la position de l'interupteur du carré
  if (EtatDC6 == LOW) {
    TimeDC6L = millis();
  } else {
  }
  if (EtatDZA6 == LOW) {
    TimeDZA6L = millis();
  } else {
  }
  TimeDC6L = TimeDC6L / 1000;
  TimeDZA6L = TimeDZA6L / 1000;
  if (EtatDC6 == LOW) {
    (I6DC = I6DC + 1);
  } else {
  }
  if (EtatDZA6 == LOW) {
    (I6DZA = I6DZA + 1);
  } else {
  }

  if (Affichage == 1) {
    Serial.print("EtatDC6 = ");
    Serial.println(EtatDC6);
    Serial.print("EtatDZA6 = ");
    Serial.println(EtatDZA6);
    Serial.print("EtatCARRE6 = ");
    Serial.println(EtatCARRE6);
    Serial.print("FeuRouge6 = ");
    Serial.println(FeuRouge6);
    Serial.println("-----------------------");
  } else {
  }

  StockEtatDC6 = EtatDC6;
  StockEtatDZA6 = EtatDZA6;
  Serial.println("---------- Début de boucle -------------");
  Serial1.write("A");


  //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  // Canton 0

  if (EtatDC1 == LOW && I1DC == 1) {
    TimeDC1ML = TimeDC1L;
  } else {
  }

  //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

  // Canton 1     Pleine voie    *********************************************************************************************************



  if (EtatCARRE2 == LOW) {
    EtatFeuOrange1 = LOW;
  } else {
    EtatFeuOrange1 = HIGH;
  }  // Pour forcer le signal à l'Orange

  // Prise en compte que si le canton +1 est une bifurcation
  if (EtatPosiAig1 == HIGH)  // Regarde la position de l'aiguille d'ENTREE, si déviée prend en compte 3 et 3 ALD 3 et 3

  {
    EtatDC3 = EtatDC3;    // prise en compte de l'état de la variable du canton 3 bis dans la variable 3
    EtatDZA3 = EtatDZA3;  // prise en compte de l'état de la variable du canton 3 bis dans la variable 3
  } else {
    EtatDC3 = EtatDC3;    // prise en compte de l'état de la variable du canton 3 dans la variable 3
    EtatDZA3 = EtatDZA3;  // prise en compte de l'état de la variable du canton 3 dans la variable 3
  }





  // if (Affichage == 1) {Serial.println("-------------------------------------------------------------------------------------------------");} else {}
  // if (Affichage == 1) { Serial.print("FeuRouge1 = "); Serial.println(FeuRouge1); } else {}

  if (EtatDZA1 == LOW && I1DZA == 1) {
    TimeDZA1ML = TimeDZA1L;
  } else {
  }
  if (EtatDC2 == LOW && I2DC == 1) {
    TimeDC2ML = TimeDC2L;
  } else {
  }
  if ((EtatDC1 == HIGH) && (EtatDZA1 == HIGH)) {
    I1DC = 0;
    TimeDC1ML = 0;
    I1DZA = 0;
    TimeDZA1ML = 0;
  } else {
  }

  if ((TimeDC1ML < TimeDC2ML) && (I1DC > 0)) {
    Pousse1 = 1;
    goto Lab1;
  } else {
    Pousse1 = 0;
  }  // initialisation de la pousse dans le canton

  if ((TimeDZA1ML < TimeDC2ML) && (I1DZA > 0)) {
    Pousse1 = 1;
    goto Lab1;
  } else {
    Pousse1 = 0;
  }  // initialisation de la pousse dans le canton
  // if (Affichage == 1) {Serial.println("-------------------------------------------------------------------------------------------------");} else {}

Lab1:

  if (Affichage1 == 1) {
    Serial.println("----------------------------------------------------");
  } else {
  }
  if (Affichage1 == 1) {
    Serial.println("Canton 1");
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("Pousse1 = ");
    Serial.println(Pousse1);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDC1ML = ");
    Serial.println(TimeDC1ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDZA1ML = ");
    Serial.println(TimeDZA1ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDC2ML = ");
    Serial.println(TimeDC2ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDZA2ML = ");
    Serial.println(TimeDZA2ML);
  } else {
  }

  if (Affichage1 == 1) {
    Serial.print("I1DC = ");
    Serial.println(I1DC);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("I1DZA = ");
    Serial.println(I1DZA);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("I2DC = ");
    Serial.println(I2DC);
  } else {
  }

  if (EtatDC2 == HIGH && EtatDZA2 == HIGH && EtatDC3 == HIGH && EtatDZA3 == HIGH && EtatCARRE1 == HIGH && EtatFeuOrange1 == HIGH) {
    // Feu vert  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal au Vert

    Serial1.write(22);  // Envoi Code
    Serial.println("Vert");



    if (FeuRouge1 == 0)  // Le FeuRouge1 a été rouge -- La voie principale a été libérée
    {
      // Redemarrage au ralenti pendant 6 secondes puis passage au Normal car le feu a été rouge
      Tempo1 = millis() - PreviousTempo1;
      if (Affichage3 == 1) {
        Serial.print("**************   Tempo1 = ");
        Serial.println(Tempo1);
      } else {
      }

      if (Tempo1 < 6000)  // Valeur de tempo souhaitée au redemarrage
      {


        if (Affichage == 1) {
          Serial.print("millis  = ");
          Serial.println(millis());
          Serial.print("PreviousTempo1 = ");
          Serial.println(PreviousTempo1);
          Serial.print("Tempo1 = ");
          Serial.println(Tempo1);
        } else {
        }

        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse1 == 1 && EtatCARRE1 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC1ZCNR = EtatRC2ZCNR;
          EtatRC1ZC0V = EtatRC2ZC0V;
          digitalWrite(RC1ZCNR, EtatRC1ZCNR);
          digitalWrite(RC1ZC0V, EtatRC1ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 1 en POUSSE 1111111111111111111111111111111111111111");
          } else {
          }
        } else

        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC1ZCNR, HIGH);  // Ralenti actif
          digitalWrite(RC1ZC0V, LOW);   // Voie alimentée
          EtatRC1ZCNR = 1;
          EtatRC1ZC0V = 0;
          if (Affichage1 == 1) {
            Serial.println("Canton 1 pas de  POUSSE 22222222222222222222222222222222222222222");
          } else {
          }
        }
        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

        if (Affichage == 2) {
          Serial.print("Redemarrage 1 ");
          Serial.println("Zones au ralenti ");
        } else {
        }
      }

      else {

        FeuRouge1 = 1;  // remise de la mémoire FeuRouge1 à l'état initial -- Voie principale libérée
      }

      if (Affichage == 2) {
        Serial.print("Feu Vert 1 ");
        Serial.println("Zones au NORMAL");
      } else {
      }
    }  // fin de tempo

    else  // Le FeuRouge1 n'a pas été rouge -- La voie principale est libre
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse1 == 1 && EtatCARRE1 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC1ZCNR = EtatRC2ZCNR;
        EtatRC1ZC0V = EtatRC2ZC0V;
        digitalWrite(RC1ZCNR, EtatRC1ZCNR);
        digitalWrite(RC1ZC0V, EtatRC1ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 1 en POUSSE 555555555555555555555555555555555555555555");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC1ZCNR, LOW);  // Normal actif
        digitalWrite(RC1ZC0V, LOW);  // Voie alimentée
        EtatRC1ZCNR = 0;
        EtatRC1ZC0V = 0;
        if (Affichage1 == 1) {
          Serial.println("Canton 1 pas de  POUSSE 666666666666666666666666666666666666666666666666666");
        } else {
        }
      }
      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
    if (Affichage1 == 1) {
      Serial.print("Feu au VERT 1 ");
      Serial.println("Zones au NORMAL");
    } else {
    }
  }

  else if (EtatDC2 == LOW || EtatDZA2 == LOW || EtatCARRE1 == LOW)  // Présence train dans l'une des zones

  {
    // Feu rouge  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal au Rouge avec ou sans Carré


    if (EtatCARRE1 == LOW) {
      Serial1.write(25);
    } else {
      Serial1.write(23);
    };  // Envoi Code avec ou sans le Carré
    Serial.println("Rouge");


    if (EtatDZA1 == LOW)  // Présence train dans zone d'arret, détection active
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse1 == 1 && EtatCARRE1 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC1ZCNR = EtatRC2ZCNR;
        EtatRC1ZC0V = EtatRC2ZC0V;
        digitalWrite(RC1ZCNR, EtatRC1ZCNR);
        digitalWrite(RC1ZC0V, EtatRC1ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 1 en POUSSE 7777777777777777777777777777777777777777777777777777777777");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC1ZCNR, HIGH);  // Ralenti actif dans zone arret et canton
        digitalWrite(RC1ZC0V, HIGH);  // Voie NON alimentée dans zone arret et canton
        EtatRC1ZCNR = 1;
        EtatRC1ZC0V = 1;
        if (Affichage1 == 1) {
          Serial.println("Canton 1 pas de  POUSSE 88888888888888888888888888888888888888888888888888888888888888");
        } else {
        }
      }

      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

      FeuRouge1 = 0;              // Mise de la mémoire FeuRouge1 à l'état 1 (Actif) -- Voie principale bloquée
      PreviousTempo1 = millis();  // mise en mémoire du temps pour calcul de la tempo
      if (Affichage == 1) {
        Serial.print("FeuRouge1 = ");
        Serial.println(FeuRouge1);
      } else {
      }
      if (Affichage1 == 1) {
        Serial.print("Feu au ROUGE 1 ");
        Serial.println("Zones ARRETEES");
      } else {
      }
    } else  // Pas de train dans zone d'arret
    {
      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse1 == 1 && EtatCARRE1 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC1ZCNR = EtatRC2ZCNR;
        EtatRC1ZC0V = EtatRC2ZC0V;
        digitalWrite(RC1ZCNR, EtatRC1ZCNR);
        digitalWrite(RC1ZC0V, EtatRC1ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 1 en POUSSE 99999999999999999999999999999999999999999999999999999");
        } else {
        }
      } else
      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC1ZCNR, HIGH);  // Ralenti actif dans zone arret et canton
        digitalWrite(RC1ZC0V, LOW);   // Voie alimentée  Pousse1 = 1;
        EtatRC1ZCNR = 1;
        EtatRC1ZC0V = 0;
        FeuRouge1 = 1;  // remise de la mémoire FeuRouge1 à l'état initial -- Voie principale libérée
        if (Affichage1 == 1) {
          Serial.println("Canton 1 pas de POUSSE 10101010101010101010101010101010101010101010");
        } else {
        }
      }

      if (Affichage1 == 1) {
        Serial.print("Feu au ROUGE 1 ");
        Serial.println("Zones au RALENTI");
      } else {
      }

      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
  } else {
    // Feu Orange  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal Orange


    Serial1.write(24);  // Envoi Code
    Serial.println("Orange");


    if (FeuRouge1 == 0)  // Le FeuRouge1 a été rouge -- La voie principale a été libérée
    {
      // Redemarrage au ralenti pendant 6 secondes puis passage au Normal car le feu a été rouge
      Tempo1 = millis() - PreviousTempo1;
      if (Affichage3 == 1) {
        Serial.print("**************   Tempo1 = ");
        Serial.println(Tempo1);
      } else {
      }

      if (Tempo1 < 6000)  // Valeur de tempo souhaitée au redemarrage
      {


        if (Affichage == 1) {
          Serial.print("millis  = ");
          Serial.println(millis());
          Serial.print("PreviousTempo1 = ");
          Serial.println(PreviousTempo1);
          Serial.print("Tempo1 = ");
          Serial.println(Tempo1);
        } else {
        }

        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse1 == 1 && EtatCARRE1 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC1ZCNR = EtatRC2ZCNR;
          EtatRC1ZC0V = EtatRC2ZC0V;
          digitalWrite(RC1ZCNR, EtatRC1ZCNR);
          digitalWrite(RC1ZC0V, EtatRC1ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 1 en POUSSE 1212121212121212121212121212121212121212");
          } else {
          }
        } else

        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC1ZCNR, HIGH);  // Ralenti actif
          digitalWrite(RC1ZC0V, LOW);   // Voie alimentée
          EtatRC1ZCNR = 1;
          EtatRC1ZC0V = 0;
          if (Affichage1 == 1) {
            Serial.println("Canton 1 pas de  POUSSE 131313131313131313131313131313131313131313");
          } else {
          }
        }
        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

        if (Affichage == 2) {
          Serial.print("Redemarrage 1 ");
          Serial.println("Zones au ralenti pendant 5s");
        } else {
        }
      } else

      {

        FeuRouge1 = 1;  // remise de la mémoire FeuRouge1 à l'état initial -- Voie principale libérée
      }

      if (Affichage == 2) {
        Serial.print("Feu Vert 1 ");
        Serial.println("Zones au NORMAL");
      } else {
      }
    }  // fin de tempo

    else  // Le FeuRouge1 n'a pas été rouge -- La voie principale est libre
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse1 == 1 && EtatCARRE1 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC1ZCNR = EtatRC2ZCNR;
        EtatRC1ZC0V = EtatRC2ZC0V;
        digitalWrite(RC1ZCNR, EtatRC1ZCNR);
        digitalWrite(RC1ZC0V, EtatRC1ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 1 en POUSSE 16161616161616161616161616161616161616");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC1ZCNR, LOW);  // Ralenti actif
        digitalWrite(RC1ZC0V, LOW);  // Voie alimentée
        EtatRC1ZCNR = 0;
        EtatRC1ZC0V = 0;
        if (Affichage1 == 1) {
          Serial.println("Canton 1 pas de  POUSSE 171717171717171717171717171717171717171717171717");
        } else {
        }
      }
      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
    if (Affichage1 == 1) {
      Serial.print("Feu ORANGE 1 ");
      Serial.println("Zones au NORMAL");
    } else {
    }
  }

  //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX


  // Canton 2     Pleine voie    *********************************************************************************************************



  if (EtatCARRE3 == LOW) {
    EtatFeuOrange2 = LOW;
  } else {
    EtatFeuOrange2 = HIGH;
  }  // Pour forcer le signal à l'Orange

  // Prise en compte que si le canton +1 est une bifurcation
  if (EtatPosiAig1 == HIGH)  // Regarde la position de l'aiguille d'ENTREE, si déviée prend en compte 4 et 4 ALD 4 et 4

  {
    EtatDC4 = EtatDC4;    // prise en compte de l'état de la variable du canton 4 bis dans la variable 4
    EtatDZA4 = EtatDZA4;  // prise en compte de l'état de la variable du canton 4 bis dans la variable 4
  } else {
    EtatDC4 = EtatDC4;    // prise en compte de l'état de la variable du canton 4 dans la variable 4
    EtatDZA4 = EtatDZA4;  // prise en compte de l'état de la variable du canton 4 dans la variable 4
  }





  // if (Affichage == 1) {Serial.println("-------------------------------------------------------------------------------------------------");} else {}
  // if (Affichage == 1) { Serial.print("FeuRouge2 = "); Serial.println(FeuRouge2); } else {}

  if (EtatDZA2 == LOW && I2DZA == 1) {
    TimeDZA2ML = TimeDZA2L;
  } else {
  }
  if (EtatDC3 == LOW && I3DC == 1) {
    TimeDC3ML = TimeDC3L;
  } else {
  }
  if ((EtatDC2 == HIGH) && (EtatDZA2 == HIGH)) {
    I2DC = 0;
    TimeDC2ML = 0;
    I2DZA = 0;
    TimeDZA2ML = 0;
  } else {
  }

  if ((TimeDC2ML < TimeDC3ML) && (I2DC > 0)) {
    Pousse2 = 1;
    goto Lab2;
  } else {
    Pousse2 = 0;
  }  // initialisation de la pousse dans le canton

  if ((TimeDZA2ML < TimeDC3ML) && (I2DZA > 0)) {
    Pousse2 = 1;
    goto Lab2;
  } else {
    Pousse2 = 0;
  }  // initialisation de la pousse dans le canton
  // if (Affichage == 1) {Serial.println("-------------------------------------------------------------------------------------------------");} else {}

Lab2:

  if (Affichage1 == 1) {
    Serial.println("----------------------------------------------------");
  } else {
  }
  if (Affichage1 == 1) {
    Serial.println("Canton 2");
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("Pousse2 = ");
    Serial.println(Pousse2);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDC2ML = ");
    Serial.println(TimeDC2ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDZA2ML = ");
    Serial.println(TimeDZA2ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDC3ML = ");
    Serial.println(TimeDC3ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDZA3ML = ");
    Serial.println(TimeDZA3ML);
  } else {
  }

  if (Affichage1 == 1) {
    Serial.print("I2DC = ");
    Serial.println(I2DC);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("I2DZA = ");
    Serial.println(I2DZA);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("I3DC = ");
    Serial.println(I3DC);
  } else {
  }

  if (EtatDC3 == HIGH && EtatDZA3 == HIGH && EtatDC4 == HIGH && EtatDZA4 == HIGH && EtatCARRE2 == HIGH && EtatFeuOrange2 == HIGH) {
    // Feu vert  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal au Vert

    Serial1.write(26);  // Envoi Code
    Serial.println("vert");









    if (FeuRouge2 == 0)  // Le FeuRouge1 a été rouge -- La voie principale a été libérée
    {
      // Redemarrage au ralenti pendant 6 secondes puis passage au Normal car le feu a été rouge
      Tempo2 = millis() - PreviousTempo2;
      if (Affichage3 == 1) {
        Serial.print("**************   Tempo2 = ");
        Serial.println(Tempo2);
      } else {
      }

      if (Tempo2 < 6000)  // Valeur de tempo souhaitée au redemarrage
      {


        if (Affichage == 1) {
          Serial.print("millis  = ");
          Serial.println(millis());
          Serial.print("PreviousTempo2 = ");
          Serial.println(PreviousTempo2);
          Serial.print("Tempo2 = ");
          Serial.println(Tempo2);
        } else {
        }

        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse2 == 1 && EtatCARRE2 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC2ZCNR = EtatRC3ZCNR;
          EtatRC2ZC0V = EtatRC3ZC0V;
          digitalWrite(RC2ZCNR, EtatRC2ZCNR);
          digitalWrite(RC2ZC0V, EtatRC2ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 2 en POUSSE 1111111111111111111111111111111111111111");
          } else {
          }
        } else

        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC2ZCNR, HIGH);  // Ralenti actif
          digitalWrite(RC2ZC0V, LOW);   // Voie alimentée
          EtatRC2ZCNR = 1;
          EtatRC2ZC0V = 0;
          if (Affichage1 == 1) {
            Serial.println("Canton 2 pas de  POUSSE 22222222222222222222222222222222222222222");
          } else {
          }
        }
        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

        if (Affichage == 2) {
          Serial.print("Redemarrage 2 ");
          Serial.println("Zones au ralenti ");
        } else {
        }
      }

      else {

        FeuRouge2 = 1;  // remise de la mémoire FeuRouge2 à l'état initial -- Voie principale libérée
      }

      if (Affichage == 2) {
        Serial.print("Feu Vert 2 ");
        Serial.println("Zones au NORMAL");
      } else {
      }
    }  // fin de tempo

    else  // Le FeuRouge2 n'a pas été rouge -- La voie principale est libre
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse2 == 1 && EtatCARRE2 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC2ZCNR = EtatRC3ZCNR;
        EtatRC2ZC0V = EtatRC3ZC0V;
        digitalWrite(RC2ZCNR, EtatRC2ZCNR);
        digitalWrite(RC2ZC0V, EtatRC2ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 2 en POUSSE 555555555555555555555555555555555555555555");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC2ZCNR, LOW);  // Normal actif
        digitalWrite(RC2ZC0V, LOW);  // Voie alimentée
        EtatRC2ZCNR = 0;
        EtatRC2ZC0V = 0;
        if (Affichage1 == 1) {
          Serial.println("Canton 2 pas de  POUSSE 666666666666666666666666666666666666666666666666666");
        } else {
        }
      }
      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
    if (Affichage1 == 1) {
      Serial.print("Feu au VERT 2 ");
      Serial.println("Zones au NORMAL");
    } else {
    }
  }

  else if (EtatDC3 == LOW || EtatDZA3 == LOW || EtatCARRE2 == LOW)  // Présence train dans l'une des zones

  {
    // Feu rouge  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal au Rouge avec ou sans Carré


    if (EtatCARRE2 == LOW) {
      Serial1.write(29);
    } else {
      Serial1.write(27);
    };  // Envoi Code avec ou sans le Carré
    Serial.println("rouge");










    if (EtatDZA2 == LOW)  // Présence train dans zone d'arret, détection active
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse2 == 1 && EtatCARRE2 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC2ZCNR = EtatRC3ZCNR;
        EtatRC2ZC0V = EtatRC3ZC0V;
        digitalWrite(RC2ZCNR, EtatRC2ZCNR);
        digitalWrite(RC2ZC0V, EtatRC2ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 2 en POUSSE 7777777777777777777777777777777777777777777777777777777777");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC2ZCNR, HIGH);  // Ralenti actif dans zone arret et canton
        digitalWrite(RC2ZC0V, HIGH);  // Voie NON alimentée dans zone arret et canton
        EtatRC2ZCNR = 1;
        EtatRC2ZC0V = 1;
        if (Affichage1 == 1) {
          Serial.println("Canton 2 pas de  POUSSE 88888888888888888888888888888888888888888888888888888888888888");
        } else {
        }
      }

      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

      FeuRouge2 = 0;              // Mise de la mémoire FeuRouge1 à l'état 1 (Actif) -- Voie principale bloquée
      PreviousTempo2 = millis();  // mise en mémoire du temps pour calcul de la tempo
      if (Affichage == 1) {
        Serial.print("FeuRouge2 = ");
        Serial.println(FeuRouge2);
      } else {
      }
      if (Affichage1 == 1) {
        Serial.print("Feu au ROUGE 2 ");
        Serial.println("Zones ARRETEES");
      } else {
      }
    } else  // Pas de train dans zone d'arret
    {
      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse2 == 1 && EtatCARRE2 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC2ZCNR = EtatRC3ZCNR;
        EtatRC2ZC0V = EtatRC3ZC0V;
        digitalWrite(RC2ZCNR, EtatRC2ZCNR);
        digitalWrite(RC2ZC0V, EtatRC2ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 2 en POUSSE 99999999999999999999999999999999999999999999999999999");
        } else {
        }
      } else
      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC2ZCNR, HIGH);  // Ralenti actif dans zone arret et canton
        digitalWrite(RC2ZC0V, LOW);   // Voie alimentée  Pousse2 = 1;
        EtatRC2ZCNR = 1;
        EtatRC2ZC0V = 0;
        FeuRouge2 = 1;  // remise de la mémoire FeuRouge2 à l'état initial -- Voie principale libérée
        if (Affichage1 == 1) {
          Serial.println("Canton 2 pas de POUSSE 10101010101010101010101010101010101010101010");
        } else {
        }
      }

      if (Affichage1 == 1) {
        Serial.print("Feu au ROUGE 2 ");
        Serial.println("Zones au RALENTI");
      } else {
      }

      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
  } else {
    // Feu Orange  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal Orange

    Serial1.write(28);

    Serial.println("Orange");









    if (FeuRouge2 == 0)  // Le FeuRouge1 a été rouge -- La voie principale a été libérée
    {
      // Redemarrage au ralenti pendant 6 secondes puis passage au Normal car le feu a été rouge
      Tempo2 = millis() - PreviousTempo2;
      if (Affichage3 == 1) {
        Serial.print("**************   Tempo2 = ");
        Serial.println(Tempo2);
      } else {
      }

      if (Tempo2 < 6000)  // Valeur de tempo souhaitée au redemarrage
      {


        if (Affichage == 1) {
          Serial.print("millis  = ");
          Serial.println(millis());
          Serial.print("PreviousTempo2 = ");
          Serial.println(PreviousTempo2);
          Serial.print("Tempo2 = ");
          Serial.println(Tempo2);
        } else {
        }

        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse2 == 1 && EtatCARRE2 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC2ZCNR = EtatRC3ZCNR;
          EtatRC2ZC0V = EtatRC3ZC0V;
          digitalWrite(RC2ZCNR, EtatRC2ZCNR);
          digitalWrite(RC2ZC0V, EtatRC2ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 2 en POUSSE 1212121212121212121212121212121212121212");
          } else {
          }
        } else

        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC2ZCNR, HIGH);  // Ralenti actif
          digitalWrite(RC2ZC0V, LOW);   // Voie alimentée
          EtatRC2ZCNR = 1;
          EtatRC2ZC0V = 0;
          if (Affichage1 == 1) {
            Serial.println("Canton 2 pas de  POUSSE 131313131313131313131313131313131313131313");
          } else {
          }
        }
        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

        if (Affichage == 2) {
          Serial.print("Redemarrage 2 ");
          Serial.println("Zones au ralenti pendant 5s");
        } else {
        }
      } else

      {

        FeuRouge2 = 1;  // remise de la mémoire FeuRouge2 à l'état initial -- Voie principale libérée
      }

      if (Affichage == 2) {
        Serial.print("Feu Vert 2 ");
        Serial.println("Zones au NORMAL");
      } else {
      }
    }  // fin de tempo

    else  // Le FeuRouge2 n'a pas été rouge -- La voie principale est libre
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse2 == 1 && EtatCARRE2 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC2ZCNR = EtatRC3ZCNR;
        EtatRC2ZC0V = EtatRC3ZC0V;
        digitalWrite(RC2ZCNR, EtatRC2ZCNR);
        digitalWrite(RC2ZC0V, EtatRC2ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 2 en POUSSE 16161616161616161616161616161616161616");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC2ZCNR, LOW);  // Ralenti actif
        digitalWrite(RC2ZC0V, LOW);  // Voie alimentée
        EtatRC2ZCNR = 0;
        EtatRC2ZC0V = 0;
        if (Affichage1 == 1) {
          Serial.println("Canton 2 pas de  POUSSE 171717171717171717171717171717171717171717171717");
        } else {
        }
      }
      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
    if (Affichage1 == 1) {
      Serial.print("Feu ORANGE 2 ");
      Serial.println("Zones au NORMAL");
    } else {
    }
  }

  //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX


  // Canton 3       Garage    *********************************************************************************************************



  if (EtatCARRE4 == LOW) {
    EtatFeuOrange3 = LOW;
  } else {
    EtatFeuOrange3 = HIGH;
  }  // Pour forcer le signal à l'Orange

  // Prise en compte que si le canton +1 est une bifurcation
  if (EtatPosiAig1 == HIGH)  // Regarde la position de l'aiguille N°1, si déviée prend en compte 5 et 5 ALD 5 et 5

  {
    EtatDC5 = EtatDC5;    // prise en compte de l'état de la variable du canton 5 bis dans la variable 5
    EtatDZA5 = EtatDZA5;  // prise en compte de l'état de la variable du canton 5 bis dans la variable 5
  } else {
    EtatDC5 = EtatDC5;    // prise en compte de l'état de la variable du canton 5 dans la variable 5
    EtatDZA5 = EtatDZA5;  // prise en compte de l'état de la variable du canton 5 dans la variable 5
  }





  // if (Affichage == 1) {Serial.println("----------------------");} else {}
  // if (Affichage == 1) { Serial.print("FeuRouge3 = "); Serial.println(FeuRouge3); } else {}

  if (EtatDZA3 == LOW && I3DZA == 1) {
    TimeDZA3ML = TimeDZA3L;
  } else {
  }
  if (EtatDC4 == LOW && I4DC == 1) {
    TimeDC4ML = TimeDC4L;
  } else {
  }
  if ((EtatDC3 == HIGH) && (EtatDZA3 == HIGH)) {
    I3DC = 0;
    TimeDC3ML = 0;
    I3DZA = 0;
    TimeDZA3ML = 0;
  } else {
  }

  if ((TimeDC3ML < TimeDC4ML) && (I3DC > 0)) {
    Pousse3 = 1;
    goto Lab3;
  } else {
    Pousse3 = 0;
  }  // initialisation de la pousse dans le canton

  if ((TimeDZA3ML < TimeDC4ML) && (I3DZA) > 0) {
    Pousse3 = 1;
    goto Lab3;
  } else {
    Pousse3 = 0;
  }  // initialisation de la pousse dans le canton


Lab3:

  if (Affichage1 == 1) {
    Serial.println("----------------------------------------------------");
  } else {
  }
  if (Affichage1 == 1) {
    Serial.println("Canton 3");
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("Pousse3 = ");
    Serial.println(Pousse3);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDC3ML = ");
    Serial.println(TimeDC3ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDZA3ML = ");
    Serial.println(TimeDZA3ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDC4ML = ");
    Serial.println(TimeDC4ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDZA4ML = ");
    Serial.println(TimeDZA4ML);
  } else {
  }

  if (Affichage1 == 1) {
    Serial.print("I3DC = ");
    Serial.println(I3DC);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("I3DZA = ");
    Serial.println(I3DZA);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("I4DC = ");
    Serial.println(I4DC);
  } else {
  }

  if (EtatDC4 == HIGH && EtatDZA4 == HIGH && EtatDC5 == HIGH && EtatDZA5 == HIGH && EtatCARRE3 == HIGH && EtatFeuOrange3 == HIGH) {
    // Feu vert  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF


    if (EtatPosiAig1 == HIGH) {
      Serial1.write(32);
      Serial1.write(58);
    } else {
      Serial1.write(30);
    }  // si aiguille dévié alors Rappel allumé sinon Vert allumé
    Serial.println("vert");


    if (FeuRouge3 == 0)  // Le FeuRouge1 a été rouge -- La voie principale a été libérée
    {
      // Redemarrage au ralenti pendant 6 secondes puis passage au Normal car le feu a été rouge
      Tempo3 = millis() - PreviousTempo3;
      if (Affichage3 == 1) {
        Serial.print("**************   Tempo3 = ");
        Serial.println(Tempo3);
      } else {
      }

      if (Tempo3 < 6000)  // Valeur de tempo souhaitée au redemarrage
      {


        if (Affichage == 1) {
          Serial.print("millis  = ");
          Serial.println(millis());
          Serial.print("PreviousTempo3 = ");
          Serial.println(PreviousTempo3);
          Serial.print("Tempo3 = ");
          Serial.println(Tempo3);
        } else {
        }

        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse3 == 1 && EtatCARRE3 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC3ZCNR = EtatRC4ZCNR;
          EtatRC3ZC0V = EtatRC4ZC0V;
          digitalWrite(RC3ZCNR, EtatRC3ZCNR);
          digitalWrite(RC3ZC0V, EtatRC3ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 3 en POUSSE 1111111111111111111111111111111111111111");
          } else {
          }
        } else

        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC3ZCNR, HIGH);  // Ralenti actif
          digitalWrite(RC3ZC0V, LOW);   // Voie alimentée
          EtatRC3ZCNR = 1;
          EtatRC3ZC0V = 0;
          if (Affichage1 == 1) {
            Serial.println("Canton 3 pas de  POUSSE 22222222222222222222222222222222222222222");
          } else {
          }
        }
        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

        if (Affichage == 2) {
          Serial.print("Redemarrage 3 ");
          Serial.println("Zones au ralenti ");
        } else {
        }
      }

      else {

        FeuRouge3 = 1;  // remise de la mémoire FeuRouge3 à l'état initial -- Voie principale libérée
      }

      if (Affichage == 2) {
        Serial.print("Feu Vert 3 ");
        Serial.println("Zones au NORMAL");
      } else {
      }
    }  // fin de tempo

    else  // Le FeuRouge3 n'a pas été rouge -- La voie principale est libre
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse3 == 1 && EtatCARRE3 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC3ZCNR = EtatRC4ZCNR;
        EtatRC3ZC0V = EtatRC4ZC0V;
        digitalWrite(RC3ZCNR, EtatRC3ZCNR);
        digitalWrite(RC3ZC0V, EtatRC3ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 3 en POUSSE 555555555555555555555555555555555555555555");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC3ZCNR, LOW);  // Normal actif
        digitalWrite(RC3ZC0V, LOW);  // Voie alimentée
        EtatRC3ZCNR = 0;
        EtatRC3ZC0V = 0;
        if (Affichage1 == 1) {
          Serial.println("Canton 3 pas de  POUSSE 666666666666666666666666666666666666666666666666666");
        } else {
        }
      }
      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
    if (Affichage1 == 1) {
      Serial.print("Feu au VERT 3 ");
      Serial.println("Zones au NORMAL");
    } else {
    }
  }

  else if (EtatDC4 == LOW || EtatDZA4 == LOW || EtatCARRE3 == LOW)  // Présence train dans l'une des zones

  {
    // Feu rouge  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal au Rouge


    // Shémaphore et Orange ou Rouge
    if (EtatCARRE3 == HIGH) {
      if (EtatPosiAig1 == HIGH) {
        Serial1.write(58);
      } else {
        Serial1.write(31);
      }
    } else {
      Serial1.write(33);
      Serial1.write(31);
    }
    Serial.println("rouge");

    if (EtatPosiAig1 == HIGH && EtatCARRE3 == HIGH)  // Regarde la position de l'aiguille N°1, si déviée force le ralenti pour entrer dans triage

    {
      digitalWrite(RC3ZCNR, HIGH);  // Ralenti actif dans zone arret et canton
      digitalWrite(RC3ZC0V, LOW);   // Voie alimentée  Pousse5 = 1;
      EtatRC3ZCNR = 1;
      EtatRC3ZC0V = 0;
    } else {
      if (EtatDZA3 == LOW)  // Présence train dans zone d'arret, détection active
      {

        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse3 == 1 && EtatCARRE3 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC3ZCNR = EtatRC4ZCNR;
          EtatRC3ZC0V = EtatRC4ZC0V;
          digitalWrite(RC3ZCNR, EtatRC3ZCNR);
          digitalWrite(RC3ZC0V, EtatRC3ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 3 en POUSSE 7777777777777777777777777777777777777777777777777777777777");
          } else {
          }
        } else

        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC3ZCNR, HIGH);  // Ralenti actif dans zone arret et canton
          digitalWrite(RC3ZC0V, HIGH);  // Voie NON alimentée dans zone arret et canton
          EtatRC3ZCNR = 1;
          EtatRC3ZC0V = 1;
          if (Affichage1 == 1) {
            Serial.println("Canton 3 pas de  POUSSE 88888888888888888888888888888888888888888888888888888888888888");
          } else {
          }
        }

        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

        FeuRouge3 = 0;              // Mise de la mémoire FeuRouge1 à l'état 1 (Actif) -- Voie principale bloquée
        PreviousTempo3 = millis();  // mise en mémoire du temps pour calcul de la tempo
        if (Affichage == 1) {
          Serial.print("FeuRouge3 = ");
          Serial.println(FeuRouge3);
        } else {
        }
        if (Affichage1 == 1) {
          Serial.print("Feu au ROUGE 3 ");
          Serial.println("Zones ARRETEES");
        } else {
        }
      } else  // Pas de train dans zone d'arret
      {
        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse3 == 1 && EtatCARRE3 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC3ZCNR = EtatRC4ZCNR;
          EtatRC3ZC0V = EtatRC4ZC0V;
          digitalWrite(RC3ZCNR, EtatRC3ZCNR);
          digitalWrite(RC3ZC0V, EtatRC3ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 3 en POUSSE 99999999999999999999999999999999999999999999999999999");
          } else {
          }
        } else
        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC3ZCNR, HIGH);  // Ralenti actif dans zone arret et canton
          digitalWrite(RC3ZC0V, LOW);   // Voie alimentée  Pousse3 = 1;
          EtatRC3ZCNR = 1;
          EtatRC3ZC0V = 0;
          FeuRouge3 = 1;  // remise de la mémoire FeuRouge3 à l'état initial -- Voie principale libérée
          if (Affichage1 == 1) {
            Serial.println("Canton 3 pas de POUSSE 10101010101010101010101010101010101010101010");
          } else {
          }
        }

        if (Affichage1 == 1) {
          Serial.print("Feu au ROUGE 3 ");
          Serial.println("Zones au RALENTI");
        } else {
        }

        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
      }
    }
  } else {
    // Feu Orange  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF


    // Shémaphore et Orange
    if (EtatPosiAig1 == HIGH) {
      Serial1.write(58);
    } else {
      Serial1.write(32);
    }

    Serial.println("Orange");







    if (FeuRouge3 == 0)  // Le FeuRouge1 a été rouge -- La voie principale a été libérée
    {
      // Redemarrage au ralenti pendant 6 secondes puis passage au Normal car le feu a été rouge
      Tempo3 = millis() - PreviousTempo3;
      if (Affichage3 == 1) {
        Serial.print("**************   Tempo3 = ");
        Serial.println(Tempo3);
      } else {
      }

      if (Tempo3 < 6000)  // Valeur de tempo souhaitée au redemarrage
      {


        if (Affichage == 1) {
          Serial.print("millis  = ");
          Serial.println(millis());
          Serial.print("PreviousTempo3 = ");
          Serial.println(PreviousTempo3);
          Serial.print("Tempo3 = ");
          Serial.println(Tempo3);
        } else {
        }

        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse3 == 1 && EtatCARRE3 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC3ZCNR = EtatRC4ZCNR;
          EtatRC3ZC0V = EtatRC4ZC0V;
          digitalWrite(RC3ZCNR, EtatRC3ZCNR);
          digitalWrite(RC3ZC0V, EtatRC3ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 3 en POUSSE 1212121212121212121212121212121212121212");
          } else {
          }
        } else

        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC3ZCNR, HIGH);  // Ralenti actif
          digitalWrite(RC3ZC0V, LOW);   // Voie alimentée
          EtatRC3ZCNR = 1;
          EtatRC3ZC0V = 0;
          if (Affichage1 == 1) {
            Serial.println("Canton 3 pas de  POUSSE 131313131313131313131313131313131313131313");
          } else {
          }
        }
        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

        if (Affichage == 2) {
          Serial.print("Redemarrage 3 ");
          Serial.println("Zones au ralenti pendant 5s");
        } else {
        }
      } else

      {

        FeuRouge3 = 1;  // remise de la mémoire FeuRouge3 à l'état initial -- Voie principale libérée
      }

      if (Affichage == 2) {
        Serial.print("Feu Vert 3 ");
        Serial.println("Zones au NORMAL");
      } else {
      }
    }  // fin de tempo

    else  // Le FeuRouge3 n'a pas été rouge -- La voie principale est libre
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse3 == 1 && EtatCARRE3 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC3ZCNR = EtatRC4ZCNR;
        EtatRC3ZC0V = EtatRC4ZC0V;
        digitalWrite(RC3ZCNR, EtatRC3ZCNR);
        digitalWrite(RC3ZC0V, EtatRC3ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 3 en POUSSE 16161616161616161616161616161616161616");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC3ZCNR, LOW);  // Ralenti actif
        digitalWrite(RC3ZC0V, LOW);  // Voie alimentée
        EtatRC3ZCNR = 0;
        EtatRC3ZC0V = 0;
        if (Affichage1 == 1) {
          Serial.println("Canton 3 pas de  POUSSE 171717171717171717171717171717171717171717171717");
        } else {
        }
      }
      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
    if (Affichage1 == 1) {
      Serial.print("Feu ORANGE 3 ");
      Serial.println("Zones au NORMAL");
    } else {
    }
  }

  //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  // Canton 4     Pleine voie    *********************************************************************************************************



  if (EtatCARRE5 == LOW) {
    EtatFeuOrange4 = LOW;
  } else {
    EtatFeuOrange4 = HIGH;
  }  // Pour forcer le signal à l'Orange

  // Prise en compte que si le canton +1 est une bifurcation
  if (EtatPosiAig2 == HIGH)  // Regarde la position de l'aiguille d'ENTREE, si déviée prend en compte 6 et 6 ALD 6 et 6

  {
    EtatDC6 = EtatDC6;    // prise en compte de l'état de la variable du canton 6 bis dans la variable 6
    EtatDZA6 = EtatDZA6;  // prise en compte de l'état de la variable du canton 6 bis dans la variable 6
  } else {
    EtatDC6 = EtatDC6;    // prise en compte de l'état de la variable du canton 6 dans la variable 6
    EtatDZA6 = EtatDZA6;  // prise en compte de l'état de la variable du canton 6 dans la variable 6
  }





  // if (Affichage == 1) {Serial.println("-------------------------------------------------------------------------------------------------");} else {}
  // if (Affichage == 1) { Serial.print("FeuRouge4 = "); Serial.println(FeuRouge4); } else {}

  if (EtatDZA4 == LOW && I4DZA == 1) {
    TimeDZA4ML = TimeDZA4L;
  } else {
  }
  if (EtatDC5 == LOW && I5DC == 1) {
    TimeDC5ML = TimeDC5L;
  } else {
  }
  if ((EtatDC4 == HIGH) && (EtatDZA4 == HIGH)) {
    I4DC = 0;
    TimeDC4ML = 0;
    I4DZA = 0;
    TimeDZA4ML = 0;
  } else {
  }

  if ((TimeDC4ML < TimeDC5ML) && (I4DC > 0)) {
    Pousse4 = 1;
    goto Lab4;
  } else {
    Pousse4 = 0;
  }  // initialisation de la pousse dans le canton

  if ((TimeDZA4ML < TimeDC5ML) && (I4DZA > 0)) {
    Pousse4 = 1;
    goto Lab4;
  } else {
    Pousse4 = 0;
  }  // initialisation de la pousse dans le canton
  // if (Affichage == 1) {Serial.println("-------------------------------------------------------------------------------------------------");} else {}

Lab4:

  if (Affichage1 == 1) {
    Serial.println("----------------------------------------------------");
  } else {
  }
  if (Affichage1 == 1) {
    Serial.println("Canton 4");
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("Pousse4 = ");
    Serial.println(Pousse4);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDC4ML = ");
    Serial.println(TimeDC4ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDZA4ML = ");
    Serial.println(TimeDZA4ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDC5ML = ");
    Serial.println(TimeDC5ML);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("TimeDZA5ML = ");
    Serial.println(TimeDZA5ML);
  } else {
  }

  if (Affichage1 == 1) {
    Serial.print("I4DC = ");
    Serial.println(I4DC);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("I4DZA = ");
    Serial.println(I4DZA);
  } else {
  }
  if (Affichage1 == 1) {
    Serial.print("I5DC = ");
    Serial.println(I5DC);
  } else {
  }

  if (EtatDC5 == HIGH && EtatDZA5 == HIGH && EtatDC6 == HIGH && EtatDZA6 == HIGH && EtatCARRE4 == HIGH && EtatFeuOrange4 == HIGH) {
    // Feu vert  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal au Vert


    Serial1.write(34);  // Envoi Code
    Serial.println("vert");









    if (FeuRouge4 == 0)  // Le FeuRouge1 a été rouge -- La voie principale a été libérée
    {
      // Redemarrage au ralenti pendant 6 secondes puis passage au Normal car le feu a été rouge
      Tempo4 = millis() - PreviousTempo4;
      if (Affichage3 == 1) {
        Serial.print("**************   Tempo4 = ");
        Serial.println(Tempo4);
      } else {
      }

      if (Tempo4 < 6000)  // Valeur de tempo souhaitée au redemarrage
      {


        if (Affichage == 1) {
          Serial.print("millis  = ");
          Serial.println(millis());
          Serial.print("PreviousTempo4 = ");
          Serial.println(PreviousTempo4);
          Serial.print("Tempo4 = ");
          Serial.println(Tempo4);
        } else {
        }

        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse4 == 1 && EtatCARRE4 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC4ZCNR = EtatRC5ZCNR;
          EtatRC4ZC0V = EtatRC5ZC0V;
          digitalWrite(RC4ZCNR, EtatRC4ZCNR);
          digitalWrite(RC4ZC0V, EtatRC4ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 4 en POUSSE 1111111111111111111111111111111111111111");
          } else {
          }
        } else

        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC4ZCNR, HIGH);  // Ralenti actif
          digitalWrite(RC4ZC0V, LOW);   // Voie alimentée
          EtatRC4ZCNR = 1;
          EtatRC4ZC0V = 0;
          if (Affichage1 == 1) {
            Serial.println("Canton 4 pas de  POUSSE 22222222222222222222222222222222222222222");
          } else {
          }
        }
        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

        if (Affichage == 2) {
          Serial.print("Redemarrage 4 ");
          Serial.println("Zones au ralenti ");
        } else {
        }
      }

      else {

        FeuRouge4 = 1;  // remise de la mémoire FeuRouge4 à l'état initial -- Voie principale libérée
      }

      if (Affichage == 2) {
        Serial.print("Feu Vert 4 ");
        Serial.println("Zones au NORMAL");
      } else {
      }
    }  // fin de tempo

    else  // Le FeuRouge4 n'a pas été rouge -- La voie principale est libre
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse4 == 1 && EtatCARRE4 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC4ZCNR = EtatRC5ZCNR;
        EtatRC4ZC0V = EtatRC5ZC0V;
        digitalWrite(RC4ZCNR, EtatRC4ZCNR);
        digitalWrite(RC4ZC0V, EtatRC4ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 4 en POUSSE 555555555555555555555555555555555555555555");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC4ZCNR, LOW);  // Normal actif
        digitalWrite(RC4ZC0V, LOW);  // Voie alimentée
        EtatRC4ZCNR = 0;
        EtatRC4ZC0V = 0;
        if (Affichage1 == 1) {
          Serial.println("Canton 4 pas de  POUSSE 666666666666666666666666666666666666666666666666666");
        } else {
        }
      }
      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
    if (Affichage1 == 1) {
      Serial.print("Feu au VERT 4 ");
      Serial.println("Zones au NORMAL");
    } else {
    }
  }

  else if (EtatDC5 == LOW || EtatDZA5 == LOW || EtatCARRE4 == LOW)  // Présence train dans l'une des zones

  {
    // Feu rouge  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal au Rouge avec ou sans Carré


    if (EtatCARRE4 == LOW) {
      Serial1.write("35");
      Serial1.write("37");
    } else {
      Serial1.write("35");
    };  // Envoi Code avec ou sans le Carré

    Serial.println("rouge");








    if (EtatDZA4 == LOW)  // Présence train dans zone d'arret, détection active
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse4 == 1 && EtatCARRE4 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC4ZCNR = EtatRC5ZCNR;
        EtatRC4ZC0V = EtatRC5ZC0V;
        digitalWrite(RC4ZCNR, EtatRC4ZCNR);
        digitalWrite(RC4ZC0V, EtatRC4ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 4 en POUSSE 7777777777777777777777777777777777777777777777777777777777");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC4ZCNR, HIGH);  // Ralenti actif dans zone arret et canton
        digitalWrite(RC4ZC0V, HIGH);  // Voie NON alimentée dans zone arret et canton
        EtatRC4ZCNR = 1;
        EtatRC4ZC0V = 1;
        if (Affichage1 == 1) {
          Serial.println("Canton 4 pas de  POUSSE 88888888888888888888888888888888888888888888888888888888888888");
        } else {
        }
      }

      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

      FeuRouge4 = 0;              // Mise de la mémoire FeuRouge1 à l'état 1 (Actif) -- Voie principale bloquée
      PreviousTempo4 = millis();  // mise en mémoire du temps pour calcul de la tempo
      if (Affichage == 1) {
        Serial.print("FeuRouge4 = ");
        Serial.println(FeuRouge4);
      } else {
      }
      if (Affichage1 == 1) {
        Serial.print("Feu au ROUGE 4 ");
        Serial.println("Zones ARRETEES");
      } else {
      }
    } else  // Pas de train dans zone d'arret
    {
      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse4 == 1 && EtatCARRE4 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC4ZCNR = EtatRC5ZCNR;
        EtatRC4ZC0V = EtatRC5ZC0V;
        digitalWrite(RC4ZCNR, EtatRC4ZCNR);
        digitalWrite(RC4ZC0V, EtatRC4ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 4 en POUSSE 99999999999999999999999999999999999999999999999999999");
        } else {
        }
      } else
      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC4ZCNR, HIGH);  // Ralenti actif dans zone arret et canton
        digitalWrite(RC4ZC0V, LOW);   // Voie alimentée  Pousse4 = 1;
        EtatRC4ZCNR = 1;
        EtatRC4ZC0V = 0;
        FeuRouge4 = 1;  // remise de la mémoire FeuRouge4 à l'état initial -- Voie principale libérée
        if (Affichage1 == 1) {
          Serial.println("Canton 4 pas de POUSSE 10101010101010101010101010101010101010101010");
        } else {
        }
      }

      if (Affichage1 == 1) {
        Serial.print("Feu au ROUGE 4 ");
        Serial1.write(35);
      } else {
      }

      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
  } else {
    // Feu Orange  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

    //Allumage du signal Orange



    Serial1.write("36");
    Serial.println("Orange");









    if (FeuRouge4 == 0)  // Le FeuRouge1 a été rouge -- La voie principale a été libérée
    {
      // Redemarrage au ralenti pendant 6 secondes puis passage au Normal car le feu a été rouge
      Tempo4 = millis() - PreviousTempo4;
      if (Affichage3 == 1) {
        Serial.print("**************   Tempo4 = ");
        Serial.println(Tempo4);
      } else {
      }

      if (Tempo4 < 6000)  // Valeur de tempo souhaitée au redemarrage
      {


        if (Affichage == 1) {
          Serial.print("millis  = ");
          Serial.println(millis());
          Serial.print("PreviousTempo4 = ");
          Serial.println(PreviousTempo4);
          Serial.print("Tempo4 = ");
          Serial.println(Tempo4);
        } else {
        }

        // Début Rajout pour POUSSE ----------------------------------------------------------------------------
        if (Pousse4 == 1 && EtatCARRE4 == HIGH) {
          // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
          EtatRC4ZCNR = EtatRC5ZCNR;
          EtatRC4ZC0V = EtatRC5ZC0V;
          digitalWrite(RC4ZCNR, EtatRC4ZCNR);
          digitalWrite(RC4ZC0V, EtatRC4ZC0V);
          if (Affichage1 == 1) {
            Serial.println("Canton 4 en POUSSE 1212121212121212121212121212121212121212");
          } else {
          }
        } else

        // Pas de POUSSE DETECTEE
        {
          digitalWrite(RC4ZCNR, HIGH);  // Ralenti actif
          digitalWrite(RC4ZC0V, LOW);   // Voie alimentée
          EtatRC4ZCNR = 1;
          EtatRC4ZC0V = 0;
          if (Affichage1 == 1) {
            Serial.println("Canton 4 pas de  POUSSE 131313131313131313131313131313131313131313");
          } else {
          }
        }
        // Fin Rajout pour POUSSE ----------------------------------------------------------------------------

        if (Affichage == 2) {
          Serial.print("Redemarrage 4 ");
          Serial.println("Zones au ralenti pendant 5s");
        } else {
        }
      } else

      {

        FeuRouge4 = 1;  // remise de la mémoire FeuRouge4 à l'état initial -- Voie principale libérée
      }

      if (Affichage == 2) {
        Serial.print("Feu Vert 4 ");
        Serial.println("Zones au NORMAL");
      } else {
      }
    }  // fin de tempo

    else  // Le FeuRouge4 n'a pas été rouge -- La voie principale est libre
    {

      // Début Rajout pour POUSSE ----------------------------------------------------------------------------
      if (Pousse4 == 1 && EtatCARRE4 == HIGH) {
        // mise à la même alimentation le canton + le canton précédant car POUSSE DETECTEE
        EtatRC4ZCNR = EtatRC5ZCNR;
        EtatRC4ZC0V = EtatRC5ZC0V;
        digitalWrite(RC4ZCNR, EtatRC4ZCNR);
        digitalWrite(RC4ZC0V, EtatRC4ZC0V);
        if (Affichage1 == 1) {
          Serial.println("Canton 4 en POUSSE 16161616161616161616161616161616161616");
        } else {
        }
      } else

      // Pas de POUSSE DETECTEE
      {
        digitalWrite(RC4ZCNR, LOW);  // Ralenti actif
        digitalWrite(RC4ZC0V, LOW);  // Voie alimentée
        EtatRC4ZCNR = 0;
        EtatRC4ZC0V = 0;
        if (Affichage1 == 1) {
          Serial.println("Canton 4 pas de  POUSSE 171717171717171717171717171717171717171717171717");
        } else {
        }
      }
      // Fin Rajout pour POUSSE ----------------------------------------------------------------------------
    }
    if (Affichage1 == 1) {
      Serial.print("Feu ORANGE 4 ");
      Serial.println("Zones au NORMAL");
    } else {
    }
  }

  //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX


  // Canton 5

  if (EtatDZA5 == LOW && I5DZA == 1) {
    TimeDZA5ML = TimeDZA5L;
  } else {
  }
  if (EtatDC6 == LOW && I6DC == 1) {
    TimeDC6ML = TimeDC6L;
  } else {
  }
  if ((EtatDC5 == HIGH) && (EtatDZA5 == HIGH)) {
    I5DC = 0;
    TimeDC5ML = 0;
    I5DZA = 0;
    TimeDZA5ML = 0;
  } else {
  }  // donc le canton est vide, les 2 zones ne sont pas occupées

  // Pour Visualisation de ZC9 et ZA9

  if (EtatDC5 == 0) {
    digitalWrite(LedZC9, LOW);
  } else {
    digitalWrite(LedZC9, HIGH);
  }
  if (EtatDZA5 == 0) {
    digitalWrite(LedZA9, LOW);
  } else {
    digitalWrite(LedZA9, HIGH);
  }

  if (EtatDC6 == 0) {
    digitalWrite(LedZC10, LOW);
  } else {
    digitalWrite(LedZC10, HIGH);
  }
  if (EtatDZA6 == 0) {
    digitalWrite(LedZA10, LOW);
  } else {
    digitalWrite(LedZA10, HIGH);
  }

  if (EtatDC1 == 0) {
    digitalWrite(LedZC1, LOW);
  } else {
    digitalWrite(LedZC1, HIGH);
  }
  if (EtatDZA1 == 0) {
    digitalWrite(LedZA1, LOW);
  } else {
    digitalWrite(LedZA1, HIGH);
  }

  if (EtatDC2 == 0) {
    digitalWrite(LedZC2, LOW);
  } else {
    digitalWrite(LedZC2, HIGH);
  }
  if (EtatDZA2 == 0) {
    digitalWrite(LedZA2, LOW);
  } else {
    digitalWrite(LedZA2, HIGH);
  }

  if (EtatDC1 == 0) {
    digitalWrite(SortieZC1, LOW);
  } else {
    digitalWrite(SortieZC1, HIGH);
  }
  if (EtatDZA1 == 0) {
    digitalWrite(SortieZA1, LOW);
  } else {
    digitalWrite(SortieZA1, HIGH);
  }

  if (EtatDC2 == 0) {
    digitalWrite(SortieZC2, LOW);
  } else {
    digitalWrite(SortieZC2, HIGH);
  }
  if (EtatDZA2 == 0) {
    digitalWrite(SortieZA2, LOW);
  } else {
    digitalWrite(SortieZA2, HIGH);
  }

  /*
Serial.print("EtatDC1 = "); Serial.println(EtatDC1);
Serial.print("EtatDZA1 = "); Serial.println(EtatDZA1);
Serial.print("EtatDC2 = "); Serial.println(EtatDC2);
Serial.print("EtatDZA2 = "); Serial.println(EtatDZA2);

Serial.print("EtatDC5 = "); Serial.println(EtatDC5);
Serial.print("EtatDZA5 = "); Serial.println(EtatDZA5);
Serial.print("EtatDC6 = "); Serial.println(EtatDC6);
Serial.print("EtatDZA6 = "); Serial.println(EtatDZA6);

 Serial.print("SortieZC1 = "); Serial.println(SortieZC1);
Serial.print("SortieZA1 = "); Serial.println(SortieZA1);
Serial.print("SortieZC2 = "); Serial.println(SortieZC2);
Serial.print("SortieZA2 = "); Serial.println(SortieZA2);
*/
}

// ******************************************** Fin de Programme ***********************************************

Carte réceptrice

// Prog Escalave Universel pour allumage Signaux LED slave #1  - Version 22/02/25

int CodeRecu = 0;
int x = 0; //code reçu lu
int i = 0;

int C1 = 0;
int C2 = 0;
int C3 = 0;
int C4 = 0;
int C5 = 0;
int C6 = 0;
int C7 = 0;
int C8 = 0;

int watchdogTime = 2500;
int counter =0;

// Canton 1
int D54 = 54; // Sémaphore Orange
int D55 = 55; // Sémaphore Orange
int D25 = 25; // Carré Rouge
int D22 = 22; // Vert
int D23 = 23; // Rouge
int D24 = 24; // Jaune
int D2 = 2; // ZC1
int D3 = 3; // ZA1

// Canton 2
const int D56 = 56; // Sémaphore Orange
const int D57 = 57; // Sémaphore Orange
const int D29 = 29; // Carré Rouge
const int D26 = 26; // Vert
const int D27 = 27; // Rouge
const int D28 = 28; // Jaune
const int D4 = 4; // ZC2
const int D5 = 5; // ZA2

// Canton 3
const int D58 = 58; // Sémaphore Orange
const int D59 = 59; // Sémaphore Orange
const int D33 = 33; // Carré Rouge
const int D30 = 30; // Vert
const int D31 = 31; // Rouge
const int D32 = 32; // Jaune
const int D6 = 6; // ZC3
const int D7 = 7; // ZA3

// Canton 4
const int D60 = 60; // Sémaphore Orange
const int D61 = 61; // Sémaphore Orange
const int D37 = 37; // Carré Rouge
const int D34 = 34; // Vert
const int D35 = 35; // Rouge
const int D36 = 36; // Jaune
const int D8 = 8; // ZC4
const int D9 = 9; // ZA4

// Canton 5
const int D62 = 62; // Sémaphore Orange
const int D63 = 63; // Sémaphore Orange
const int D41 = 41; // Carré Rouge
const int D38 = 38; // Vert
const int D39 = 39; // Rouge
const int D40 = 40; // Jaune
const int D10 = 10; // ZC5
const int D11 = 11; // ZA5

// Canton 6
const int D64 = 64; // Sémaphore Orange
const int D65 = 65; // Sémaphore Orange
const int D45 = 45; // Carré Rouge
const int D42 = 42; // Vert
const int D43 = 43; // Rouge
const int D44 = 44; // Jaune
const int D12 = 12;  // ZC6
const int D14 = 14;  // ZA6

// Canton 7
const int D66 = 66; // Sémaphore Orange
const int D67 = 67; // Sémaphore Orange
const int D49 = 49; // Carré Rouge
const int D46 = 46; // Vert
const int D47 = 47; // Rouge
const int D48 = 48; // Jaune
const int D15 = 15;  // ZC7
const int D16 = 16;  // ZA7

// Canton 8
const int D68 = 68; // Sémaphore Orange
const int D69 = 69; // Sémaphore Orange
const int D53 = 53; // Carré Rouge
const int D50 = 50; // Vert
const int D51 = 51; // Rouge
const int D52 = 52; // Jaune
const int D17 = 17;  // ZC8
const int D20 = 20;  // ZA8
/*
void watchdogSetup(void) 
{
// do what you want here
}
*/

void setup()
{

Serial.begin(9600); // Demarrer la liaison serie avec le PC -- ATTENTION LA FONCTION BLOQUE LE BUS
Serial1.begin(250000);

//watchdogEnable(watchdogTime);

pinMode(D54, OUTPUT); 
pinMode(D55, OUTPUT); 
pinMode(D2, OUTPUT); 
pinMode(D3, OUTPUT); 
pinMode(D22, OUTPUT); 
pinMode(D23, OUTPUT);   
pinMode(D24, OUTPUT);   
pinMode(D25, OUTPUT);   

pinMode(D2, OUTPUT); 
pinMode(D3, OUTPUT); 
pinMode(D4, OUTPUT); 
pinMode(D5, OUTPUT); 
pinMode(D6, OUTPUT); 
pinMode(D7, OUTPUT);   
pinMode(D8, OUTPUT);   
pinMode(D8, OUTPUT);   
pinMode(D10, OUTPUT);   
pinMode(D11, OUTPUT);   
pinMode(D12, OUTPUT);   

pinMode(D14, OUTPUT);   
pinMode(D15, OUTPUT);   
pinMode(D15, OUTPUT);   
pinMode(D17, OUTPUT);   
pinMode(D20, OUTPUT);   

pinMode(D22, OUTPUT);   
pinMode(D23, OUTPUT);   
pinMode(D24, OUTPUT);   
pinMode(D25, OUTPUT);   
pinMode(D26, OUTPUT);   
pinMode(D27, OUTPUT);   
pinMode(D28, OUTPUT);   
pinMode(D29, OUTPUT);   
pinMode(D30, OUTPUT);   
pinMode(D31, OUTPUT);   
pinMode(D32, OUTPUT);   
pinMode(D33, OUTPUT);   
pinMode(D34, OUTPUT);   
pinMode(D35, OUTPUT);   
pinMode(D36, OUTPUT);   
pinMode(D37, OUTPUT);   
pinMode(D38, OUTPUT);   
pinMode(D39, OUTPUT);   
pinMode(D40, OUTPUT);   
pinMode(D41, OUTPUT);   
pinMode(D42, OUTPUT);   
pinMode(D43, OUTPUT);   
pinMode(D44, OUTPUT);   
pinMode(D45, OUTPUT);   
pinMode(D46, OUTPUT);   
pinMode(D47, OUTPUT);   
pinMode(D48, OUTPUT);   
pinMode(D49, OUTPUT);   
pinMode(D50, OUTPUT);   
pinMode(D51, OUTPUT);   
pinMode(D52, OUTPUT);   
pinMode(D53, OUTPUT);   

pinMode(D54, OUTPUT);   
pinMode(D55, OUTPUT);   
pinMode(D56, OUTPUT);   
pinMode(D57, OUTPUT);   
pinMode(D58, OUTPUT);   
pinMode(D59, OUTPUT);   
pinMode(D60, OUTPUT);   
pinMode(D61, OUTPUT);   
pinMode(D62, OUTPUT);   
pinMode(D63, OUTPUT);   
pinMode(D64, OUTPUT);   
pinMode(D65, OUTPUT);   
pinMode(D66, OUTPUT);   
pinMode(D67, OUTPUT);   
pinMode(D68, OUTPUT);   
pinMode(D69, OUTPUT);   

//RAZ Canton 1
digitalWrite(D22, LOW);
digitalWrite(D23, LOW);
digitalWrite(D24, LOW);
digitalWrite(D25, LOW);
digitalWrite(D54, LOW);
digitalWrite(D55, LOW);

//RAZ Canton 2
digitalWrite(D26, LOW);
digitalWrite(D27, LOW);
digitalWrite(D28, LOW);
digitalWrite(D29, LOW);
digitalWrite(D56, LOW);
digitalWrite(D57, LOW);

//RAZ Canton 3
digitalWrite(D30, HIGH);
digitalWrite(D31, HIGH);
digitalWrite(D32, HIGH);
digitalWrite(D33, HIGH);
digitalWrite(D58, HIGH);
digitalWrite(D59, HIGH);

//RAZ Canton 4
digitalWrite(D34, LOW);
digitalWrite(D35, LOW);
digitalWrite(D36, LOW);
digitalWrite(D37, LOW);
digitalWrite(D60, LOW);
digitalWrite(D61, LOW);

//RAZ Canton 5
digitalWrite(D38, LOW);
digitalWrite(D39, LOW);
digitalWrite(D40, LOW);
digitalWrite(D41, LOW);
digitalWrite(D62, LOW);
digitalWrite(D63, LOW);

// Canton 6
digitalWrite(D42, LOW);
digitalWrite(D43, LOW);
digitalWrite(D44, LOW);
digitalWrite(D45, LOW);
digitalWrite(D64, LOW);
digitalWrite(D65, LOW);

//RAZ Canton 7
digitalWrite(D46, LOW);
digitalWrite(D47, LOW);
digitalWrite(D48, LOW);
digitalWrite(D49, LOW);
digitalWrite(D66, LOW);
digitalWrite(D67, LOW);

//RAZ Canton 8
digitalWrite(D50, LOW);
digitalWrite(D51, LOW);
digitalWrite(D52, LOW);
digitalWrite(D53, LOW);
digitalWrite(D68, LOW);
digitalWrite(D69, LOW);

}


void loop()
{
Serial.flush(); // effacement message ecran

//watchdogReset();

CodeRecu =Serial1.available();
Serial.print("CodeRecu   ");Serial.println(CodeRecu);
x = Serial1.read();
Serial.print("x   ");Serial.println(x);
Serial.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");

Lab1:

C1 = 0;
C2 = 0;
C3 = 0;
C4 = 0;
C5 = 0;
C6 = 0;
C7 = 0;
C8 = 0;


i=0;
while (CodeRecu>0)
{
Serial.flush();
x = Serial1.read();
Serial.print("x   ");Serial.println(x);
i=i+1;
Serial.println(i);
if ( i == 1) { C1=x;} else {C1=0;}
if ( i == 2) { C2=x;} else {C2=0;}
if ( i == 3) { C3=x;} else {C3=0;}
if ( i == 4) { C4=x;} else {C4=0;}
if ( i == 5) { C5=x;} else {C5=0;}
if ( i == 6) { C6=x;} else {C6=0;}
if ( i == 7) { C7=x;} else {C7=0;}
if ( i == 8) { C8=x;} else {C8=0;}

Serial.print("C1   ");Serial.println(C1);
Serial.print("C2   ");Serial.println(C2);
Serial.print("C3   ");Serial.println(C3);
Serial.print("C4   ");Serial.println(C4);
Serial.print("C5   ");Serial.println(C5);
Serial.print("C6   ");Serial.println(C6);
Serial.print("C7   ");Serial.println(C7);
Serial.print("C8   ");Serial.println(C8);
//delay(100);




/*
//Pour visualisation des ZC et ZA 
if (A == 50) {digitalWrite(D2, LOW);digitalWrite(D3, HIGH);} else  {}  // code envoyé= 2
if (B == 51) {digitalWrite(D2, HIGH);digitalWrite(D3, LOW);} else  {}  // code envoyé= 3
if (C == 52) {digitalWrite(D4, LOW);digitalWrite(D5, HIGH);} else  {}  // code envoyé= 4
if (D == 53) {digitalWrite(D4, HIGH);digitalWrite(D5, LOW);} else  {}  // code envoyé= 5
if (E == 54) {digitalWrite(D6, LOW);digitalWrite(D7, HIGH);} else  {}  // code envoyé= 6
if (F == 55) {digitalWrite(D6, HIGH);digitalWrite(D7, LOW);} else  {}  // code envoyé= 7
if (G == 56) {digitalWrite(D8, LOW);digitalWrite(D9, HIGH);} else  {}  // code envoyé= 8
if (H == 57) {digitalWrite(D8, HIGH);digitalWrite(D9, LOW);} else  {}  // code envoyé= 9
*/
if (x == 10) {digitalWrite(D10, LOW);digitalWrite(D11, HIGH);} else  {}  // code envoyé= 10
if (x == 11) {digitalWrite(D10, HIGH);digitalWrite(D11, LOW);} else  {}  // code envoyé= 11
if (x == 12) {digitalWrite(D12, LOW);digitalWrite(D14, HIGH);} else  {}  // code envoyé= 12

if(x == 14) {digitalWrite(D12, HIGH);digitalWrite(D14, LOW);} else  {}  // code envoyé= 14
if(x == 15) {digitalWrite(D15, LOW);digitalWrite(D16, HIGH);} else  {}  // code envoyé= 15
if(x == 19) {digitalWrite(D15, HIGH);digitalWrite(D16, LOW);} else  {}  // code envoyé= 15
if(x == 17) {digitalWrite(D17, LOW);digitalWrite(D20, HIGH);} else  {}  // code envoyé= 17
if(x == 18) {digitalWrite(D17, HIGH);digitalWrite(D20, LOW);} else  {}  // code envoyé= 18

//Canton 1
if(C1 == 22) {digitalWrite(D22, HIGH);digitalWrite(D23, LOW);digitalWrite(D24, LOW);digitalWrite(D25, LOW);digitalWrite(D54, LOW);digitalWrite(D55, LOW);} else  {}  // code envoyé= 22
if(C1 == 23) {digitalWrite(D22, LOW);digitalWrite(D23, HIGH);digitalWrite(D24, LOW);digitalWrite(D25, LOW);digitalWrite(D54, LOW);digitalWrite(D55, LOW);} else  {}  // code envoyé= 23
if(C1 == 24) {digitalWrite(D22, LOW);digitalWrite(D23, LOW);digitalWrite(D24, HIGH);digitalWrite(D25, LOW);digitalWrite(D54, LOW);digitalWrite(D55, LOW);} else  {}  // code envoyé= 24
if(C1 == 25) {digitalWrite(D22, LOW);digitalWrite(D23, HIGH);digitalWrite(D24, LOW);digitalWrite(D25, HIGH);digitalWrite(D54, LOW);digitalWrite(D55, LOW);} else  {}  // code envoyé= 25

//Canton 2
if(C2 == 26) {digitalWrite(D26, HIGH);digitalWrite(D27, LOW);digitalWrite(D28, LOW);digitalWrite(D29, LOW);digitalWrite(D56, LOW);digitalWrite(D57, LOW);} else  {}  // code envoyé= 26
if(C2 == 27) {digitalWrite(D26, LOW);digitalWrite(D27, HIGH);digitalWrite(D28, LOW);digitalWrite(D29, LOW);digitalWrite(D56, LOW);digitalWrite(D57, LOW);} else  {}  // code envoyé= 27
if(C2 == 28) {digitalWrite(D26, LOW);digitalWrite(D27, LOW);digitalWrite(D28, HIGH);digitalWrite(D29, LOW);digitalWrite(D56, LOW);digitalWrite(D57, LOW);} else  {}  // code envoyé= 28
if(C2 == 29) {digitalWrite(D26, LOW);digitalWrite(D27, HIGH);digitalWrite(D28, LOW);digitalWrite(D29, HIGH);digitalWrite(D56, LOW);digitalWrite(D57, LOW);} else  {}  // code envoyé= 29

//Canton 3
if(C3 == 30) {digitalWrite(D30, LOW);digitalWrite(D31, HIGH);digitalWrite(D32, HIGH);digitalWrite(D33, HIGH);digitalWrite(D58, HIGH);digitalWrite(D59, HIGH);} else  {}  // code envoyé= 30
if(C3 == 31) {digitalWrite(D30, HIGH);digitalWrite(D31, LOW);digitalWrite(D32, HIGH);digitalWrite(D33, HIGH);digitalWrite(D58, HIGH);digitalWrite(D59, HIGH);} else  {}  // code envoyé= 31
if(C3 == 32) {digitalWrite(D30, HIGH);digitalWrite(D31, HIGH);digitalWrite(D32, LOW);digitalWrite(D33, HIGH);digitalWrite(D58, HIGH);digitalWrite(D59, HIGH);} else  {}  // code envoyé= 32
if(C3 == 33) {digitalWrite(D30, HIGH);digitalWrite(D31, LOW);digitalWrite(D32, HIGH);digitalWrite(D33, LOW);digitalWrite(D58, HIGH);digitalWrite(D59, HIGH);} else  {}  // code envoyé= 33

//Canton 4
if(C4 == 34) {digitalWrite(D34, HIGH);digitalWrite(D35, LOW);digitalWrite(D36, LOW);digitalWrite(D37, LOW);digitalWrite(D60, LOW);digitalWrite(D61, LOW);} else  {}  // code envoyé= 34
if(C4 == 35) {digitalWrite(D34, LOW);digitalWrite(D35, HIGH);digitalWrite(D36, LOW);digitalWrite(D37, LOW);digitalWrite(D60, LOW);digitalWrite(D61, LOW);} else  {}  // code envoyé= 35
if(C4 == 36) {digitalWrite(D34, LOW);digitalWrite(D35, LOW);digitalWrite(D36, HIGH);digitalWrite(D37, LOW);digitalWrite(D60, LOW);digitalWrite(D61, LOW);} else  {}  // code envoyé= 36
if(C4 == 37) {digitalWrite(D34, LOW);digitalWrite(D35, HIGH);digitalWrite(D36, LOW);digitalWrite(D37, HIGH);digitalWrite(D60, LOW);digitalWrite(D61, LOW);} else  {}  // code envoyé= 37

//Canton 5
if(x == 38) {digitalWrite(D38, HIGH);digitalWrite(D39, LOW);digitalWrite(D40, LOW);digitalWrite(D41, LOW);digitalWrite(D62, LOW);digitalWrite(D63, LOW);} else  {}  // code envoyé= 38
if(x == 39) {digitalWrite(D38, LOW);digitalWrite(D39, HIGH);digitalWrite(D40, LOW);digitalWrite(D41, LOW);digitalWrite(D62, LOW);digitalWrite(D63, LOW);} else  {}  // code envoyé= 39

if(x == 40) {digitalWrite(D38, LOW);digitalWrite(D39, LOW);digitalWrite(D40, HIGH);digitalWrite(D41, LOW);digitalWrite(D62, LOW);digitalWrite(D63, LOW);} else  {}  // code envoyé= 40
if(x == 41) {digitalWrite(D38, LOW);digitalWrite(D39, HIGH);digitalWrite(D40, LOW);digitalWrite(D41, HIGH);digitalWrite(D62, LOW);digitalWrite(D63, LOW);} else  {}  // code envoyé= 41

//Canton 6
if(x == 42) {digitalWrite(D42, HIGH);digitalWrite(D43, LOW);digitalWrite(D44, LOW);digitalWrite(D45, LOW);digitalWrite(D64, LOW);digitalWrite(D65, LOW);} else  {}  // code envoyé= 42
if(x == 43) {digitalWrite(D42, LOW);digitalWrite(D43, HIGH);digitalWrite(D44, LOW);digitalWrite(D45, LOW);digitalWrite(D64, LOW);digitalWrite(D65, LOW);} else  {}  // code envoyé= 43
if(x == 44) {digitalWrite(D42, LOW);digitalWrite(D43, LOW);digitalWrite(D44, HIGH);digitalWrite(D45, LOW);digitalWrite(D64, LOW);digitalWrite(D65, LOW);} else  {}  // code envoyé= 44
if(x == 45) {digitalWrite(D42, LOW);digitalWrite(D43, HIGH);digitalWrite(D44, LOW);digitalWrite(D45, HIGH);digitalWrite(D64, LOW);digitalWrite(D65, LOW);} else  {}  // code envoyé= 45


//Canton 7
if(x == 46) {digitalWrite(D46, HIGH);digitalWrite(D47, LOW);digitalWrite(D48, LOW);digitalWrite(D49, LOW);digitalWrite(D66, LOW);digitalWrite(D67, LOW);} else  {}  // code envoyé= 46
if(x == 47) {digitalWrite(D46, LOW);digitalWrite(D47, HIGH);digitalWrite(D48, LOW);digitalWrite(D49, LOW);digitalWrite(D66, LOW);digitalWrite(D67, LOW);} else  {}  // code envoyé= 47
if(x == 48) {digitalWrite(D46, LOW);digitalWrite(D47, LOW);digitalWrite(D48, HIGH);digitalWrite(D49, LOW);digitalWrite(D66, LOW);digitalWrite(D67, LOW);} else  {}  // code envoyé= 48
if(x == 49) {digitalWrite(D46, HIGH);digitalWrite(D47, HIGH);digitalWrite(D48, LOW);digitalWrite(D49, LOW);digitalWrite(D66, LOW);digitalWrite(D67, LOW);} else  {}  // code envoyé= 49

//Canton 8
if(x == 50) {digitalWrite(D50, HIGH);digitalWrite(D51, LOW);digitalWrite(D52, LOW);digitalWrite(D53, LOW);digitalWrite(D68, LOW);digitalWrite(D69, LOW);} else  {}  // code envoyé= 50
if(x == 51) {digitalWrite(D50, LOW);digitalWrite(D51, HIGH);digitalWrite(D52, LOW);digitalWrite(D53, LOW);digitalWrite(D68, LOW);digitalWrite(D69, LOW);} else  {}  // code envoyé= 51
if(x == 52) {digitalWrite(D50, LOW);digitalWrite(D51, LOW);digitalWrite(D52, HIGH);digitalWrite(D53, LOW);digitalWrite(D68, LOW);digitalWrite(D69, LOW);} else  {}  // code envoyé= 52
if(x == 53) {digitalWrite(D50, LOW);digitalWrite(D51, HIGH);digitalWrite(D52, LOW);digitalWrite(D53, HIGH);digitalWrite(D68, LOW);digitalWrite(D69, LOW);} else  {}  // code envoyé= 53


//Sémaphore 1
if(x == 54) {digitalWrite(D22, LOW);digitalWrite(D23, LOW);digitalWrite(D24, LOW);digitalWrite(D25, LOW);digitalWrite(D54, HIGH);digitalWrite(D55, LOW);} else  {}  // code envoyé= 54
if(x == 55) {digitalWrite(D22, LOW);digitalWrite(D23, LOW);digitalWrite(D24, LOW);digitalWrite(D25, LOW);digitalWrite(D54, LOW);digitalWrite(D55, HIGH);} else  {}  // code envoyé= 55

//Sémaphore 2
if(x == 56) {digitalWrite(D26, LOW);digitalWrite(D27, LOW);digitalWrite(D28, LOW);digitalWrite(D29, LOW);digitalWrite(D56, HIGH);digitalWrite(D57, LOW);} else  {}  // code envoyé= 56
if(x == 57) {digitalWrite(D26, LOW);digitalWrite(D27, LOW);digitalWrite(D28, LOW);digitalWrite(D29, LOW);digitalWrite(D56, LOW);digitalWrite(D57, HIGH);} else  {}  // code envoyé= 57

//Sémaphore 3
if(x == 58) {digitalWrite(D30, HIGH);digitalWrite(D31, HIGH);digitalWrite(D32, LOW);digitalWrite(D33, HIGH);digitalWrite(D58, LOW);digitalWrite(D59, HIGH);} else  {}  // code envoyé= 58
if(x == 59) {digitalWrite(D30, LOW);digitalWrite(D31, LOW);digitalWrite(D32, LOW);digitalWrite(D33, LOW);digitalWrite(D58, LOW);digitalWrite(D59, HIGH);} else  {}  // code envoyé= 59

//Sémaphore 4
if(x == 60) {digitalWrite(D34, LOW);digitalWrite(D35, LOW);digitalWrite(D36, LOW);digitalWrite(D37, LOW);digitalWrite(D60, LOW);digitalWrite(D61, LOW);} else  {}  // code envoyé= 60
if(x == 61) {digitalWrite(D34, LOW);digitalWrite(D35, LOW);digitalWrite(D36, LOW);digitalWrite(D37, LOW);digitalWrite(D60, LOW);digitalWrite(D61, HIGH);} else  {}  // code envoyé= 61

//Sémaphore 5
if(x == 62) {digitalWrite(D38, LOW);digitalWrite(D39, LOW);digitalWrite(D40, LOW);digitalWrite(D41, LOW);digitalWrite(D62, HIGH);digitalWrite(D63, LOW);} else  {}  // code envoyé= 62
if(x == 63) {digitalWrite(D38, LOW);digitalWrite(D39, LOW);digitalWrite(D40, LOW);digitalWrite(D41, LOW);digitalWrite(D62, LOW);digitalWrite(D63, HIGH);} else  {}  // code envoyé= 63

//Sémaphore 6
if(x == 64) {digitalWrite(D42, LOW);digitalWrite(D43, LOW);digitalWrite(D44, LOW);digitalWrite(D45, LOW);digitalWrite(D64, HIGH);digitalWrite(D65, LOW);} else  {}  // code envoyé= 64
if(x == 65) {digitalWrite(D42, LOW);digitalWrite(D43, LOW);digitalWrite(D44, LOW);digitalWrite(D45, LOW);digitalWrite(D64, LOW);digitalWrite(D65, HIGH);} else  {}  // code envoyé= 65

//Sémaphore 7
if(x == 66) {digitalWrite(D46, LOW);digitalWrite(D47, LOW);digitalWrite(D48, LOW);digitalWrite(D49, LOW);digitalWrite(D66, HIGH);digitalWrite(D67, LOW);} else  {}  // code envoyé= 66
if(x == 67) {digitalWrite(D46, LOW);digitalWrite(D47, LOW);digitalWrite(D48, LOW);digitalWrite(D49, LOW);digitalWrite(D66, LOW);digitalWrite(D67, HIGH);} else  {}  // code envoyé= 67

//Sémaphore 8
if(x == 68) {digitalWrite(D50, LOW);digitalWrite(D51, LOW);digitalWrite(D52, LOW);digitalWrite(D53, LOW);digitalWrite(D68, HIGH);digitalWrite(D69, LOW);} else  {}  // code envoyé= 68
if(x == 69) {digitalWrite(D50, LOW);digitalWrite(D51, LOW);digitalWrite(D52, LOW);digitalWrite(D53, LOW);digitalWrite(D68, LOW);digitalWrite(D69, HIGH);} else  {}  // code envoyé= 69
//delay(2000);
if (x==65) {goto Lab1;} else {}
}
}

[jpbbricole]

Bonjour eric93

A la place d'utiliser un autre Arduino comme extension de port, pourquoi ne pas utiliser des extensions de ports, comme le MCP23017 qui permet d'avoir 8 x 16 ports.
Un simple UNO, voir un Mega suffirait.

Pour la gestion de tes ports, regardes du côté des tableaux, ça te simplifierai la gestion de tes ports.

Comme tu as un grande quantité de feux, as tu regardé du côté des LED adressables comme les WS2812 pu Neopixel, pour le câblage, plus qu'un fil pour toutes les LED et une quantié de couleurs ....

Un essai de simplification fait par ChatGPT, ça compile mais je n'ai pas pu essayer, mais ça peut donner des idées :

// Programme Escalade Universel - Slave #1
// Version simplifiée 11/09/2025

struct Canton {
	int vert;
	int rouge;
	int jaune;
	int carreRouge;
	int semOrange1;
	int semOrange2;
	int ZC;
	int ZA;
};

// Déclaration des 8 cantons
Canton cantons[8] = {
	{22, 23, 24, 25, 54, 55,  2,  3},  // Canton 1
	{26, 27, 28, 29, 56, 57,  4,  5},  // Canton 2
	{30, 31, 32, 33, 58, 59,  6,  7},  // Canton 3
	{34, 35, 36, 37, 60, 61,  8,  9},  // Canton 4
	{38, 39, 40, 41, 62, 63, 10, 11},  // Canton 5
	{42, 43, 44, 45, 64, 65, 12, 14},  // Canton 6
	{46, 47, 48, 49, 66, 67, 15, 16},  // Canton 7
	{50, 51, 52, 53, 68, 69, 17, 20}   // Canton 8
};

// Initialisation
void setup() {
	Serial.begin(9600);
	Serial1.begin(250000);

	// Configurer toutes les pins en sortie + mise à zéro
	for (int i = 0; i < 8; i++) {
		pinMode(cantons[i].vert, OUTPUT);
		pinMode(cantons[i].rouge, OUTPUT);
		pinMode(cantons[i].jaune, OUTPUT);
		pinMode(cantons[i].carreRouge, OUTPUT);
		pinMode(cantons[i].semOrange1, OUTPUT);
		pinMode(cantons[i].semOrange2, OUTPUT);
		pinMode(cantons[i].ZC, OUTPUT);
		pinMode(cantons[i].ZA, OUTPUT);

		digitalWrite(cantons[i].vert, LOW);
		digitalWrite(cantons[i].rouge, LOW);
		digitalWrite(cantons[i].jaune, LOW);
		digitalWrite(cantons[i].carreRouge, LOW);
		digitalWrite(cantons[i].semOrange1, LOW);
		digitalWrite(cantons[i].semOrange2, LOW);
		digitalWrite(cantons[i].ZC, LOW);
		digitalWrite(cantons[i].ZA, LOW);
	}
}

// Allume un feu d’un canton selon l’état
// etat = 0=vert, 1=rouge, 2=jaune, 3=carré
void setSignal(int canton, int etat) {
	Canton c = cantons[canton];
	digitalWrite(c.vert,       (etat == 0) ? HIGH : LOW);
	digitalWrite(c.rouge,      (etat == 1) ? HIGH : LOW);
	digitalWrite(c.jaune,      (etat == 2) ? HIGH : LOW);
	digitalWrite(c.carreRouge, (etat == 3) ? HIGH : LOW);
	// Les sémaphores sont laissés LOW ici, sauf commandes spécifiques
}

// Active un sémaphore orange d’un canton
void setSemaphore(int canton, int num) {
	Canton c = cantons[canton];
	digitalWrite(c.semOrange1, (num == 1) ? HIGH : LOW);
	digitalWrite(c.semOrange2, (num == 2) ? HIGH : LOW);
}

// Active ZC/ZA d’un canton
void setZone(int canton, bool ZCstate, bool ZAstate) {
	Canton c = cantons[canton];
	digitalWrite(c.ZC, ZCstate ? HIGH : LOW);
	digitalWrite(c.ZA, ZAstate ? HIGH : LOW);
}

void loop() {
	if (Serial1.available()) {
		int code = Serial1.read();
		Serial.print("Code recu : ");
		Serial.println(code);

		// 🔹 Gestion des feux principaux (22..53)
		for (int i = 0; i < 8; i++) {
			int base = 22 + i * 4; // chaque canton a 4 états (vert, rouge, jaune, carré)
			if (code >= base && code <= base + 3) {
				setSignal(i, code - base);
			}
		}

		// 🔹 Gestion des sémaphores (54..69)
		for (int i = 0; i < 8; i++) {
			int base = 54 + i * 2; // 2 sémaphores par canton
			if (code == base)     setSemaphore(i, 1);
			if (code == base + 1) setSemaphore(i, 2);
		}

		// 🔹 Gestion des zones (exemple basé sur ton ancien code)
		if (code == 10) setZone(4, false, true);   // Canton 5 ZA active
		if (code == 11) setZone(4, true, false);   // Canton 5 ZC active
		if (code == 12) setZone(5, false, true);   // Canton 6 ZA active
		if (code == 14) setZone(5, true, false);   // Canton 6 ZC active
		if (code == 15) setZone(6, false, true);   // Canton 7 ZA active
		if (code == 19) setZone(6, true, false);   // Canton 7 ZC active
		if (code == 17) setZone(7, false, true);   // Canton 8 ZA active
		if (code == 18) setZone(7, true, false);   // Canton 8 ZC active
	}
}

A+
Cordialement
jpbbricole

[eric93]

jpbbricole
J'ai essayé d'utiliser le MCP23017 mais je n'ai pas poursuivi, je ne me souviens pas si c'était à cause du code que je n'arrivais à faire correctement ou parce que je me suis aperçu que cela n'allait pas pour mon besoin.
Je vais recommencer pour voir.
Effectivement l'utilisation des tableaux serait certainement 1 mieux pour moi
Le WS2812 ne répond pas apriori au besoin car j'allume des feux ferroviaires.
Quant au programme IA, je suis admiratif et un peu humilié car cela semble fonctionner parfaitement. je vais câbler les feux et faire les essais grandeur nature.
1 grand merci et je reviendrai vers vous pour vous donnez le résultat ou pour que vous m'aider encore si besoin.
A savoir que le réseau est visible en région parisienne ou à l'adresse Club Ferroviaire de Villemomble

[jpbbricole]

Bonsoir eric93

@eric93

Le WS2812 ne répond pas apriori au besoin car j'allume des feux ferroviaires.

En quoi les LED adressables ne sont pas compatibles, je pense que c'est justement applicable aux feux ferroviaires, imagines que pour un feux de 4 LED, avec des LED "normales" il te faut, à part les alimentations, 4 fils de commande avec pour chaque LED une résistance, avec des LED adressables, un fils qui parcourt tout tes feux et une résistance au départ de l'Arduino.

Bonne soirée
jpbbricole

[eric93]

je regarde tu as certainement raison.