Un tableau de commande géré par arduino

[herwat]

Patience, patience, ça va venir !

[Georges de Villette]

Je vais suivre ça Hervé , avec intérêt ....

[herwat]

Pour une bonne compréhension, voici une vue d'ensemble du réseau, du point de vue technique :
Tous les aiguillages sont commandés par servomoteurs eux-même commandés par arduino nano eux-même commandés pour la plupart par un arduino méga centralisateur .
Je détaille : Voici le montage du servo :
.

IMG_2694.jpg (105.66 Kio) Vu 8678 fois

.
et le module arduino nano :
.

IMG_2695.jpg (102.35 Kio) Vu 8678 fois

.
Ces modules sont tous quasiment identiques . Ils peuvent commander de 2 à 4 servo . Seul change le programme .
Il y a 2 types de module : ceux qui sont directement commandés par bouton poussoir et change donc d'état par impulsion, et ceux, les plus nombreux, commandés par un arduino méga et change donc d'état par niveau logique .

Voici le plan général des aiguillages :
.

Plan_aiguillagesNv.jpg (134.83 Kio) Vu 8678 fois

.
En fait, il y a 3 TCO : le TCO voyageur
le TCO marchandise
et un petit TCO que j'appelle dérivation et qui gérera , plus tard , "probablement", le pont tournant . . .

Le TCO marchandise étant en développement, je parlerai essentiellement du TCO voyageur qui, lui, est opérationnel :
.

IMG_2692.jpg (71.48 Kio) Vu 8678 fois

.
et ses entrailles :
.

IMG_2693.jpg (118.98 Kio) Vu 8678 fois

La suite au prochain numéro .

[likiki]

Voilà un sujet qui commence fort.

[Georges de Villette]

Commençons par le début ...
Un TCO c'est quoi ? Est ce que ça veut dire tableau commande ... ?
Excuse ma question , mais si je veux suivre ...
Auquel cas il y aurait 3 pupitres du genre de celui ci ? C'est ça ?

[herwat]

Euhhh, oui Georges .
TCO : tableau de commande optique .
Il y en a effectivement 3 sur mon réseau .

[Georges de Villette]

Merci Hervé ....

[Papy2568]

Il y en a effectivement 3 sur mon réseau .

3

[Georges de Villette]

Il y en a effectivement 3 sur mon réseau .

3

Et oui Eric ! Je t'explique :
Un pour le réseau voyageur , un pour le réseau marchandises et un pour les commandes du pont tournant !!!
Tu comprends ?
.
Pas sur la tête Hervé ! Pas sur la tête !!!!

[herwat]

Georges, si tu veux faire l'exposé à ma place, y faut pas hésiter ! ! !

ça me fera des vacances !

[herwat]

Pour fixer les idée;
voilà le tableau voyageur "in situ" :

IMG_2697.jpg (92.28 Kio) Vu 8655 fois

.
L'emplacement du futur tableau marchandise :

IMG_2698.jpg (98.41 Kio) Vu 8655 fois

.
Et le petit tableau qui gère la dérivation et provisoirement en analogique le pont tournant

IMG_2699.jpg (105.89 Kio) Vu 8655 fois

.

[Papy2568]

Ah ok!

Je pensais que tout serait sur un même tableau...

[Al1baba]

Patience, patience, ça va venir !

20 avril 2021 16:03
Ouais.... En informatique il y a 50% de préannonce!

[herwat]

Pour les impatients

Voici le sketch d'un nano :

Code : Tout sélectionner

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * *   Gare Voyageur  -  Côté gauche   * * * * * * *
     * * * * * * * * * * *   Aguillages  GV 01 02 03 04    * * * * * * *
     * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
     * 
     * Programme Opérationnel
     * Quatre servo
     * une entrée analogique par servo     
     * entree niveau bas impose angle mini
     * entree niveau haut impose angle maxi
     */   
    #include <Servo.h>
     
    int MiniMax1[2]  = {600,900} ;    // Aiguillage GV01
    const byte pinServo1 = 2;
    const byte pinEntree1 = 2;
    int MiniMax2[2]  = {600,900} ;    // Aiguillage GV02
    const byte pinServo2 = 3;
    const byte pinEntree2 = 3;
    int MiniMax3[2]  = {600,900} ;    // Aiguillage GV03
    const byte pinServo3 = 4;
    const byte pinEntree3 = 4;
    int MiniMax4[2]  = {600,900} ;    // Aiguillage GV04
    const byte pinServo4 = 5;
    const byte pinEntree4 = 5; 
    Servo monServo1;
    Servo monServo2;
    Servo monServo3;
    Servo monServo4;
    int vitesse1[2] = {-1,1} ;
    int vitesse2[2] = {-1,1} ;
    int vitesse3[2] = {-1,1} ;
    int vitesse4[2] = {-1,1} ;
    int sens1;
    int sens2;
    int sens3;
    int sens4;
    int PosActuelle1;
    int PosActuelle2;
    int PosActuelle3;
    int PosActuelle4;
    boolean Mvt;
    boolean Mvt1;
    boolean Mvt2;
    boolean Mvt3;
    boolean Mvt4;
    boolean NvAncien1;
    boolean NvLu1;
    boolean NvAncien2;
    boolean NvLu2;
    boolean NvAncien3;
    boolean NvLu3;
    boolean NvAncien4;
    boolean NvLu4;
        
    void setup()
    {
        pinMode (13, OUTPUT);       // Sortie témoin de mouvement des servo
        monServo1.attach(pinServo1);
        monServo1.writeMicroseconds(750); // Les servo sont d'abord mis en position médiane
        delay(200);                       // avant leur position définitive 
        monServo2.attach(pinServo2);
        monServo2.writeMicroseconds(750);
        delay(200);
        monServo3.attach(pinServo3);
        monServo3.writeMicroseconds(750);
        delay(200);
        monServo4.attach(pinServo4);
        monServo4.writeMicroseconds(750);
        delay(200);
        PosActuelle1 = 750;
        PosActuelle2 = 750;
        PosActuelle3 = 750;
        PosActuelle4 = 750;
        sens1 = 0;
        sens2 = 0;
        sens3 = 0;
        sens4 = 0;
        Mvt1 = false;
        Mvt2 = false;
        Mvt3 = false;
        Mvt4 = false;
        Mvt = Mvt1 || Mvt2 || Mvt3 || Mvt4;

// Attente pour l'initialisation du Méga soit terminée

        delay(1000);
        NvLu1 = analogRead(pinEntree1) > 511;   NvAncien1 = !NvLu1;
        NvLu2 = analogRead(pinEntree2) > 511;   NvAncien2 = !NvLu2;
        NvLu3 = analogRead(pinEntree3) > 511;   NvAncien3 = !NvLu3;
        NvLu4 = analogRead(pinEntree4) > 511;   NvAncien4 = !NvLu4;
        
     }
     
  
    void loop()
     /*
     * J'ai fait en sorte que l'entréz ne soit lue que si
     * le servo est à l'arrêt .    
     */   
   
    {
      
      NvLu1 = analogRead(pinEntree1) > 511;
      NvLu2 = analogRead(pinEntree2) > 511;
      NvLu3 = analogRead(pinEntree3) > 511;
      NvLu4 = analogRead(pinEntree4) > 511;
      if(NvLu1 == NvAncien1 && NvLu2 == NvAncien2 && NvLu3 == NvAncien3 && NvLu4 == NvAncien4 && !Mvt )
            {   }
            
      else {  
             
           if(Mvt1)
              {
               PosActuelle1 = PosActuelle1 + vitesse1[sens1] ;
               monServo1.writeMicroseconds(PosActuelle1);
               if( PosActuelle1 == MiniMax1[sens1] )
                  {
                   Mvt1 = false;
                   monServo1.detach();
                  }
              }
           if(Mvt2)
              {
               PosActuelle2 = PosActuelle2 + vitesse2[sens2] ;
               monServo2.writeMicroseconds(PosActuelle2);
               if( PosActuelle2 == MiniMax2[sens2] )
                  {
                   Mvt2 = false;
                   monServo2.detach();
                  }
              }

            if(Mvt3)
              {
               PosActuelle3 = PosActuelle3 + vitesse3[sens3] ;
               monServo3.writeMicroseconds(PosActuelle3);
               if( PosActuelle3 == MiniMax3[sens3] )
                  {
                   Mvt3 = false;
                   monServo3.detach();
                  }
              }

            if(Mvt4)
              {
               PosActuelle4 = PosActuelle4 + vitesse4[sens4] ;
               monServo4.writeMicroseconds(PosActuelle4);
               if( PosActuelle4 == MiniMax4[sens4] )
                  {
                   Mvt4 = false;
                   monServo4.detach();
                  }
              }

           if(NvLu1 == !NvAncien1 && !Mvt1 )
              {
               sens1 = NvLu1;
               Mvt1 = true;
               monServo1.attach(pinServo1);
               NvAncien1 = NvLu1;
              } 

            if(NvLu2 == !NvAncien2 && !Mvt2 )
              {
               sens2 = NvLu2;
               Mvt2 = true;
               monServo2.attach(pinServo2);
               NvAncien2 = NvLu2;
              } 

            if(NvLu3 == !NvAncien3 && !Mvt3 )
              {
               sens3 = NvLu3;
               Mvt3 = true;
               monServo3.attach(pinServo3);
               NvAncien3 = NvLu3;
              } 

            if(NvLu4 == !NvAncien4 && !Mvt4 )
              {
               sens4 = NvLu4;
               Mvt4 = true;
               monServo4.attach(pinServo4);
               NvAncien4 = NvLu4;
              } 

           }
        
        delay(5);
        Mvt = Mvt1 || Mvt2 || Mvt3 || Mvt4;
        digitalWrite (13,Mvt);
    }    

Bon . . . Je pense qu'on peut mieux faire, mais j'ai fait ce que j'ai pu avec mes connaissances et les neurones qui me reste .
Mais au moins, ça marche parfaitement .

La sortie 13, témoin de mouvement permet à l'arduino Mega d'éteindre les leds du tableau des que les aiguillages sont en mouvement . Histoire d'éviter d'engager un train avant qu'ils ne soient en positions . . . .

[likiki]

Je t'ai mis le listing dans des balises code, c'est mieux.


Par contre, petite question, le code Arduino et le même pour un UNO comme pour un Nano où il faut le préciser ?

[herwat]

Je t'ai mis le listing dans des balises code, c'est mieux.

Merci, Christian . Je ne savais pas comment faire . . . . .. Maintenant, je sais !

Pour l'UNO, bonne question . A priori, pas de problème car il sont quasiment identique . . . .

[herwat]

Je viens de faire une compilation dans l'IDE arduino, en précisant UNO , . . . Pas de souci . . .

[likiki]

Oui, dans l'IDE il faut choisir le type de carte (UNO, MEGA ou NANO).

[Papy2568]

Hervé



Tu es le pro de l'arduino!

[herwat]

, Eric

[herwat]

Dans la catégorie des Nano "spéciaux" et indépendant du Méga , voici le Nano 6 sur son banc d'essai :
.

IMG_2547.jpg (111.67 Kio) Vu 8627 fois

.
et son sketch :

Code : Tout sélectionner

    /*
     * Programme opérationnel
     * Un poussoir sur entrée analogique pour changement de voie A et pas de changement voie B
     * Un poussoir sur entrée analogique pour changement de voie B et pas de changement voie A
     * Un poussoir sur entrée analogique sans changement de voie 
     * Le changement de voie A interdit le changement de voie B et réciproquement
     */   
    
    #include <Servo.h>
    
    const byte pinServo1 = 2;
    const byte pinServo2 = 3;
    const byte pinServo3 = 4;
    const byte pinServo4 = 5;
    const byte pinBouton1 = 2;
    const byte pinBouton2 = 3;
    const byte pinBouton3 = 4;

    int MiniMax1[2]  = {600,900} ;     // Amplitude du mouvement du servo 1
    int MiniMax2[2]  = {600,900} ;
    int MiniMax3[2]  = {600,900} ;
    int MiniMax4[2]  = {600,900} ;
    int vitesse[2]  = {-1,1} ;
    
    //*******************    Configuration des mouvements servo selon plan de voie    *******************
    
    boolean Inverse = true;    // Indique si les sens de rotation des 2 servo A et B d'une même voie
                                //  sont inversés ou non
                                // à modifier suivant la configuration du réseau 
    boolean InverseA = true;   // Même chose pour les 2 servo de changement de voie A
    boolean InverseB = true;   // Même chose pour les 2 servo de changement de voie B
    
    boolean Sensini = false;      // Position du servo1 pour que son aiguillage soit droit à l'initialisation
                                
    //****************************************************************************************************
                                
    const byte Led1 = 7;       // commande les leds 1 et 6
    const byte Led2 = 8;       // commande la led 2
    const byte Led3 = 9;       // commande les leds 3 et 4
    const byte Led4 = 10;      // commande la led 7
    const byte Led5 = 11;      // commande la led 8
                               // la led 5 est allumée en permanence 

    int Allumage [3][5] = {  
                           {0,0,1,0,1},        //  Changement A       Bouton 1
                           {1,1,1,0,0},        //  Pas de Changement  Bouton 2
                           {1,0,0,1,0},        //  Changement B       Bouton 3
                          };
    int Bouton;                      
     
    Servo monServo1;
    int vitesse1;
    int angle1;                // position du servo à un instant donné
    int angleFinal1;
    boolean Sens1;             // indique si l'aiguillage doit être droit ou dévié 
    
    Servo monServo2;
    int vitesse2;
    int angle2;
    int angleFinal2;
    boolean Sens2;

    Servo monServo3;
    int vitesse3;
    int angle3;
    int angleFinal3;
    boolean Sens3;

    Servo monServo4;
    int vitesse4;
    int angle4;
    int angleFinal4;
    boolean Sens4;
    
    boolean Mvt;               // indique qu'il y a au moins un servo en mouvement
    boolean Mvt1;              // indique que le servo 1 est en mouvement
    boolean Mvt2;
    boolean Mvt3;
    boolean Mvt4;
    
    void setup()
      {
        pinMode (Led1, OUTPUT);
        pinMode (Led2, OUTPUT);
        pinMode (Led3, OUTPUT);
        pinMode (Led4, OUTPUT);
        pinMode (Led5, OUTPUT);
        pinMode  (13, OUTPUT );
        
        monServo1.attach(pinServo1);
        monServo1.writeMicroseconds(750);
        delay(500);
        angle1 = 750;
        Sens1 = Sensini;
        Mvt1 = true;
        
        monServo2.attach(pinServo2);
        monServo2.writeMicroseconds(750);
        delay(500);
        angle2 = 750;
        Sens2 = Sens1^InverseA ;
        Mvt2 = true;

        monServo3.attach(pinServo3);
        monServo3.writeMicroseconds(750);
        delay(500);
        angle3 = 750;
        Sens3 = Sens1^Inverse ;
        Mvt3 = true;
        
        monServo4.attach(pinServo4);
        monServo4.writeMicroseconds(750);
        delay(500);
        angle4 = 750;
        Sens4 = Sens3^InverseB ;
        Mvt4 = true;

        vitesse1 = vitesse[Sens1]; angleFinal1 = MiniMax1[Sens1];
        vitesse2 = vitesse[Sens2]; angleFinal2 = MiniMax2[Sens2];
        vitesse3 = vitesse[Sens3]; angleFinal3 = MiniMax3[Sens3];
        vitesse4 = vitesse[Sens4]; angleFinal4 = MiniMax4[Sens4];

        Mvt = Mvt1 || Mvt2 || Mvt3 || Mvt4;
        Bouton = 1 ;

        digitalWrite (Led1, HIGH);
        digitalWrite (Led2, HIGH);
        digitalWrite (Led3, HIGH);
        digitalWrite (Led4, HIGH);
        digitalWrite (Led5, HIGH);
        digitalWrite (13,HIGH);
       }
     
    void loop()
       {
         if(Mvt) { }
         else {
               if (analogRead(pinBouton1) > 511 )    // Changement de voie A
                 {Bouton = 0 ;
                  Sens1 = !Sensini;
                  Sens2 = Sens1^InverseA ;
                  Sens3 = !Sens1^Inverse ;
                  Sens4 = Sens3^InverseB ;
                  monServo1.attach(pinServo1);
                  monServo2.attach(pinServo2);
                  monServo3.attach(pinServo3);
                  monServo4.attach(pinServo4);
                  Mvt1 = true;
                  Mvt2 = true;
                  Mvt3 = true;
                  Mvt4 = true;
                 }
       
                if (analogRead(pinBouton2) > 511 )    // Pas de hangement de voie
                 {Bouton = 1 ;
                  Sens1 = Sensini;
                  Sens2 = Sens1^InverseA ;
                  Sens3 = Sens1^Inverse ;
                  Sens4 = Sens3^InverseB ;
                  monServo1.attach(pinServo1);
                  monServo2.attach(pinServo2);
                  monServo3.attach(pinServo3);
                  monServo4.attach(pinServo4);
                  Mvt1 = true;
                  Mvt2 = true;
                  Mvt3 = true;
                  Mvt4 = true;
                 }

                 if (analogRead(pinBouton3) > 511 )    // Changement de voie B
                 {Bouton = 2 ;
                  Sens1 = Sensini;
                  Sens2 = Sens1^InverseA ;
                  Sens3 = !Sens1^Inverse ;
                  Sens4 = Sens3^InverseB ;
                  monServo1.attach(pinServo1);
                  monServo2.attach(pinServo2);
                  monServo3.attach(pinServo3);
                  monServo4.attach(pinServo4);
                  Mvt1 = true;
                  Mvt2 = true;
                  Mvt3 = true;
                  Mvt4 = true;
                 }
                 
                vitesse1 = vitesse[Sens1]; angleFinal1 = MiniMax1[Sens1];
                vitesse2 = vitesse[Sens2]; angleFinal2 = MiniMax2[Sens2];
                vitesse3 = vitesse[Sens3]; angleFinal3 = MiniMax3[Sens3];
                vitesse4 = vitesse[Sens4]; angleFinal4 = MiniMax4[Sens4];
                digitalWrite (Led1,LOW);
                digitalWrite (Led2,LOW);
                digitalWrite (Led3,LOW);
                digitalWrite (Led4,LOW);
                digitalWrite (Led5,LOW);
              }
              
        monServo1.writeMicroseconds(angle1);
        if (angle1 == angleFinal1) {
                     vitesse1 = 0;
                      monServo1.detach();
                      Mvt1 = false;    
                                   }
        angle1 = angle1 + vitesse1;
        
                            
        monServo2.writeMicroseconds(angle2);
        if (angle2 == angleFinal2) {
                     vitesse2 = 0;
                      monServo2.detach();
                      Mvt2 = false;    
                                   }
        angle2 = angle2 + vitesse2;
        
                                   
        monServo3.writeMicroseconds(angle3);
        if (angle3 == angleFinal3) {
                     vitesse3 = 0;
                      monServo3.detach();
                      Mvt3 = false;    
                                   }
        angle3 = angle3 + vitesse3;
        

        monServo4.writeMicroseconds(angle4);
        if (angle4 == angleFinal4) {
                     vitesse4 = 0;
                      monServo4.detach();
                      Mvt4 = false;    
                                   }
        angle4 = angle4 + vitesse4;
                                                             
                                  
        Mvt = Mvt1 || Mvt2 || Mvt3 || Mvt4;
        
        if(!Mvt) {
                   digitalWrite (Led1, Allumage [Bouton][0]);
                   digitalWrite (Led2, Allumage [Bouton][1]);
                   digitalWrite (Led3, Allumage [Bouton][2]);
                   digitalWrite (Led4, Allumage [Bouton][3]);
                   digitalWrite (Led5, Allumage [Bouton][4]);
                   digitalWrite (13,LOW);
                  }    
        
        delay(6);
    }

Assez content moi . . . . ( en toute humilité, bien sûr ! )

[likiki]

Tu peu être content de toi, c'est super.

[herwat]

Je dois reconnaitre que je me suis bien amusé sur ce programme !

Mais maintenant, passons au morceau de bravoure !
La programmation de l'arduino méga . . .

Le voilà avec son premier shield maison :
.

IMG_2481.jpg (124.28 Kio) Vu 8588 fois

.
Je voulais gérer les servo de ma gare cachée directement depuis le méga . . . ce fut un cuisant échec ! ! ! . . . .
Je n'ai jamais obtenu un fonctionnement fiable et n'ai jamais compris pourquoi .

C'est à ce moment là que j'ai opté pour la configuration actuelle : des nano pour gérer les servo et le méga pour commander les nano .
En fait, cette config a plusieurs avantages :
1 - Scinder les problèmes
2 - Faciliter le câblage
3 - Permettre une éventuelle maintenance plus aisée .
Je dis "éventuelle" parce que, jusqu'à maintenant il n'y en a pas . . . . c'est d'une fiabilité remarquable et . . . j'en suis le premier étonné !

Le shield définitif est à peu prés similaire
et voici le programme :

Code : Tout sélectionner

     /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
      *          Mega commandant trois nano pilotant les servo gérant la gare voyageur        *
      * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
      * 
      *   Programme Opérationnel
      *   
      *   Onze boutons poussoirs
      *   Quinzes leds
      *   
       */
 
       /* Affectation des entrées analogiques pour boutons poussoirs
    de commpande */
    int pinBouton [11] = {2,3,4,5,6,7,8,9,10,11,12};    //   pin A2 à A12
          
    /* Affectation des sorties pour les LEDs témoins  */
    int GrLed [15] = {26,28,30,32,34,36,38,40,42,44,46,48,50,51,53};
    
    int Allumage [12][15] = {                   //la valeur 2 n'impose pas de changement .
                           {1,0,2,2,2,2,2,2,2,2,2,2,2,2,2},  
                           {0,1,2,2,2,2,2,2,2,2,2,2,2,2,2},
                           {2,2,1,0,0,0,0,0,0,0,1,0,0,0,1},
                           {2,2,0,1,0,0,0,0,0,0,1,1,0,0,1},
                           {2,2,0,0,1,0,0,0,0,0,1,1,1,2,2},
                           {2,2,0,0,0,1,0,0,0,0,1,1,1,2,2},
                           {2,2,0,0,0,0,1,0,0,0,1,1,1,2,2},
                           {2,2,2,2,2,2,2,1,2,2,2,2,2,2,2},
                           {2,2,2,2,2,2,2,2,1,2,2,2,2,2,2},
                           {2,2,2,2,2,2,2,2,2,1,0,2,2,2,2},
                           {2,2,2,2,2,2,2,2,2,2,2,2,2,1,0},
                           {0,1,1,0,0,0,0,0,0,0,1,0,0,0,1},  // ligne prévue pour l'initialisation
                          };

     int Precedent [15] = {0,1,1,0,0,0,0,0,0,0,1,0,0,0,1};                     
                             
     /* Grille des Etats de commande des onze servo répartis sur 3 platines nano
     la valeur 0 correspond à l'aiguillage droit
     la valeur 1 correspond à l'aiguillage dévié
     la valeur 2 correspond à un état indifférent
     */

   int Etat [12][11] = {  
                        {2,0,2,2,2,0,2,2,2,2,2},  
                        {2,1,2,2,2,1,2,2,2,2,2},  
                        {1,2,0,2,1,2,0,2,2,2,2},
                        {1,2,1,0,1,2,1,2,2,2,2},
                        {1,2,1,1,2,2,2,1,0,2,2},
                        {1,2,1,1,2,2,2,0,0,1,0},
                        {1,2,1,1,2,2,2,0,0,0,0},
                        {2,2,2,2,2,2,2,2,1,2,2},
                        {2,2,2,2,2,2,2,2,2,2,1},
                        {0,2,2,2,2,2,2,2,2,2,2},
                        {2,2,2,2,0,2,2,2,2,2,2},
                        {1,1,0,2,1,1,2,2,2,2,2},       // ligne prévue pour l'initialisation
                     };

    /* Affectation des sorties  servo   */
    
    int pinServo [11] = {2,3,4,5,6,7,8,10,11,12,13};   /*   pin D"x"   */
    
    /* Affectation des entrées témoins de mouvements servo   */

    const byte  EmvtP1 = 14 ;   /*   pin D"x"   */
    const byte  EmvtP2 = 15 ;
    const byte  EmvtP3 = 16 ;

    const byte  Relai5 = 17 ;  // relais commandant l'alimentation des voies "parking"
    const byte  Relai6 = 18 ;
    const byte  Relai7 = 19 ;
    const byte  Relai89 = 20 ;
    
    boolean Mvt ;
    boolean Mvt1 ;
    boolean Mvt2 ;
    boolean Mvt3 ;
    boolean Bouton ;
    int y ;             //  variables d'incrémentation
    int z ;
    int BoutonSel ;     //  numéro du bouton appuyé
    void setup()
    {   
        for (y=0 ; y <= 10 ; y++){ pinMode(pinServo [y], OUTPUT); }
        pinMode (EmvtP1, INPUT);
        pinMode (EmvtP2, INPUT);
        pinMode (EmvtP3, INPUT);
        pinMode (Relai5, OUTPUT);
        pinMode (Relai6, OUTPUT);
        pinMode (Relai7, OUTPUT);
        pinMode (Relai89, OUTPUT);
        for (y=0 ; y <= 14 ; y++){ pinMode(GrLed [y], OUTPUT); }
        BoutonSel = 11;   // sélectionne les lignes d'initialisation
        
     }

    void loop()
    {
      Mvt1 = digitalRead( EmvtP1 );
      Mvt2 = digitalRead( EmvtP2 );
      Mvt3 = digitalRead( EmvtP3 );  
      Mvt = Mvt1 || Mvt2 || Mvt3 ;

      if(!Mvt) {
                 Bouton = LOW;
                 for (y=0 ; y <= 10 ; y++)
                   { 
                   if ( analogRead( pinBouton [y]) > 511 ){ Bouton = HIGH; }
                   if (Bouton){
                                for (z=0 ; z <= 14 ; z++)
                                    {
                                       if ( Allumage [BoutonSel][z] == 2 ) {}
                                       else {Precedent [z] = Allumage [BoutonSel][z]; }
                                    }
                                BoutonSel = y;
                                break;
                               }
                   }  
               }

      if(Mvt) {  
               for (y=0 ; y <= 14 ; y++){ digitalWrite(GrLed [y], LOW); }
               digitalWrite( Relai5, HIGH );
               digitalWrite( Relai6, HIGH );
               digitalWrite( Relai7, HIGH );
               digitalWrite( Relai89, HIGH );
              }
    
      for (y=0 ; y <= 10 ; y++)
            { 
              if ( Etat [BoutonSel][y] == 2 ) { }
              else {digitalWrite(pinServo [y], Etat [BoutonSel][y] ); }
            }
      if(!Mvt) {
                for (y=0 ; y <= 14 ; y++)
                     {
                      digitalWrite(GrLed [y], Precedent[y]);
                     }
                digitalWrite( Relai5, !Precedent[4]);    
                digitalWrite( Relai6, !Precedent[5]);
                digitalWrite( Relai7, !Precedent[6]);
                if (Precedent[7] || Precedent[8] ){ digitalWrite( Relai89, LOW); }
               }
           
    }
    

Voilà, vous savez tous , enfin pour le TCO voyageur . Pour le "marchandise", il faudra patienter un peu et même, peut-être beaucoup !

Alors je dirais quand même :

[Papy2568]

Ce ne sont plus des neurones que tu as dans la tête, mais des nanos arduino

Ceci dit, beau boulot...

[herwat]

, Eric