Nouveau projet : La vitrine voyageur

[herwat]

De rien, Christian .

Et pour finir, le tablier où il y a la barrière et la partie amovible du support :

Tablier_Extr220.STL

Supp_Barr.STL

[bunny94]

Hervé, bien que je ne lancerai pas dans l'impression de ton projet, c'est très sympa à toi de mettre tes Stl à notre disposition.

[likiki]

Oui, car il est tout a fait possible de les adapter a ses besoins.

[herwat]

Évolution du jour :
.

IMG_2916.jpg

[Papy2568]

Le top!

[NANAR]

Superbe

[herwat]

Présentation
.

IMG_2917.jpg

.
. Je continue . . .

[likiki]

Hooo ! Cela avance.

Tu a ajouté un guide au plateau ?

[herwat]

Tu a ajouté un guide au plateau ?

C'est à dire ?

De toute façon, j'ai fait une énooooorme erreur de cotation sur un dessin !
Ce qui fait que l'écartement entre le profilé et la tige filetée n'est pas le même sur les pièces moteur et sur la glissière . . . .
Impardonnable ! si je continue comme cela, je vais dévaliser mon fournisseur de PLA . . . . et vider ma tirelire . . .

Bon, erreur corrigée . Il n'y a plus qu'à ré-imprimer . . . . Demain matin, ce sera oublié !

[likiki]

La glissière que tu utilise est rectangulaire ?

Rond ce n’est pas mieux ?

[herwat]

La réponse est là

[likiki]

Ok autant pour moi

[Georges de Villette]

.
Merci Hervé pour les supports dans Cura .
Je ne t'ai pas répondu plus tôt car je suis dans la famille à Dunkerque et sans gas oil !!!
On verra bien mercredi pour redescendre à Lyon !!!

[herwat]

Bon, hier, j'ai pris mon courage à deux mains, et, grâce au tuto de Christian sur les mini connecteurs, j'ai pu remettre en état Liliane . Euuuhhh . . . pour éviter les commentaires et malentendus, je parle de Liliane mon imprimante maison .
Cela me permet de faire d'une seule pièce la partie centrale du tablier qui fait 30 cm de long .
.

IMG_2918.jpg

.
Cela m'aurait ennuyé de l'imprimer en deux morceaux car cela aurait affaibli la rigidité de l'ensemble .
Bref, c'est très

[likiki]

Liliane reprend du service.

[herwat]

Liliane a fait du bon boulot : on ne voit quasiment pas la différence entre les deux imprimantes .
.

IMG_2919.jpg

.
et ça c'est

[likiki]

Superbes impressions.

[Georges de Villette]

Bon résultat !

[Papy2568]

Super!

[jeanjacques]

[bunny94]

c'est

[NANAR]

Très réussi

[herwat]

ça y est ! la programmation du verrou et de ma barrière est, sauf erreur, opérationnel .

https://youtu.be/TJ8aaS8HwKg

Bonne chose de faite . . . et il n'y a plus qu'à faire la même chose pour l'autre extrémité !

Et pour ceux que ça intéresse, voici le programme .

Code : Tout sélectionner

          /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
           * * * * * *                                                       * * * * * *
           * * * * * *                Pont transbordeur Voyageur             * * * * * *
           * * * * * *             Commande verrouillage par servo           * * * * * *
           * * * * * *                            et                         * * * * * *
           * * * * * *               Commande Barrière par servo             * * * * * * 
           * * * * * *                                                       * * * * * *
           * * * * * *                    sur arduino Nano                   * * * * * *
           * * * * * *         avec condamnation  verrou et barrière         * * * * * *
           * * * * * *   et confimation du déverrouillage par fin de course  * * * * * *
           * * * * * * Le défaut de verrouilage entraine un blocage système  * * * * * *
           * * * * * *            pour en sortir, faire un "RESET"           * * * * * *
           * * * * * *                                                       * * * * * *
           * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 
     
     // Programme opérationnel
     // Un servo pour le verrou et un pour la barrière
     // deux entrée numérique commandent le servoV et le servoB     
     // entree niveau bas impose le verrou rentré et barrière levée
     // entree niveau haut impose le verrou sorti et barrière baissée
   
    
    #include <Servo.h>
    
    const byte pinServoV = 2;  //  Servo commandant le verrouillage
    const byte pinEntreeV = 5; //  Entrée de commande verrou numérique D5 venant de la D25 du Méga
    const byte pinServoB = 3;  //  Servo commandant la barrière
    const byte pinEntreeB = 6; //  Entrée de commande barrière numérique D6 venant de la Dxx du Méga
    
    const byte pinVerrou = 7;   //  Sortie témoin de verrouillage - déverrouillage vers D27 du Méga
    const byte pinBlocage = 9;  //  Entrée  de condamnation du verrou 
    const byte pinFdc = 4;      //  Entrée du fin de course confirmant le déverrouillage
    const byte pinDefaut = 8;   //  Sortie témoin de défaut de déverrouillage
        
    int MiniMaxV[2]  = {900,1700} ;    // 900 = verrou rentré   -  1700 = verrou sorti
    int vitesseV[2]  = {-1,1} ;
    int MiniMaxB[2]  = {830,2000} ;    // 830 = barrière levée  -  2000 = Barrière baissée
    int vitesseB[2]  = {-1,1} ;
            
    Servo LeServoV;             // variables pour le servo du verrou
    int AvanceV;
    int angleV;
    int angleFinalV;

    Servo LeServoB;             // variables pour le servo de la barrière
    int AvanceB;
    int angleB;
    int angleFinalB;
    
    boolean Etat;               // Etat de l'entrée de commande de verrouillage
    boolean Etatlu;
    boolean InverseV ;          // Permet d'inverser la position du verrou par rapport à l'entrée
        /* 
         * Ex: En supposant que "pinEntreeV = 0 " impose le verrou rentré avec "InverseV=false;"
         * Alors il sera sorti si "InverseV=true;"
         */
    boolean Temoin ;
    boolean Barre;              // Etat de l'entrée de commande de la barrière
    boolean Barrelu;
    boolean InverseB ;          // Permet d'inverser la position de la barrière
    boolean UneSeuleCmdt;       // Permet de n'avoir qu'une entrée de commande
    
    boolean MvtV;
    boolean MvtB;
    boolean Blocage;            // Si "vrai" bloque le verrou en position déverrillé
    boolean Fdc;                // état du fin de course pour confirmation du déverrouillage
    boolean Defaut;             // vrai si le déverrouillage n'est pas confirmé
    boolean Clign;
    unsigned long Periode = 0 ;
        
    void setup()
      {
        pinMode (pinEntreeV, INPUT);
        pinMode (pinEntreeB, INPUT);
        pinMode (pinVerrou, OUTPUT);
        pinMode (pinBlocage, INPUT);
        pinMode (pinFdc, INPUT);
        pinMode (pinDefaut, OUTPUT);
                                 
        LeServoV.attach(pinServoV);
        LeServoV.writeMicroseconds(1300);
        delay(500);
        angleV = 1300;
        AvanceV = vitesseV[false]; angleFinalV = MiniMaxV[false];
        digitalWrite (pinDefaut,false);
        Clign = false ;
        Defaut = false ;
        MvtV = true ;
        MvtB = true ;

        LeServoB.attach(pinServoB);
        LeServoB.writeMicroseconds(1400);
        delay(500);
        angleB = 1400;
        AvanceB = vitesseB[false]; angleFinalB = MiniMaxB[false];    

        UneSeuleCmdt = true ;
        InverseV = false ;
        InverseB = true ;
        
       }   
     
    void loop()
       {
        Blocage = digitalRead(pinBlocage);
        Etatlu = InverseV^digitalRead(pinEntreeV); Temoin = Etatlu ;
        Barrelu = InverseB^digitalRead(pinEntreeB);
        
 
         
        if(Blocage) { Etatlu =InverseV ^ false ; Barrelu = InverseB^false ; }
        if(UneSeuleCmdt) { Barrelu = InverseB^Etatlu ; }
                 
         if(MvtV) { }
         else { 
                if (Etatlu == Etat ) { }
                else{ 
                    Etat = Etatlu ;
                    LeServoV.attach(pinServoV);
           
                    AvanceV = vitesseV[Etat]; angleFinalV = MiniMaxV[Etat];
                    MvtV = true ;
                    }
               }

         if(MvtB) { }
         else { 
                if (Barrelu == Barre ) { }
                else{ 
                    Barre = Barrelu ;
                    LeServoB.attach(pinServoB);
           
                    AvanceB = vitesseB[Barre]; angleFinalB = MiniMaxB[Barre];
                    MvtB = true ;
                    }
               }
              
        angleV = angleV + AvanceV;      
        LeServoV.writeMicroseconds(angleV);
        Fdc = digitalRead(pinFdc);

        if (angleV == angleFinalV)
                    {
                     AvanceV = 0;
                     LeServoV.detach();
                     MvtV = false ;
                    }

        angleB = angleB + AvanceB;      
        LeServoB.writeMicroseconds(angleB);

        if (angleB == angleFinalB)
                    {
                     AvanceB = 0;
                     LeServoB.detach();
                     MvtB = false ;
                    } 

        if(!MvtV) {
                  if (Temoin) {digitalWrite (pinVerrou,Temoin);}
                  if (!Temoin && Fdc ) {digitalWrite (pinVerrou,Temoin); Defaut = false ;}
                  if (!Etat && !Fdc ) { Defaut = true ; }
                  if (Defaut){while(true){
                                 if(millis()-Periode > 100 ){Clign = !Clign ; Periode = millis(); }
                                 digitalWrite (pinDefaut,Clign);
                                         }
                                }
                  }
                      else { digitalWrite (pinDefaut,LOW); }
      
        delay(3);
    }

[NANAR]

Et ça fonctionne !!!!

[jeanjacques]