Un tableau de commande géré par arduino

Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 18 18:30

Un tableau de commande géré par arduino

Message par herwatFrance

Patience, patience, ça va venir ! :hellod: :hhhaaaa:
Avatar du membre
Georges de VilletteChine
2000 posts et +
2000 posts et +
Messages : 5402
Enregistré le : 09 mars 2021, 19:23
Prénom : Georges
LOCALISATION : Villette d'Anthon
Centres d'intérêts : J'ai participé au début de Mini World Lyon .
J'aime l'électronique , la mini mécanique .
Passionné par les nouvelles technologies , imprimantes 3D , Laser , CNC .
Echelle pratiquée : Aucune
Âge : 74
Pays :
Chine (cn)
Chine
avr. 2021 18 18:43

Re: Un tableau de commande géré par arduino

Message par Georges de VilletteChine

Je vais suivre ça Hervé , avec intérêt .... :cooooool:
Le travail est bien une maladie !!!
Puisqu'il y a une médecine du travail !!! Coluche .
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 18 20:56

Re: Un tableau de commande géré par arduino

Message par herwatFrance

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
IMG_2694.jpg (105.66 Kio) Vu 4168 fois
.
et le module arduino nano :
.
IMG_2695.jpg
IMG_2695.jpg (102.35 Kio) Vu 4168 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
Plan_aiguillagesNv.jpg (134.83 Kio) Vu 4168 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
IMG_2692.jpg (71.48 Kio) Vu 4168 fois
.
et ses entrailles :
.
IMG_2693.jpg
IMG_2693.jpg (118.98 Kio) Vu 4168 fois
La suite au prochain numéro . :-)
Modifié en dernier par herwatFrance le 18 avr. 2021, 21:00, modifié 1 fois.
Avatar du membre
likikiFrance
Site Admin
Site Admin
Messages : 6655
Enregistré le : 27 févr. 2021, 16:11
Prénom : Christian
LOCALISATION : Ile de France
Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
Echelle pratiquée : H0
Âge : 56
Pays :
France (fr)
France
avr. 2021 19 04:45

Re: Un tableau de commande géré par arduino

Message par likikiFrance

Voilà un sujet qui commence fort.

:cooooool:
:kingmoi:

ImageImageImage


Les dates des bourses d'échange mis a jour ==> ICI <==
Avatar du membre
Georges de VilletteChine
2000 posts et +
2000 posts et +
Messages : 5402
Enregistré le : 09 mars 2021, 19:23
Prénom : Georges
LOCALISATION : Villette d'Anthon
Centres d'intérêts : J'ai participé au début de Mini World Lyon .
J'aime l'électronique , la mini mécanique .
Passionné par les nouvelles technologies , imprimantes 3D , Laser , CNC .
Echelle pratiquée : Aucune
Âge : 74
Pays :
Chine (cn)
Chine
avr. 2021 19 06:32

Re: Un tableau de commande géré par arduino

Message par Georges de VilletteChine

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 ?
Le travail est bien une maladie !!!
Puisqu'il y a une médecine du travail !!! Coluche .
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 19 08:37

Re: Un tableau de commande géré par arduino

Message par herwatFrance

Euhhh, oui Georges .
TCO : tableau de commande optique .
Il y en a effectivement 3 sur mon réseau .
Avatar du membre
Georges de VilletteChine
2000 posts et +
2000 posts et +
Messages : 5402
Enregistré le : 09 mars 2021, 19:23
Prénom : Georges
LOCALISATION : Villette d'Anthon
Centres d'intérêts : J'ai participé au début de Mini World Lyon .
J'aime l'électronique , la mini mécanique .
Passionné par les nouvelles technologies , imprimantes 3D , Laser , CNC .
Echelle pratiquée : Aucune
Âge : 74
Pays :
Chine (cn)
Chine
avr. 2021 19 09:08

Re: Un tableau de commande géré par arduino

Message par Georges de VilletteChine

Merci Hervé .... :cooooool:
Le travail est bien une maladie !!!
Puisqu'il y a une médecine du travail !!! Coluche .
Papy2568
avr. 2021 19 09:38

Re: Un tableau de commande géré par arduino

Message par Papy2568

Il y en a effectivement 3 sur mon réseau .
3 :o
Avatar du membre
Georges de VilletteChine
2000 posts et +
2000 posts et +
Messages : 5402
Enregistré le : 09 mars 2021, 19:23
Prénom : Georges
LOCALISATION : Villette d'Anthon
Centres d'intérêts : J'ai participé au début de Mini World Lyon .
J'aime l'électronique , la mini mécanique .
Passionné par les nouvelles technologies , imprimantes 3D , Laser , CNC .
Echelle pratiquée : Aucune
Âge : 74
Pays :
Chine (cn)
Chine
avr. 2021 19 10:25

Re: Un tableau de commande géré par arduino

Message par Georges de VilletteChine

Papy2568 a écrit : 19 avr. 2021, 09:38
Il y en a effectivement 3 sur mon réseau .
3 :o
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 ? :mdr:
.
Pas sur la tête Hervé ! Pas sur la tête !!!! :hhhaaaa: :hhhaaaa: :hhhaaaa:

:sivousme:
Le travail est bien une maladie !!!
Puisqu'il y a une médecine du travail !!! Coluche .
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 19 11:12

Re: Un tableau de commande géré par arduino

Message par herwatFrance

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

ça me fera des vacances ! :hhhaaaa: :hhhaaaa: :hhhaaaa:
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 19 11:46

Re: Un tableau de commande géré par arduino

Message par herwatFrance

Pour fixer les idée;
voilà le tableau voyageur "in situ" :
IMG_2697.jpg
IMG_2697.jpg (92.28 Kio) Vu 4145 fois
.
L'emplacement du futur tableau marchandise :
IMG_2698.jpg
IMG_2698.jpg (98.41 Kio) Vu 4145 fois
.
Et le petit tableau qui gère la dérivation et provisoirement en analogique le pont tournant
IMG_2699.jpg
IMG_2699.jpg (105.89 Kio) Vu 4145 fois
.
Papy2568
avr. 2021 19 11:49

Re: Un tableau de commande géré par arduino

Message par Papy2568

Ah ok!

Je pensais que tout serait sur un même tableau... :cooooool:
Avatar du membre
Al1babaFrance
Posteur habitué
Posteur habitué
Messages : 81
Enregistré le : 11 mars 2021, 12:40
Prénom : Alain
LOCALISATION : Figeac (46)
Centres d'intérêts : Spéléo Il y a quelques années, mais plus maintenant.
L'Histoire ferroviaire. Les voyages, La Gastronomie. Le modélisme ferroviaire bien sûr après une période de modélisme naval.
Récemment : Généalogie. En attendant que ça sèche
Echelle pratiquée : H0
Pays :
France (fr)
France
avr. 2021 20 16:04

Re: Un tableau de commande géré par arduino

Message par Al1babaFrance

herwat a écrit : 18 avr. 2021, 18:30 Patience, patience, ça va venir ! :hellod: :hhhaaaa:
20 avril 2021 16:03
Ouais.... En informatique il y a 50% de préannonce! :sivousme:
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 20 17:29

Re: Un tableau de commande géré par arduino

Message par herwatFrance

Pour les impatients :mdr1:

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 . . . .
Avatar du membre
likikiFrance
Site Admin
Site Admin
Messages : 6655
Enregistré le : 27 févr. 2021, 16:11
Prénom : Christian
LOCALISATION : Ile de France
Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
Echelle pratiquée : H0
Âge : 56
Pays :
France (fr)
France
avr. 2021 20 18:19

Re: Un tableau de commande géré par arduino

Message par likikiFrance

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 ?
:kingmoi:

ImageImageImage


Les dates des bourses d'échange mis a jour ==> ICI <==
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 20 19:00

Re: Un tableau de commande géré par arduino

Message par herwatFrance

likiki a écrit : 20 avr. 2021, 18:19 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 . . . .
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 20 19:02

Re: Un tableau de commande géré par arduino

Message par herwatFrance

Je viens de faire une compilation dans l'IDE arduino, en précisant UNO , . . . Pas de souci . . .
Avatar du membre
likikiFrance
Site Admin
Site Admin
Messages : 6655
Enregistré le : 27 févr. 2021, 16:11
Prénom : Christian
LOCALISATION : Ile de France
Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
Echelle pratiquée : H0
Âge : 56
Pays :
France (fr)
France
avr. 2021 20 19:58

Re: Un tableau de commande géré par arduino

Message par likikiFrance

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

:kingmoi:
:kingmoi:

ImageImageImage


Les dates des bourses d'échange mis a jour ==> ICI <==
Papy2568
avr. 2021 20 20:05

Re: Un tableau de commande géré par arduino

Message par Papy2568

Hervé

:5:

Tu es le pro de l'arduino!
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 20 20:07

Re: Un tableau de commande géré par arduino

Message par herwatFrance

:merciiii: , Eric
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 20 20:14

Re: Un tableau de commande géré par arduino

Message par herwatFrance

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
IMG_2547.jpg (111.67 Kio) Vu 4117 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 ! :hhhaaaa: )
Avatar du membre
likikiFrance
Site Admin
Site Admin
Messages : 6655
Enregistré le : 27 févr. 2021, 16:11
Prénom : Christian
LOCALISATION : Ile de France
Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
Echelle pratiquée : H0
Âge : 56
Pays :
France (fr)
France
avr. 2021 20 20:47

Re: Un tableau de commande géré par arduino

Message par likikiFrance

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

:a_suivre:
:kingmoi:

ImageImageImage


Les dates des bourses d'échange mis a jour ==> ICI <==
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 21 21:19

Re: Un tableau de commande géré par arduino

Message par herwatFrance

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

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

Le voilà avec son premier shield maison :
.
IMG_2481.jpg
IMG_2481.jpg (124.28 Kio) Vu 4078 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é ! :D

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 ! :hhhaaaa:

Alors je dirais quand même : :a_suivre:
Papy2568
avr. 2021 21 21:58

Re: Un tableau de commande géré par arduino

Message par Papy2568

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

Ceci dit, beau boulot... :5:
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 21 22:38

Re: Un tableau de commande géré par arduino

Message par herwatFrance

:merciiii: , Eric
Répondre