Forum-passionnement

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);
    }    

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);
    }

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); }
               }
           
    }