LOCODUINO

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

dimanche 26 janvier 2020

14 visiteurs en ce moment

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 l’autre sens. Ces (...)

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.

  1. /*
  2.   * decodeur de 4 aiguillages double sur Arduino UNO/NANO
  3.   * 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...)
  4.   * adresse premier aiguillage paire (X), adresse second aiguillage impaire (X+1)
  5.   * ces sorties peuvent etre utilisees directement pour commander des ULN2803 ou les inputs de relais ou L298N
  6.   *
  7.   */
  8.  
  9. /******************************************************************************************
  10.   *
  11.   * LES PARAMETRES DE CONFIGURATION a definir par l'utilisateur
  12.   * CONSOLE : pour avoir le deroulement du programme, si pas necessaire supprimer la ligne
  13.   * 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..)
  14.   * NB_TURNOUT : le nombre d'aiguillages = 4
  15.   *
  16.   *********************************************************************************************/
  17.  
  18. #define CONSOLE // sortie console du deroulement
  19. #define DEBIT_CONSOLE 115200 // le debit de la console
  20. #define FIRST_ID_DCC 40 // ID DCC de départ
  21. #define ACTIVATION 250 // duree d'activation des bobines en ms ( a modifier si necessaire)
  22. #define NB_TURNOUT 4 // le nombre d'aiguillages
  23. /***********************************************************************************************
  24.   *
  25.   * LES PARAMETRES INTERNES
  26.   *
  27.   * ************************************************************************************************/
  28.  
  29. //////////////////// LE DCC /////////////////////////////////////////////////////////////////
  30.  
  31. #include <DCC_Decoder.h> // la bibliothèque de Minabay
  32. #define kDCC_INTERRUPT 0 // la pin 2 qui recoit les interruptions du signal DCC
  33. int adresse_precedente = 0; // evite les commandes multiples DCC
  34. int ancienne_position = 2;
  35. volatile boolean MAJ_activation; // si des MAJ a faire apres controle du DCC
  36.  
  37. /////////////////// LES AIGUILLAGES ///////////////////////////////////////////////////////
  38.  
  39. #define FIRST_PIN 3 // broche de depart des aiguillages
  40. #define BOBINE1 0 // adresse DCC/0
  41. #define BOBINE2 1 // adresse DCC/1
  42.  
  43.  
  44. //// STRUCTURE D'UN AIGUILLAGE ////
  45.  
  46. struct TurnOutDouble {
  47. int adresse; // son adresse DCC premier aiguillage DCC (paire), [on deduit le second aiguillage DCC+1 (impaire)]
  48. int position_actuelle_A; // directe / deviee premier aiguillage (0,1)
  49. int bobine_A1; // broche bobine 1 premiere aiguille
  50. int bobine_A2; // broche bobine 2 premiere aiguille
  51. int position_actuelle_B; // directe / deviee second aiguillage (0,1)
  52. int bobine_B1; // broche bobine 1 second aiguille
  53. int bobine_B2; // broche bobine 2 seconde aiguille
  54. boolean attente; // attente de la deuxieme adresse
  55. boolean demande_activation; // true, false
  56. };
  57. TurnOutDouble turnout[NB_TURNOUT]; // l'ensemble des aiguillages
  58.  
  59. /********************************************************************
  60.   *
  61.   * METHODE APPELEE SI UNE DEMANDE DE MISE A JOUR PAR LE DCC
  62.   * Determine periodiquemùent les bobines a activer
  63.   *
  64.   *******************************************************************/
  65.  
  66. void activation_aiguillage() {
  67.  
  68. for (int i = 0; i < NB_TURNOUT; i++) // on balaie tous les aiguillages
  69. {
  70. if (turnout[i].demande_activation) { // si un des deux aiguillages a modifier
  71. if (turnout[i].attente) { // si en attente activation
  72. if (turnout[i].position_actuelle_A == BOBINE1) { // bobine A1 concernee
  73. digitalWrite(turnout[i].bobine_A1,HIGH); // activation
  74. delay(ACTIVATION); // duree de l'activation
  75. digitalWrite(turnout[i].bobine_A1,LOW); // arret de l'activation
  76. #ifdef CONSOLE
  77. Serial.print("activation -> premier aiguillage");Serial.print(i);Serial.println(" : bobine_A1");
  78. #endif
  79. }
  80. else { // si bobine A2
  81. digitalWrite(turnout[i].bobine_A2,HIGH); // activation
  82. delay(ACTIVATION); // duree de l'activation
  83. digitalWrite(turnout[i].bobine_A2,LOW); // arret de l'activation
  84. #ifdef CONSOLE
  85. Serial.print("activation -> premier aiguillage");Serial.print(i);Serial.println(" : bobine_A2");
  86. #endif
  87. }
  88. if (turnout[i].position_actuelle_B == BOBINE1) { // si bobine B1
  89. digitalWrite(turnout[i].bobine_B1,HIGH); // activation
  90. delay(ACTIVATION); // duree de l'activation
  91. digitalWrite(turnout[i].bobine_B1,LOW); // arret de l'activation
  92. #ifdef CONSOLE
  93. Serial.print("activation -> second aiguillage");Serial.print(i);Serial.println(" : bobine_B1");
  94. #endif
  95. }
  96. else { // si bobine B2
  97. digitalWrite(turnout[i].bobine_B2,HIGH); // activation
  98. delay(ACTIVATION); // duree de l'activation
  99. digitalWrite(turnout[i].bobine_B2,LOW); // arret de l'activation
  100. #ifdef CONSOLE
  101. Serial.print("activation -> second aiguillage");Serial.print(i);Serial.println(" : bobine_B2");
  102. #endif
  103. }
  104. turnout[i].attente = false; // on a termine le traitement
  105. }
  106. else { // sinon on attend la deuxieme activation
  107. turnout[i].attente = true;
  108. }
  109. turnout[i].demande_activation = false; // activation realisee
  110. }
  111. }
  112. MAJ_activation = false; // on a fait toutes les MAJ
  113. }
  114.  
  115. /*************************************************************************************
  116.   *
  117.   * METHODE APPELEE A CHAQUE IT DU DCC
  118.   * determine si un aiguillage est concerne par la commande DCC
  119.   *
  120.   ***********************************************************************************/
  121.  
  122. void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
  123. {
  124. address -= 1; address *= 4; address += 1; address += (data & 0x06) >> 1; // decodage adresse DCC
  125. int bobine = (data & 0x01) ? BOBINE1 : BOBINE2; // quelle bobine est concernee DCC/bobine
  126. // si on change d'adresse ou de position, evite les commandes repetitives
  127. if ((address != adresse_precedente) | ((bobine != ancienne_position)&(address == adresse_precedente))){
  128. adresse_precedente = address; ancienne_position = bobine; // evite de traiter plusieurs fois la meme commande DCC
  129. if ((address >= FIRST_ID_DCC) && (address < FIRST_ID_DCC + (NB_TURNOUT*2))){ // si une de nos adresses
  130. if ((address%2)==0){
  131. address = address - FIRST_ID_DCC; // adresse paire = premier aiguillage
  132. turnout[address].position_actuelle_A = bobine; // on place la bobine concernee
  133. }
  134. else {
  135. address = address - (FIRST_ID_DCC - 1); // adresse impaire = second aiguillage
  136. turnout[address].position_actuelle_B = bobine; // on place la bobine bobine concernee
  137. }
  138. turnout[address].demande_activation = true; // demande d'activation
  139. }
  140. MAJ_activation = true; // MAJ demandee
  141. }
  142. }
  143. /**********************************************************************************************
  144.   *
  145.   * le setup
  146.   * initialise le DCC et les aiguillages
  147.   *
  148.   ******************************************************************************************/
  149.  
  150. void setup() {
  151. int decal = 0;
  152. int index = 0;
  153. for (int i=0; i<NB_TURNOUT; i++){ // pour tous les aiguillages
  154. turnout[i].adresse = FIRST_ID_DCC + index; // premier aiguillage : son ID DCC
  155. turnout[i].bobine_A1 = decal+FIRST_PIN; // numero de broche de la bobine A1
  156. pinMode(turnout[i].bobine_A1, OUTPUT); // bobine A1 en sortie (ID DCC/0)
  157. digitalWrite(turnout[i].bobine_A1, LOW); // bobine A1 au repos
  158. turnout[i].bobine_A2 = 1+decal+FIRST_PIN; // numero de la broche de la bobine A2
  159. pinMode(turnout[i].bobine_A2, OUTPUT); // bobine A2 en sortie (ID DCC/1)
  160. digitalWrite(turnout[i].bobine_A2, LOW); // bobine A2 au repos
  161. turnout[i].bobine_B1 = 2+decal+FIRST_PIN; // numero de broche de la bobine B1
  162. pinMode(turnout[i].bobine_B1, OUTPUT); // bobine B1 en sortie (ID DCC+1/0)
  163. digitalWrite(turnout[i].bobine_B1, LOW); // bobine B1 au repos
  164. turnout[i].bobine_B2 = 3+decal+FIRST_PIN; // numero de la broche de la bobine B2
  165. pinMode(turnout[i].bobine_B2, OUTPUT); // bobine B2 en sortie (ID DCC+1/1)
  166. digitalWrite(turnout[i].bobine_B2, LOW); // bobine B2 au repos
  167. decal+=4; // on passe aux broches suivantes
  168. index+=2; // adresse suivante
  169. }
  170.  
  171. /***********************************************************
  172.   * La methode appellee par le DCC
  173.   ******************************************/
  174.  
  175. DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true); // le DCC
  176. DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT ); // son IT
  177. MAJ_activation = false; // pas de MAJ a priori
  178. #ifdef CONSOLE
  179. Serial.begin(DEBIT_CONSOLE);
  180. for (int i=0; i<NB_TURNOUT; i++){
  181. Serial.print("premier aiguillage");Serial.print(i);Serial.print(" , code DCC : ");Serial.println(turnout[i].adresse);
  182. Serial.print("\t bobine A1 sur broche : ");Serial.println(turnout[i].bobine_A1);
  183. Serial.print("\t bobine A2 sur broche : ");Serial.println(turnout[i].bobine_A2);
  184. Serial.print("second aiguillage");Serial.print(i);Serial.print(" , code DCC : ");Serial.println(turnout[i].adresse+1);
  185. Serial.print("\t bobine B1 sur broche : ");Serial.println(turnout[i].bobine_B1);
  186. Serial.print("\t bobine B2 sur broche : ");Serial.println(turnout[i].bobine_B2);
  187. }
  188. #endif
  189. }
  190.  
  191. /*************************************************************************
  192.   * boucle
  193.   *
  194.   ******************************************************************/
  195.  
  196. void loop() {
  197. DCC.loop(); // demande DCC ?
  198. if (MAJ_activation) {activation_aiguillage();} // si oui activation des aiguillages
  199. }

Télécharger

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.)

60 Messages

Rubrique Projets

Un 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

Un décodeur DCC pour 16 feux tricolores

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

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)

Realisation 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

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

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

La carte Satellite V1

La carte Satellite V1

La carte Satellite V1

Les derniers articles

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


Serge

Etude d’un passage à niveau multivoies


Dominique, JPClaude

Annonces en gare avec la RFID


bobyAndCo, Catplus, Christian

La carte Satellite V1


bobyAndCo, Dominique, Jean-Luc, Thierry

La carte Satellite V1


bobyAndCo, Dominique, Jean-Luc, Thierry

La carte Satellite V1


bobyAndCo, Dominique, Jean-Luc, Thierry

La carte Satellite V1


bobyAndCo, Dominique, Jean-Luc, Thierry

Communications entre JMRI et Arduino


Dominique, Nopxor

Souris et centrale sans fil


tony04

Realisation d’un va-et-vient automatique et réaliste


Dominique

Les articles les plus lus

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

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

Une barrière infrarouge

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

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

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

Feux tricolores

Un chenillard de DEL

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

Réalisation d’un affichage de gare ARRIVEE DEPART