LOCODUINO

Aide
Forum de discussion
Dépôt GIT Locoduino
Flux RSS

jeudi 28 mars 2024

Visiteurs connectés : 92

Décodeur pour aiguillage à solénoïdes sur Arduino

. Par : JPClaude

Principe des aiguillages à solénoïdes Ces aiguillages sont basés sur des moteurs à deux bobines avec un barre en fer doux attirée d’un côté ou de l’autre en fonction de l’alimentation d’une des bobines. Le principe est donc simple, si on alimente une bobine l’aiguille se déplace dans un sens, si on alimente l’autre elle se déplace dans (...)

Retourner à l'article

Vous répondez à :

Décodeur pour aiguillage à solénoïdes sur Arduino 15 février 2017 14:55, par JPClaude

Bonjour,
visiblement vous voulez gérer des aiguillages doubles du type PECO.
Je n’ai pas beaucoup de temps en ce moment mais voici un programme qui peut répondre à votre problème (je n’ai pas eu le temps de le tester in situ).
Bien cordialement.

    /*
     * decodeur de 4 aiguillages double sur Arduino UNO/NANO
     * Les aiguillages sont commandes par des sorties sur les broches a partir de la broche 3 par quadruple (aiguillage double 1 =  (3,4,5,6) etc...)
     * adresse premier aiguillage paire (X), adresse second aiguillage impaire (X+1)
     * ces sorties peuvent etre utilisees directement pour commander des ULN2803 ou les inputs de relais ou L298N 
     * 
     */
     
    /******************************************************************************************
     * 
     * LES PARAMETRES DE CONFIGURATION a definir par l'utilisateur
     * CONSOLE : pour avoir le deroulement du programme, si pas necessaire supprimer la ligne
     * FIRST_ID_DCC : premiere adresse DCC de depart, premier aiguillage (FIRST_ID_DCC sur broche 3), second aiguillage (FIRST_ID_DCC+1 sur broche 4, etc..)
     * NB_TURNOUT : le nombre d'aiguillages = 4
     * 
     *********************************************************************************************/
     
     #define CONSOLE                         // sortie console du deroulement
     #define DEBIT_CONSOLE    115200         // le debit de la console
     #define FIRST_ID_DCC      40            // ID DCC de départ
    #define ACTIVATION        250           // duree d'activation des bobines en ms ( a modifier si necessaire)
    #define NB_TURNOUT        4             // le nombre  d'aiguillages 
     /***********************************************************************************************
      * 
      * LES PARAMETRES INTERNES
      * 
      * ************************************************************************************************/
     
    //////////////////// LE DCC  /////////////////////////////////////////////////////////////////
     
    #include <DCC_Decoder.h>                 // la bibliothèque de Minabay
    #define kDCC_INTERRUPT    0             // la pin 2 qui recoit les interruptions du signal DCC
    int adresse_precedente = 0;             // evite les commandes multiples DCC
    int ancienne_position = 2;
    volatile boolean MAJ_activation;        // si des MAJ a faire apres controle du DCC
     
    /////////////////// LES AIGUILLAGES  ///////////////////////////////////////////////////////
     
    #define FIRST_PIN         3             // broche de depart des aiguillages
    #define BOBINE1           0             // adresse DCC/0
    #define BOBINE2           1             // adresse DCC/1 
    
     
    //// STRUCTURE D'UN AIGUILLAGE ////
     
    struct TurnOutDouble {
      int adresse;                      // son adresse DCC premier aiguillage DCC (paire), [on deduit le second aiguillage DCC+1 (impaire)]
      int position_actuelle_A;          // directe / deviee premier aiguillage (0,1)
      int bobine_A1;                    // broche bobine 1 premiere aiguille 
      int bobine_A2;                    // broche bobine 2 premiere aiguille
      int position_actuelle_B;          // directe / deviee second aiguillage (0,1)
      int bobine_B1;                    // broche bobine 1 second aiguille 
      int bobine_B2;                    // broche bobine 2 seconde aiguille
      boolean attente;                  // attente de la deuxieme adresse
      boolean demande_activation;       // true, false
    };
    TurnOutDouble  turnout[NB_TURNOUT];      // l'ensemble des aiguillages
     
    /********************************************************************
     * 
     * METHODE APPELEE SI UNE DEMANDE DE MISE A JOUR PAR LE DCC
     * Determine periodiquemùent les bobines a activer
     * 
     *******************************************************************/
     
    void activation_aiguillage() {
     
      for (int i = 0; i < NB_TURNOUT; i++)                                  // on balaie tous les aiguillages
      {
        if (turnout[i].demande_activation) {                                // si un des deux aiguillages a modifier
         if (turnout[i].attente) {                                          // si en attente activation
            if (turnout[i].position_actuelle_A == BOBINE1) {                // bobine A1 concernee
                              digitalWrite(turnout[i].bobine_A1,HIGH);      // activation
                              delay(ACTIVATION);                            // duree de l'activation
                              digitalWrite(turnout[i].bobine_A1,LOW);       // arret de l'activation
                              #ifdef CONSOLE
                                   Serial.print("activation -> premier aiguillage");Serial.print(i);Serial.println(" : bobine_A1");
                              #endif
                            }
                     else {                                                 // si bobine A2
                              digitalWrite(turnout[i].bobine_A2,HIGH);      // activation
                              delay(ACTIVATION);                            // duree de l'activation
                              digitalWrite(turnout[i].bobine_A2,LOW);       // arret de l'activation
                              #ifdef CONSOLE
                                  Serial.print("activation -> premier aiguillage");Serial.print(i);Serial.println(" : bobine_A2");
                              #endif
                            }
          if (turnout[i].position_actuelle_B == BOBINE1) {                    // si bobine B1
                              digitalWrite(turnout[i].bobine_B1,HIGH);        // activation
                              delay(ACTIVATION);                              // duree de l'activation
                              digitalWrite(turnout[i].bobine_B1,LOW);         // arret de l'activation
                              #ifdef CONSOLE
                                   Serial.print("activation -> second aiguillage");Serial.print(i);Serial.println(" : bobine_B1");
                              #endif
                          }
                     else {                                                   // si bobine B2
                              digitalWrite(turnout[i].bobine_B2,HIGH);        // activation
                              delay(ACTIVATION);                              // duree de l'activation
                              digitalWrite(turnout[i].bobine_B2,LOW);         // arret de l'activation
                              #ifdef CONSOLE
                                  Serial.print("activation -> second aiguillage");Serial.print(i);Serial.println(" : bobine_B2");
                              #endif
                          }
                turnout[i].attente = false;                                     // on a termine le traitement
               }
           else {                                                               // sinon on attend la deuxieme activation  
                turnout[i].attente = true; 
                }                                    
         turnout[i].demande_activation = false;                                 // activation realisee      
        }
      }
   MAJ_activation = false;                                                    // on a fait toutes les MAJ
  }
     
    /************************************************************************************* 
     *  
     *  METHODE APPELEE A CHAQUE IT DU DCC
     *  determine si un aiguillage est concerne par la commande DCC
     *  
     ***********************************************************************************/
     
    void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
    {  
      address -= 1; address *= 4; address += 1; address += (data & 0x06) >> 1;    // decodage adresse DCC
      int bobine = (data & 0x01) ? BOBINE1 : BOBINE2;             // quelle bobine est concernee DCC/bobine
      // si on change d'adresse ou de position, evite les commandes repetitives
      if ((address != adresse_precedente) | ((bobine != ancienne_position)&(address == adresse_precedente))){
        adresse_precedente = address; ancienne_position = bobine;            // evite de traiter plusieurs fois la meme commande DCC
        if ((address >= FIRST_ID_DCC) && (address < FIRST_ID_DCC + (NB_TURNOUT*2))){  // si une de nos adresses
          if ((address%2)==0){
                  address = address - FIRST_ID_DCC;                         // adresse paire = premier aiguillage
                  turnout[address].position_actuelle_A = bobine;            // on place la bobine concernee      
              }      
          else {
                  address = address - (FIRST_ID_DCC - 1);                  // adresse impaire = second aiguillage
                  turnout[address].position_actuelle_B = bobine;            // on place la bobine bobine concernee
          }
       turnout[address].demande_activation =  true;                         // demande d'activation
        }
     MAJ_activation = true;                                                // MAJ demandee 
    }
 }
    /**********************************************************************************************
     * 
     * le setup
     * initialise le DCC et les aiguillages
     * 
     ******************************************************************************************/
     
    void setup() {
      int decal = 0;
      int index = 0;
      for (int i=0; i<NB_TURNOUT; i++){                   // pour tous les aiguillages
        turnout[i].adresse = FIRST_ID_DCC + index;        // premier aiguillage : son ID DCC
        turnout[i].bobine_A1 = decal+FIRST_PIN;           // numero de broche de la bobine A1
        pinMode(turnout[i].bobine_A1, OUTPUT);            // bobine A1   en sortie (ID DCC/0)
        digitalWrite(turnout[i].bobine_A1, LOW);          // bobine A1 au repos
        turnout[i].bobine_A2 = 1+decal+FIRST_PIN;         // numero de la broche de la bobine A2
        pinMode(turnout[i].bobine_A2, OUTPUT);            // bobine A2  en sortie  (ID DCC/1)
        digitalWrite(turnout[i].bobine_A2, LOW);          // bobine A2 au repos
        turnout[i].bobine_B1 = 2+decal+FIRST_PIN;         // numero de broche de la bobine B1
        pinMode(turnout[i].bobine_B1, OUTPUT);            // bobine B1   en sortie (ID DCC+1/0)
        digitalWrite(turnout[i].bobine_B1, LOW);          // bobine B1 au repos
        turnout[i].bobine_B2 = 3+decal+FIRST_PIN;         // numero de la broche de la bobine B2
        pinMode(turnout[i].bobine_B2, OUTPUT);            // bobine B2  en sortie  (ID DCC+1/1)
        digitalWrite(turnout[i].bobine_B2, LOW);          // bobine B2 au repos
        decal+=4;                                         // on passe aux broches suivantes  
        index+=2;                                         // adresse suivante
      }
     
     /***********************************************************
    * La methode appellee par le DCC
    ******************************************/
     
    DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);     // le DCC
      DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );                                     // son IT
      MAJ_activation = false;                                  // pas de MAJ a priori
      #ifdef CONSOLE
       Serial.begin(DEBIT_CONSOLE);
       for (int i=0; i<NB_TURNOUT; i++){
        Serial.print("premier aiguillage");Serial.print(i);Serial.print(" , code DCC : ");Serial.println(turnout[i].adresse); 
        Serial.print("\t       bobine A1 sur broche : ");Serial.println(turnout[i].bobine_A1);
        Serial.print("\t       bobine A2 sur broche : ");Serial.println(turnout[i].bobine_A2);
        Serial.print("second aiguillage");Serial.print(i);Serial.print(" , code DCC : ");Serial.println(turnout[i].adresse+1); 
        Serial.print("\t       bobine B1 sur broche : ");Serial.println(turnout[i].bobine_B1);
        Serial.print("\t       bobine B2 sur broche : ");Serial.println(turnout[i].bobine_B2);
      }
      #endif
    }
     
    /*************************************************************************
     * boucle
     * 
     ******************************************************************/
     
    void loop() {
      DCC.loop();                                             // demande DCC ?
      if (MAJ_activation) {activation_aiguillage();}          // si oui activation des aiguillages
    }
Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

111 Messages

Rubrique Projets

LaBox, Une Centrale DCC polyvalente et abordable (1)

LaBox, Une Centrale DCC polyvalente et abordable (2)

LaBox, Une Centrale DCC polyvalente et abordable (3)

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Comment piloter trains et accessoires en DCC avec un Arduino (2)

Comment piloter trains et accessoires en DCC avec un Arduino (3)

Comment piloter trains et accessoires en DCC avec un Arduino (4)

SGDD : Système de Gestion DD (1)

SGDD : Système de Gestion DD (2)

SGDD : Système de Gestion DD (3)

La PWM : Qu’est-ce que c’est ? (1)

La PWM : Qu’est-ce que c’est ? (2)

La PWM : Qu’est-ce que c’est ? (3)

La PWM : Qu’est-ce que c’est ? (4)

Mise en oeuvre du Bus CAN entre modules Arduino (1)

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Un gestionnaire en C++ pour votre réseau (1)

Un gestionnaire en C++ pour votre réseau (2)

Un gestionnaire en C++ pour votre réseau (3)

Un gestionnaire en C++ pour votre réseau (4)

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Contrôleur à télécommande infrarouge pour centrale DCC++

Gestion d’une gare cachée (1)

Gestion d’une gare cachée (2)

Gestion d’une gare cachée (3)

La carte Satellite V1 (1)

La carte Satellite V1 (2)

La carte Satellite V1 (3)

La carte Satellite V1 (4)

La carte Satellite V1 (5)

Chenillard de DEL

Enseigne de magasin

Feux tricolores

Multi-animations lumineuses

L’Arduino et le système de commande numérique DCC

Un décodeur d’accessoire DCC versatile basé sur Arduino

Un moniteur de signaux DCC

Une barrière infrarouge

Un capteur RFID

Un TCO xpressnet

Une animation sonore

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Calcul de la vitesse d’un train miniature avec l’Arduino

La génèse d’un réseau 100% Arduino

Une horloge à échelle H0

Simulateur de soudure à arc

Un automatisme de Passage à Niveau

Automatisation du pont FLEISCHMANN 6152 (HO) avec un ESP32 (1)

Identifier et localiser vos trains avec le RFID/NFC et un bus CAN.

Etude d’un passage à niveau multivoies

La rétro-signalisation sur Arduino

Décodeur pour aiguillage à solénoïdes sur Arduino

Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO

Etude d’un passage à niveau universel

Réalisation pratique d’un système de mesure de vitesse à l’échelle N

Une Passerelle entre le bus S88 et le bus CAN pour la rétro signalisation

Un décodeur DCC pour 16 feux tricolores

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"

Réalisation d’un affichage de gare ARRIVEE DEPART

Ménage à trois (Ordinateur, Arduino, réseau)

Réalisation d’un va-et-vient automatique et réaliste

Souris et centrale sans fil

Communications entre JMRI et Arduino

Annonces en gare avec la RFID

Une croix de pharmacie animée avec Arduino UNO

Réalisation d’un wagon de mesure (distance et vitesse)

Passage à niveau géré par Arduino (1)

Passage à niveau géré par Arduino (2)

Passage à niveau géré par Arduino (3)

Passage à niveau géré par Arduino (4)

Passage à niveau géré par Arduino (5)

Une manette simple et autonome pour LaBox

Éclairer le réseau (1)

Éclairer le réseau (2)

Block Automatique Lumineux à 8 cantons analogiques

Un décodeur DCC pour les plaques tournantes Fleischmann et Roco

Éclairer le réseau (3)

Éclairer le réseau (4)

Éclairer le réseau (5)

JMRI pour Ma première centrale DCC

Rocrail pour Ma première centrale DCC

CDM-Rail pour Ma première centrale DCC (1)

CDM-Rail pour Ma première centrale DCC (2)

Banc de test pour les décodeurs DCC

Ma première manette pour les aiguillages DCC

Mon premier décodeur pour les aiguillages DCC

Boitier 3D pour la station DCC minimale

Va-et-vient pour deux trains

Un programme pour régler facilement les servos moteurs avec un ESP32

Affichage publicitaire avec Arduino (1)

Affichage publicitaire avec Arduino (2)

TCO Web interactif avec des ESP32 et des ESP8266 (1)

TCO Web interactif avec des ESP32 et des ESP8266 (2)

TCO Web interactif avec des ESP32 et des ESP8266 (3)

TCO Web interactif avec des ESP32 et des ESP8266 (4)

TCO Web interactif avec des ESP32 et des ESP8266 (5)

Les derniers articles

LaBox, Une Centrale DCC polyvalente et abordable (3)


Thierry

LaBox, Une Centrale DCC polyvalente et abordable (1)


Thierry

LaBox, Une Centrale DCC polyvalente et abordable (2)


Dominique, msport, Thierry

Un programme pour régler facilement les servos moteurs avec un ESP32


bobyAndCo

TCO Web interactif avec des ESP32 et des ESP8266 (5)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (4)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (3)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (2)


utpeca

TCO Web interactif avec des ESP32 et des ESP8266 (1)


utpeca

Affichage publicitaire avec Arduino (2)


catplus, Christian

Les articles les plus lus

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

La PWM : Qu’est-ce que c’est ? (1)

CDM-Rail pour Ma première centrale DCC (2)

Chenillard de DEL

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Automatisation du pont FLEISCHMANN 6152 (HO) avec un ESP32 (1)

Souris et centrale sans fil

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)

LaBox, Une Centrale DCC polyvalente et abordable (1)