LOCODUINO

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

jeudi 23 novembre 2017

17 visiteurs en ce moment

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

. Par : JPClaude

Nous proposons dans cet article la réalisation d’un décodeur d’ aiguillages à solénoïdes sur une base d’Arduino NANO aussi bien en mode TCO (et oui on peut s’amuser sans avoir le DCC  ) pour quatre aiguillages avec leurs boutons et leurs leds de positionnement, qu’en mode DCC   pour huit aiguillages et une extension avec la bibliothèque de Thierry pour Arduino MEGA qui permet d’avoir jusqu’à 32 aiguillages. On présente d’abord de façon rapide le principe des aiguillages à solénoïdes, puis les interfaces possibles de commande de ces derniers, enfin les réalisations de ces décodeurs et des idées de réalisation de cartes. En fin d’article vous trouverez également un petit circuit qui permet de protéger les bobines en cas de dysfonctionnement (bouton coincé ou circuit intégré qui dégénère), cela m’est arrivé avec un ULN2803A qui a maintenu ses sorties du fait d’une mauvaise soudure (adieu pour la bobine concernée).

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 bobines demandent un fort courant (500mA à 2A pour certain modèle) mais sur un laps de temps très court sous peine de voir griller les bobines. Il existe plusieurs types d’aiguillage, les simples à deux directions, les triples à trois directions et les TJD (Traversée Jonction Double) à quatre positions. Un aiguillage simple est composé d’un moteur, les aiguillages triples de deux moteurs, on peut aller jusqu’à quatre moteurs pour des TJD. Dans tous les cas il suffit de savoir générer la bonne impulsion pour faire varier un des moteurs.
Par exemple dans le cas d’un simple aiguillage il suffit d’envoyer l’impulsion sur une des bobines pour faire varier la position de l’aiguillage. Il suffit de deux broches (une pour chaque sens) et une adresse DCC   (DCC  /0 et DCC/1).
Dans le cas d’aiguillage triple il faut commander deux moteurs. Il faut donc 4 broches et deux adresses DCC. N’ayant que trois directions, il faut faire attention au mouvement des aiguilles. Par exemple dans le cas des aiguillages PECO type SL99 il faut respecter la table de vérité suivante :

Il y donc une position interdite. Il faut faire attention lorsque l’on branche les points A, B, C et D sur les broches de l’Arduino.

La commande des aiguillages à solénoïdes

Nous ne parlons ici que des aiguillages à solénoïdes. Ces aiguillages demandent une impulsion entre 500mA et 2A pour les plus gros mais avec une courte durée de 50 à 300ms généralement. Il y a donc deux aspects à prendre en compte, le premier est la durée, c’est à l’Arduino de gérer cette durée, le second est de générer un courant suffisant, que l’Arduino ne peut fournir, par une interface en sortie des broches de l’Arduino.

Durée de l’impulsion

Elle ne pose aucun problème puisque prise en compte dans la bibliothèque UAD, il suffit donc de déterminer la durée en ms et de fournir cette valeur au programme.

Génération du courant d’impulsion

Il existe plusieurs possibilités pour réaliser cette génération, les relais, l’interface L298N, le L9110 ou l’interface ULN2803A. On trouve l’ensemble de ces composants pour quelques Euros. Je souligne que je n’ai pas utilisé le L293D car il monopolise trop de broches sur le MEGA.

Les relais

On trouve des interfaces qui vont de 2 à 16 relais à 1RT. Ce qui veut dire qu’un seul relais ne peut commander qu’une seule bobine, il faut donc deux relais pour un moteur d’aiguillage. Chaque broche INx est reliée à une broche de l’Arduino. Lorsque la broche est haute (HIGH) le relais est au repos et lorsqu’elle est basse (LOW) le relais travaille.

Les bornes du relais sont les suivantes :

  • GND : la masse de l’Arduino
  • VCC : le 5V de l’Arduino
  • IN1 à INx : les broches de commande des relais, connectées aux broches digitales de l’Arduino, actives quand LOW.
  • STRAP : si le strap est mis on utilise le 5v de l’Arduino, les optocoupleurs sont shuntés, si on enlève le strap il faut fournir une tension (5V ou 12V suivant le type de relais), dans ce cas les optocoupleurs agissent et isolent l’Arduino.
  • COMMUN : alimentation du relais (jusqu’à 220V et 10A !!), le commun des bobines.
  • Permanent : sortie permanente du relais (position repos)
  • Commuté : sortie commutée du relais (position travail), l’entrée d’une bobine

Les relais permettent d’avoir de forte puissance et donc de s’adapter à tout type d’aiguillage, mais ont l’inconvénient d’être bruyants et consommateurs d’énergie. La consommation est de 70mA par relais actionné.

Voici la connexion pour un aiguillage

L’interface L298N

Cette interface contient un double pont H, il peut contrôler deux moteurs CC ou un moteur pas à pas. Ce module supporte des courants de 3A max (2A en fonctionnement continu). La puissance maximale est de 25W. Il possède des diodes de protection rapide pour le pont en H et une grande capacité de filtrage. Ce module coûte moins de 5€.

Les bornes sont les suivantes :

  • 1 : - de la bobine 1 du moteur 1
  • 2 : - de la bobine 2 du moteur 1
  • 3 : strap 12V, il faut l’enlever si on utilise une tension supérieure à 12V (35V max)
  • 4 : tension du moteur (enlever le strap si supérieur à 12V), le + commun des moteurs
  • 5 : GND, relier les masses de l’Arduino et de l’alimentation externe
  • 6 : sortie 5V si le strap est mis (peut alimenter l’Arduino)
  • 7 : enable jumper pour le moteur 1 (à connecter dans le cas PWM  ), laisser le strap ici
  • 8, 9, 10, 11 : les entrées de commande de l’Arduino, actives quand LOW
  • 12 : enable jumper pour le moteur 2 (à connecter dans le cas PWM  ), laisser le strap ici
  • 13 : - de la bobine 1 du moteur 2
  • 14 : - de la bobine 2 du moteur 2

Ce petit module est très intéressant car d’un coût très faible et permettant de gérer des aiguilles à forte demande d’intensité, comme les moteurs PECO. Il ne demande que 36mA au maximum par broche.

Voici la connexion pour un aiguillage

L’interface L9110

Ce composant permet de contrôler un moteur CC (c’est un pont en H). Il admet des tensions entre 2,5V et 12V pour une intensité de 800mA par sortie en continu. (Je remercie Denis qui m’a fait connaitre ce composant). Le schéma est le suivant :

IA et IB sont les commandes des sorties OA et OB respectivement, actives quand LOW.
et le schéma de connection est le suivant :

La bobine 1 est activée quand IA est LOW et la bobine 2 quand IB est LOW.

L’interface ULN2803A

Ce composant offre 8 sorties en Darlington pour une tension de 50V max et 500mA par sortie (attention pas de mélange de tension en sortie). Sa structure est simple comme le montre le schéma suivant :

Les connections sont des plus faciles, il faut relier les entrées 1 à 8 aux broches de commande de l’Arduino, actives quand HIGH, les sorties 1 à 8 aux moins des bobines et la broche 10 au plus des moteurs (diodes anti-retour).
Afin d’avoir plus d’intensité on peut relier deux sorties entre elles ce qui permet d’avoir 1A, mais attention pas plus sinon ça chauffe !!.

Voici la connexion pour un aiguillage

Conclusion

On a donc à notre disposition un panel large pour gérer nos aiguillages que l’on peut résumer de la manière suivante :

Réalisation d’un décodeur pour 4 aiguillages à solénoïdes en mode TCO (sans DCC)

Dans ce mode 4 aiguillages peuvent être contrôlés par 4 boutons et 8 leds qui fournissent au TCO la position des aiguilles. Les commandes des moteurs pour cet exemple sont faites via des ULN2803A qui ont l’avantage d’être simple à mettre en place et qui fournissent un courant d’un ampère pour une tension max de 35V. Le schéma de principe est le suivant :

Chaque bouton est une bascule qui change la position d’un aiguillage et allume la led correspondante. Les leds sont commandées par 4 ports de l’Arduino, une partie des leds (bobine1) sont commandées au plus, l’autre partie (bobine2) est commandé au moins. Pour ceux qui le souhaitent voici une idée de carte à réaliser. Les borniers d’aiguillages permettent de connecter les bobines des aiguillages, les borniers leds permettent de connecter les leds du TCO (en tenant compte des polarités) et les borniers boutons pour les boutons du TCO en mode PULLUP :

Le programme INO est le suivant (fichier cde_aiguillage_Nano_TCO) :

  1. /*
  2.  * commande de 4 aiguillages sur Arduino UNO/NANO sans DCC avec bouton et led pour TCO
  3. * les boutons sont traites avec anti-rebond
  4.  * Les leds indiquent la position de l'aiguillage sur le TCO
  5.  * Configuration :
  6.  * aiguillage 1 : bobine1 : broche 3, bobine2 : broche 4
  7.  * aiguillage 2 : bobine1 : broche 5, bobine2 : broche 6
  8.  * aiguillage 3 : bobine1 : broche 7, bobine2 : broche 8
  9.  * aiguillage 4 : bobine1 : broche 9, bobine2 : broche 10
  10.  * led aiguillage 1 : broche 11
  11.  * led aiguillage 2 : broche 12
  12.  * led aiguillage 3 : broche 13
  13.  * led aiguillage 4 : broche A0
  14.  * bouton aiguillage 1 : broche A1
  15.  * bouton aiguillage 2 : broche A2
  16.  * bouton aiguillage 3 : broche A3
  17.  * bouton aiguillage 4 : broche A4
  18.  *
  19.  */
  20.  
  21. /******************************************************************************************
  22.  *
  23.  * LES PARAMETRES DE CONFIGURATION a definir par l'utilisateur
  24.  * CONSOLE : pour avoir le deroulement du programme, si pas necessaire supprimer la ligne
  25. * *********************************************************************************************/
  26.  
  27. #define CONSOLE // sortie console du deroulement
  28. #define DEBIT_CONSOLE 115200 // le debit de la console
  29. #define ACTIVATION 250 // duree d'activation des bobines en ms ( a modifier si necessaire)
  30.  
  31. /***********************************************************************************************
  32.   *
  33.   * LES PARAMETRES INTERNES
  34.   *
  35.   * ************************************************************************************************/
  36.  
  37. #define DELAI_ANTI_REBOND 50
  38.  
  39. /////////////////// LES AIGUILLAGES ///////////////////////////////////////////////////////
  40.  
  41. #define FIRST_PIN 3 // broche de depart des aiguillages
  42.  
  43. //// STRUCTURE D'UN AIGUILLAGE ////
  44.  
  45. struct TurnOut {
  46. int position_actuelle; // etat, bobine1 ou bobine2
  47. int bobine1; // broche bobine 1
  48. int bobine2; // broche bobine 2
  49. int bouton; // broche du bouton TCO a bascule
  50. int etat_bouton;
  51. int ledBobine; // broche de la Led TCO pour les bobines
  52. boolean demande_activation; // demande d'activation, bouton bascule
  53. };
  54. #define NB_TURNOUT 4 // le nombre d'aiguillages
  55. TurnOut turnout[NB_TURNOUT]; // l'ensemble des aiguillages
  56.  
  57. /********************************************************************
  58.  *
  59.  * METHODE APPELEE SI UNE DEMANDE DE MISE A JOUR PAR LE BOUTON
  60.  * Determine periodiquement les bobines a activer
  61.  *
  62.  *******************************************************************/
  63.  
  64. void activation_aiguillage(int i) {
  65. int etat = turnout[i].position_actuelle;
  66. if (turnout[i].demande_activation == true) // si l'aiguillage i est en attente d'activation
  67. {
  68. if (turnout[i].position_actuelle==HIGH){ // bobine 1 --> bobine 2
  69. digitalWrite(turnout[i].bobine2,HIGH); // activation
  70. delay(ACTIVATION); // duree de l'activation
  71. digitalWrite(turnout[i].bobine2,LOW); // arret de l'activation
  72. digitalWrite(turnout[i].ledBobine, LOW);
  73. etat = LOW;
  74. #ifdef CONSOLE
  75. Serial.print("activation -> aiguillage");Serial.print(i);Serial.println(" : bobine2");
  76. #endif
  77. }
  78. else{ // bobine 2 --> bobine 1
  79. digitalWrite(turnout[i].bobine1,HIGH); // activation
  80. delay(ACTIVATION); // duree de l'activation
  81. digitalWrite(turnout[i].bobine1,LOW); // arret de l'activation
  82. digitalWrite(turnout[i].ledBobine, HIGH);
  83. etat = HIGH;
  84. #ifdef CONSOLE
  85. Serial.print("activation -> aiguillage");Serial.print(i);Serial.println(" : bobine1");
  86. #endif
  87. }
  88. }
  89. turnout[i].position_actuelle = etat; // etat de la bascule
  90. turnout[i].demande_activation = false; // l'aiguillage a etait traite
  91. }
  92.  
  93.  
  94. /*************************************************************************************
  95.  *
  96.  * METHODE de test des boutons avec anti rebond
  97.  * determine si un aiguillage est concerne par l'appui d'un bouton
  98.  *
  99.  ***********************************************************************************/
  100.  
  101. boolean boutonTest(int i)
  102. { turnout[i].demande_activation = false;
  103. int etat = digitalRead(turnout[i].bouton);
  104. int tempo = millis();
  105. while ((millis() - tempo) < DELAI_ANTI_REBOND) {}
  106. if (etat == LOW){turnout[i].demande_activation = true;}
  107. return turnout[i].demande_activation;
  108. }
  109.  
  110. /**********************************************************************************************
  111.  *
  112.  * le setup
  113.  * initialise les aiguillages
  114. *
  115. ******************************************************************************************/
  116.  
  117. void setup() {
  118. int decal = 0;
  119. for (int i=0; i<NB_TURNOUT; i++){ // pour tous les aiguillages
  120. turnout[i].demande_activation = false; // pas de demande d'activation
  121. turnout[i].position_actuelle = HIGH; // par defaut sur bobine 1
  122.  
  123. turnout[i].bobine1 = decal+FIRST_PIN; // numero de broche de la bobine 1
  124. pinMode(turnout[i].bobine1, OUTPUT); // bobine 1 en sortie
  125. digitalWrite(turnout[i].bobine1, LOW); // bobine 1 au repos
  126.  
  127.  
  128. turnout[i].bobine2 = 1+decal+FIRST_PIN; // numero de la broche de la bobine 2
  129. pinMode(turnout[i].bobine2, OUTPUT); // bobine 2 en sortie
  130. digitalWrite(turnout[i].bobine2, LOW); // bobine 2 au repos
  131.  
  132.  
  133. turnout[i].ledBobine = FIRST_PIN + i +8; // les led du TCO
  134. pinMode(turnout[i].ledBobine, OUTPUT);
  135. digitalWrite(turnout[i].ledBobine,HIGH); // bobine 1 allumee par defaut
  136. delay(ACTIVATION);
  137. digitalWrite(turnout[i].ledBobine,LOW);
  138. delay(ACTIVATION);
  139. digitalWrite(turnout[i].ledBobine,HIGH);
  140.  
  141. turnout[i].bouton = FIRST_PIN + i +12; // le bouton du TCO
  142. pinMode(turnout[i].bouton,INPUT_PULLUP);
  143. turnout[i].etat_bouton = HIGH;
  144.  
  145. decal+=2; // on passe aux aiguillages suivants
  146. }
  147.  
  148. #ifdef CONSOLE
  149. Serial.begin(DEBIT_CONSOLE);
  150. for (int i=0; i<NB_TURNOUT; i++){
  151. Serial.print("aiguillage");Serial.println(i);
  152. Serial.print("\t bobine 1 sur broche : ");Serial.println(turnout[i].bobine1);
  153. Serial.print("\t bobine 2 sur broche : ");Serial.println(turnout[i].bobine2);
  154. Serial.print("\t bouton TCO sur broche : ");Serial.println(turnout[i].bouton);
  155. Serial.print("\t Led TCO sur broche : ");Serial.println(turnout[i].ledBobine);
  156. }
  157. #endif
  158. }
  159.  
  160. /*************************************************************************
  161.  * boucle
  162.  *
  163.  ******************************************************************/
  164.  
  165. void loop() {
  166. for (int i = 0;i<NB_TURNOUT;i++) {if (boutonTest(i)) activation_aiguillage(i);}

Télécharger

Un exemple de séquence :

aiguillage0
bobine 1 sur broche : 3
bobine 2 sur broche : 4
bouton TCO sur broche : 15
Led TCO sur broche : 11
aiguillage1
bobine 1 sur broche : 5
bobine 2 sur broche : 6
bouton TCO sur broche : 16
Led TCO sur broche : 12
aiguillage2
bobine 1 sur broche : 7
bobine 2 sur broche : 8
bouton TCO sur broche : 17
Led TCO sur broche : 13
aiguillage3
bobine 1 sur broche : 9
bobine 2 sur broche : 10
bouton TCO sur broche : 18
Led TCO sur broche : 14
activation -> aiguillage0 : bobine2
activation -> aiguillage0 : bobine1
activation -> aiguillage1 : bobine2
activation -> aiguillage1 : bobine1
activation -> aiguillage2 : bobine2
activation -> aiguillage2 : bobine1
activation -> aiguillage3 : bobine2
activation -> aiguillage3 : bobine1

Réalisation d’un décodeur pour 8 aiguillages à solénoïdes en mode DCC

Si on utilise le mode DCC, on récupère les ports utilisés par les boutons et les leds pour augmenter les possibilités à 8 aiguillages. Le schéma de principe devient le suivant :

Et une idée de carte à réaliser :

decodeur 8 aiguillages DCC sur NANO

et sa réalisation :

Le programme INO est le suivant (fichier cde_aiguillage_Nano_DCC) :

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

Télécharger

Et un exemple de séquences :

aiguillage0 , code DCC : 40
bobine 1 sur broche : 3
bobine 2 sur broche : 4
aiguillage1 , code DCC : 41
bobine 1 sur broche : 5
bobine 2 sur broche : 6
aiguillage2 , code DCC : 42
bobine 1 sur broche : 7
bobine 2 sur broche : 8
aiguillage3 , code DCC : 43
bobine 1 sur broche : 9
bobine 2 sur broche : 10
aiguillage4 , code DCC : 44
bobine 1 sur broche : 11
bobine 2 sur broche : 12
aiguillage5 , code DCC : 45
bobine 1 sur broche : 13
bobine 2 sur broche : 14
aiguillage6 , code DCC : 46
bobine 1 sur broche : 15
bobine 2 sur broche : 16
aiguillage7 , code DCC : 47
bobine 1 sur broche : 17
bobine 2 sur broche : 18
activation -> aiguillage0 : bobine2
activation -> aiguillage0 : bobine1
activation -> aiguillage1 : bobine2
activation -> aiguillage1 : bobine1
activation -> aiguillage2 : bobine2
activation -> aiguillage2 : bobine1
activation -> aiguillage3 : bobine2
activation -> aiguillage3 : bobine1

Réalisation d’un décodeur pour Arduino MEGA en mode DCC avec la bibliothèque UAD

Avec l’utilisation d’un Arduino MEGA le nombre d’aiguillages explose et peut aller jusqu’à 32 !!!
Nous utilisons ici la bibliothèque UAD de Thierry qui va nous faciliter la configuration du décodeur.
Comme on a pu le voir précédemment, suivant les interfaces il faut envoyer des commandes soit en mode « HIGH » soit en mode « LOW ». Pour cela le programme fournit deux méthodes de setup l’une pour des commandes en mode « HIGH » l’autre pour des commandes en mode « LOW » soit en mode TCO (SetupDigital, SetupDigital_Inverted) soit en mode DCC (SetupDccDigital, SetupDccDigital_Inverted) . Dans notre cas particulier la méthode SetupDigital s’applique uniquement à l’interface avec les ULN2803A, dans les autres cas (relais, ULN298N) la méthode SetupDigital_Inverted doit être appelée, ce qui veut dire qu’il peut y avoir mélange de relais et d’ULN298N mais pas d’ULN2803A. Le programme INO se base sur une classe turnOut donnée en fin d’article (fichier turnOut).

Voici un schéma de principe pour contrôler 16 aiguillages à base d’ULN2803A :

Au centre les 16 pins allant vers les broches de l’Arduino.

Et une idée de carte à réaliser :

En mode TCO il y a un bouton par aiguillage, deux leds pour les positions d’un aiguillage et ses deux bobines, soit 5 broches par aiguillage. Pour la première commande d’aiguillage on obtient donc :
Bouton sur la broche 3,
led bobine1 sur la broche 4,
led bobine2 sur la broche 5,
bobine1 sur la broche 6,
et bobine2 sur la broche 7,
et ainsi de suite.
En mode DCC il n’y a qu’un bouton de test (par défaut sur la broche A15) et une led témoin sur la broche 53, on obtient donc la séquence suivante :
Bobine1 sur broche 3,
Bobine2 sur broche 4,
Et ainsi de suite.

Le programme INO en mode TCO

  1. /*
  2.  * decodeur pour des aiguilles à solenoide et a 2 positions sur Arduino MEGA
  3.  * en mode TCO
  4.  * bouton : pin x
  5.  * led bobine 1 : pin x + 1
  6.  * led bobine 2 : pin x + 2
  7.  * bobine 1 : pin x + 3
  8.  * bobine 2 : pin x + 4
  9.  *
  10.  */
  11.  
  12. /********************************************************************
  13.  * PARAMETRES DE CONFIGURATION
  14.  *
  15.  *********************************************************************/
  16. #define NB_TURN_OUT 4 // nombre d'aiguillages
  17. #define ACTIVATION 250 // activation des bobines de 250 ms
  18.  
  19.  
  20. /**********************************************************************
  21.  * LES PARAMETRES INTERNES
  22.  *
  23.  *************************************************************************/
  24.  
  25. #include <UniversalAccessoryDecoder.h> // la biliotheque UAD
  26. #include "TurnOut.h" // la classe des aiguillages
  27.  
  28. TurnOut aiguilles; // une instance des aiguillages
  29.  
  30. /*
  31.  * pour le setup il faut donner :
  32.  * le nombre d'aiguille
  33.  * la duree d'activation de l'aiguille
  34.  * par defaut la tension est MAX = 255
  35.  * on peut modifier cette valeur comme troisieme argument du setup
  36.  *
  37.  */
  38. void setup() {
  39. aiguilles.SetupDigital(NB_TURN_OUT,ACTIVATION); // commande = HIGH
  40. //aiguilles.SetupDigital_Inverted(NB_TURN_OUT,ACTIVATION); // ou commande = LOW
  41. }
  42.  
  43. /*
  44.  * la boucle se limite a une methode
  45.  */
  46. void loop() {aiguilles.Loop();}

Télécharger

et le même en mode DCC :

  1. /*
  2.  * decodeur pour des aiguilles à solenoide et a 2 positions sur Arduino MEGA
  3.  * en mode DCC
  4.  * base sur le project: <DCC Accessory Decoder> de Thierry PARIS
  5.  *
  6.  * aiguille y : bobine1 pin x (IdDccy/0), bobine2 pin x+1 (IdDccy/1)
  7.  * nombre max d'aiguille y
  8.  *
  9.  * interruption int0 pour le DCC sur pin 2
  10.  *
  11.  */
  12.  
  13. /********************************************************************
  14.  * PARAMETRES DE CONFIGURATION
  15.  *
  16.  *********************************************************************/
  17. #define NB_TURN_OUT 4 // nombre d'aiguillages
  18. #define ID_DCC 40 // adresse DCC de depart du premier aiguillage
  19. #define ACTIVATION 250 // activation de 250ms
  20.  
  21.  
  22. /**********************************************************************
  23.  * LES PARAMETRES INTERNES
  24.  *
  25.  *************************************************************************/
  26.  
  27. #include <UniversalAccessoryDecoder.h> // la biliotheque UAD
  28. #include "TurnOut.h" // la classe des aiguillages
  29.  
  30. TurnOut aiguilles; // une instance des aiguillages
  31.  
  32. /*
  33.  * pour le setup il faut donner :
  34.  * le nombre d'aiguille
  35.  * l'adresse de debut DCC
  36.  * la duree d'activation de l'aiguille
  37.  * par defaut la tension est MAX = 255
  38.  * on peut modifier cette valeur comme quatrieme argument du setup
  39.  * par defaut la broche de la led de test DCC est a la broche 53,
  40.  * on peut modifier cette valeur comme cinquieme argument du setup
  41.  * la broche du bouton est par defaut en A15,
  42.  * on peut modifier cette valeur en sixieme argument du setup
  43.  *
  44.  */
  45. void setup() {
  46. aiguilles.SetupDccDigital_Inverted(NB_TURN_OUT,ID_DCC,ACTIVATION); // commande = LOW
  47. //aiguilles.SetupDccDigital(NB_TURN_OUT,ID_DCC,ACTIVATION); // ou commande = HIGH
  48. }
  49.  
  50. /*
  51.  * la boucle se limite a une methode
  52.  */
  53. void loop() {aiguilles.LoopDcc();}

Télécharger

et un exemple de séquences

Universal Accessories Decoder V4.14.
Developed by Thierry Paris.

*** Setup started.
ButtonsCommander Setup
*** Setup Finished. Memory used = 545 bytes

Avec le bouton de test

DCCToggle : Accessory 0 DccId 40 / 0
AccessoryMotor MoveToggle() : DriverPortArduino 3 MoveLeftDir() at speed 255
255
DriverPortArduino 3 MoveStop()
DCCToggle : Accessory 1 DccId 40 / 1
AccessoryMotor MoveToggle() : DriverPortArduino 4 MoveLeftDir() at speed 255
255
DriverPortArduino 4 MoveStop()

Avec des commandes DCC

DCCToggle : Accessory 1 DccId 40 / 1
AccessoryMotor MoveToggle() : DriverPortArduino 4 MoveRightDir() at speed 255
DriverPortArduino 4 MoveStop()

DCCToggle : Accessory 0 DccId 40 / 0
AccessoryMotor MoveToggle() : DriverPortArduino 3 MoveRightDir() at speed 255
DriverPortArduino 3 MoveStop()

Circuit de protection des solénoïdes

Le circuit suivant permet de protéger l’alimentation des bobines en fournissant une décharge capacitive lors de l’appel et en protégeant les bobines par la durée de recharge du condensateur de l’ordre de 100 ms en laissant un courant de fuite limité à 13,5 mA admissible par les bobines.

Circuit de protection des bobines

L’entrée consiste en une alimentation continue entre 12 et 20 V (ajouter un pont de diode en cas d’alimentation alternative).
En sortie, il faut relier la borne positive au commun des aiguillages et la borne négative au GND de l’Arduino.

Conclusion

Pour un très faible coût et des interfaces de puissance simples il est possible de créer des décodeurs d’aiguillages à solénoïdes. Les programmes sont simples et permettent de réaliser rapidement ces décodeurs sans rentrer dans la complexité de la réalisation logicielle. L’ensemble des possibilités présentées ont été testées sur une console ECOS pour le DCC et fonctionnent parfaitement… Vous trouverez ici bas les programmes et une idée de typons pour réaliser les cartes.

commande aiguillages NANO TCO


commande aiguillages NANO DCC


commande aiguillages MEGA


idées de typons

33 Messages

Réagissez à « Décodeur pour aiguillage à solénoïdes sur Arduino »

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

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

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

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)

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)

Les derniers articles

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


Christian

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


Jean-Luc

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


Christian

Réalisation d’un affichage de gare ARRIVEE DEPART


Gilbert

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


Daniel

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


Jean-Luc

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


bobyAndCo

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


Pierre59

Un décodeur DCC pour 16 feux tricolores


Dominique, JPClaude, Thierry

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


bobyAndCo

Les articles les plus lus

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

Réalisation d’un affichage de gare ARRIVEE DEPART

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

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

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

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

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

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

La rétro-signalisation sur Arduino

Une barrière infrarouge