LOCODUINO

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

mercredi 26 juillet 2017

28 visiteurs en ce moment

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

. Par : Christian Bézanger

Comme on l’a vu dans l’article La carte Arduino Uno, les sorties numériques délivrent très peu de courant et pour pouvoir commander certains accessoires sur un réseau, il est nécessaire de compléter les cartes Arduino par un peu d’électronique. Différentes solutions sont possibles parmi lesquelles l’utilisation de relais qui permettent de commander des courants forts à partir de courants faibles ainsi que d’assurer une parfaite isolation galvanique entre ces deux types de courants. Vous trouverez dans l’article Démarrer en électronique un cours d’électronique pour débutants où le chapitre 6 résume ce qu’il faut connaître des relais. Vous pouvez aussi consulter l’article Relais électromagnétique. Cependant, si votre projet se limite à utiliser quatre relais 1 RT (un contact repos et un contact travail par relais), il est plus simple de faire appel à la carte shield   4 Relais d’Arduino que nous allons décrire ici.

Une carte shield   disposant de 4 relais de type 1 RT

La carte "Arduino 4 Relays Shield  " est une carte au format shield, c’est-à-dire une carte dont la dimension est analogue à une carte Arduino Uno, munie de connecteurs mâles permettant de la connecter dans les connecteurs femelles de la carte Arduino. La figure 1 montre cette carte 4 relais.

Figure 1 - La carte shield 4 relais


Comme on le voit sur la figure 1, la carte dispose de 4 relais (en blanc) de type 1 RT : pour chaque relais, un contact commun peut être relié à un contact R lorsque le relais est au repos (c’est-à-dire lorsque le relais n’est pas alimenté) ou bien à un contact travail T lorsque le relais est alimenté. Le contact commun est noté C sur les connecteurs (en bleu), le contact repos est noté NC (normaly connected ou normalement connecté) et le contact travail est noté NO (normaly open ou normalement ouvert si le relais n’est pas alimenté). Les relais sont numérotés de 1 à 4 et les connecteurs associés sont au plus proche de chaque relais.

Pour commander un relais, il suffit de mettre à l’état haut (HIGH) la sortie numérique qui lui est associée. Le tableau suivant résume les sorties à utiliser pour chaque relais.

RelaisSortie N°
1 4
2 7
3 8
4 12

Les sorties à l’état haut commandent les relais par l’intermédiaire de transistors à effet de champ ; ceux-ci étant sensibles aux décharges électrostatiques, la carte shield est livrée avec ses connecteurs enfichés sur une mousse conductrice et il faut faire attention lorsqu’on manipule la carte de ne pas être porteur de charges électrostatiques (il suffit d’éviter de toucher les connecteurs mâles de la carte shield).

Le lien suivant permet d’afficher le plan de la carte shield :
http://download.arduino.org/products/4RELAYSSHIELD/Arduino-4-Relays-Shield-V1.pdf

On constate que les relais sont munis d’une diode de roue libre (en parallèle avec le bobinage) ainsi que d’une DEL   de contrôle qui s’allume lorsque le relais est commandé (qu’on peut voir en haut à gauche de la figure 1 juste sous le bouton RESET). Chaque relais consomme 35 mA, ce qui représente une consommation totale de 140 mA si on commande les quatre relais en même temps.

Tous les signaux de la carte Arduino peuvent être récupérés sur les connecteurs femelles de la carte shield (en noir sur la figure 1), ainsi que sur des connecteurs au format TinkerKit permettant la création de prototypes basés sur les modules du même nom.

Les quatre relais peuvent être utilisés comme des interrupteurs pour commander des accessoires du réseau. Les contacts sont prévus pour supporter 2 A sous 30 V ce qui correspond tout à fait aux courants utilisés en modélisme ferroviaire et comme les relais assurent une isolation galvanique avec les cartes Arduino, on peut tout à fait les utiliser pour commander du courant alternatif comme celui délivré par la sortie accessoire de notre transformateur et ainsi commander des aiguilles à solénoïdes.

Comme application pratique de cette carte shield au modélisme ferroviaire, je vous propose d’élaborer un Block Automatique Lumineux qui pourra être installé sur un circuit ferroviaire de base, comme un ovale de voie souvent proposé par les coffrets de départ. Nous allons ainsi créer sur cet ovale, quatre cantons où deux trains peuvent se suivre sans se rattraper.

Principe du Block Automatique Lumineux (B.A.L)

Le circuit ferroviaire est divisé en cantons successifs qui sont des portions de voie sur lesquelles circulent les trains. La première règle, inviolable, est la suivante :
Un canton ne peut être occupé que par un train et un seul à la fois.

Cela peut paraître évident mais la SNCF autorise parfois un train à entrer, en condition de marche à vue, sur un canton déjà occupé. Dans le cas d’un réseau de trains miniatures en exploitation analogique, la règle précédente doit être absolument respectée.

Une deuxième règle est qu’ un canton ne peut avoir que deux états possibles  : soit il est libre, soit il est occupé. S’il est libre, un train peut donc pénétrer dessus, s’il est occupé, le train ne peut pas entrer dans le canton afin de respecter la première règle.

Chaque canton possède à son entrée un signal lumineux à trois feux (vert, rouge, orange). Si le signal est vert (voie libre VL), les deux cantons situés après le signal sont libres et le train peut continuer son chemin. Si le signal est orange (avertissement A), le canton suivant est libre mais pas celui d’après ; le train est averti qu’il aura peut-être à s’arrêter un peu plus loin et il doit ralentir. Si le signal est rouge (sémaphore S), cela veut dire que le canton derrière le signal est occupé et le train ne doit pas franchir le signal.

Cette division du circuit ferroviaire en cantons avec chacun un signal lumineux à trois feux constitue un Block Automatique Lumineux (B.A.L) selon les principes de la SNCF. Le B.A.L permet d’espacer les trains pour être sûr qu’ils ne se rattrapent pas. Le tableau suivant résume ce que nous venons de dire.

Signal du Canton NCanton NCanton (N+1)ZA(N-1) alimentée ?
Vert (VL) Libre Libre oui
Orange(A) Libre Occupé oui
Rouge (S) Occupé - - - non

Dans un train réel, c’est au conducteur de respecter les signaux lumineux. Dans un réseau de trains miniatures, il faut commander les trains. En numérique, il suffit d’envoyer des ordres par l’intermédiaire de la centrale numérique à la locomotive pour que celle-ci obéisse. En analogique, commander les trains revient à commander la voie et pour qu’une locomotive s’arrête devant un signal, il est nécessaire de créer une zone d’arrêt alimentée ou non selon la couleur du signal ; c’est ce qu’indique la dernière colonne du tableau. L’avantage de cette zone d’arrêt est que la locomotive s’arrête juste devant le signal mais l’inconvénient est que l’arrêt et le redémarrage sont brusques puisque le courant est coupé ou remis de façon non progressive.

Si le principe du B.A.L reste simple, sa réalisation devient vite compliquée car un train n’est pas ponctuel mais constitué d’une locomotive et d’un certain nombre de wagons ou voitures qui peuvent se trouver sur plusieurs cantons en même temps. De plus, le train peut être remorqué par deux locomotives (ou plus) ou encore être poussé comme nos trains de banlieue. Toutes ces possibilités compliquent la résolution d’un B.A.L adapté au modélisme ferroviaire et l’exercice que je vous propose est donc limité à un B.A.L extrêmement simplifié comme nous allons le voir.

Constitution du circuit

Pour que cette réalisation soit à la portée des débutants, nous allons considérer dans la suite de cet article que notre B.A.L est installé sur un ovale de voie, lui-même divisé en quatre cantons. Bien évidemment, on peut aussi l’installer sur un réseau plus sophistiqué.

L’ovale de voie est constitué de 12 coupons courbes et 4 coupons droits, chaque coupon étant plus long que les locomotives ou autorails en circulation afin de réaliser facilement les zones d’arrêt en remplaçant certaines éclisses métalliques par des éclisses isolantes. On peut ainsi utiliser un coffret de départ bon marché pour constituer le circuit, mais rien n’empêche d’utiliser également de la voie courbable et de sectionner un des deux rails pour constituer les zones d’arrêt. L’ovale est divisé en quatre cantons de longueurs égales, chaque canton étant constitué d’une zone de pleine voie (ZPV, alimentée en permanence) et d’une zone d’arrêt (ZA, commandée par les relais de la carte shield). La figure 2 montre le circuit à réaliser.

Figure 2 - Le circuit ovale avec quatre cantons


L’ovale est parcouru uniquement dans un seul sens, celui des aiguilles d’une montre. Le rail extérieur (en bleu sur la figure 2) est d’un seul tenant et est relié à la borne (-) du transformateur d’alimentation. Le rail intérieur (en rouge) est divisé par des éclisses isolantes (en vert) pour constituer nos quatre zones d’arrêt ; les rails rouges des ZPV sont reliés au (+) du transformateur d’alimentation, les rails rouges des zones d’arrêt sont reliés aux connecteurs NC des relais puisque ce sont eux qui commandent ces zones d’arrêt qui sont constituées d’un seul coupon de voie (droit ou en courbe) sur ce circuit très simple. Il y a donc à prévoir quelques soudures de fils électriques sous les rails afin d’apporter le courant nécessaire à la traction des trains.

Division de l’ovale de voie en quatre cantons

Les cantons sont délimités par des ILS (Interrupteurs à Lames Souples, voir l’article Entrées numériques et résistance pull-up (2)) placés quelques cm plus loin que l’entrée du canton (ils sont repérés par un triangle vert sur la figure 2). Un signal à trois feux se trouve à chaque entrée de canton et est géré par la carte Arduino Uno.

L’ILS situé en entrée de canton peut aussi être considéré comme l’ILS de sortie du canton précédent (dans le sens de marche du train). Quand un train franchit un ILS, il entre dans le canton N et libère le canton N-1. L’entrée dans le canton N met au rouge le signal du canton N et coupe le courant dans la zone d’arrêt du canton N-1 ; ainsi le train suivant s’arrête sur cette zone d’arrêt et ne peut pas sortir du canton N-1 tant que le canton N n’est pas libéré. Ce système permet de respecter la règle numéro 1 citée plus haut. Sur le circuit qui est bouclé, le canton 4 précède le canton 1.

L’ILS d’entrée doit allumer le signal du canton au rouge un peu après que l’engin moteur soit entré, comme dans la réalité. Ceci permet d’éviter de couper le courant dans la zone d’arrêt précédente alors que l’engin moteur n’en est pas complètement sorti. L’ILS doit donc se situer légèrement plus loin que l’entrée de canton afin qu’il soit déclenché lorsque la locomotive a bien quitté le canton précédent ; la distance entre l’entrée du canton et l’ILS est à régler en fonction de votre matériel. Une autre solution pour parvenir au même résultat est de positionner l’aimant actionnant l’ILS sur le premier wagon tracté ou sur la remorque d’un autorail.

L’utilisation d’ILS pour délimiter les cantons présente des avantages et des inconvénients. Parmi les avantages, les ILS peuvent être posés sur un réseau déjà terminé sans rien modifier sur les rails, ce qui permet déjà d’avoir une signalisation fonctionnelle au passage d’un train mais pas d’espacer plusieurs trains puisqu’aucune zone d’arrêt n’est créée. Dans ce cas, on peut se passer de la carte shield et un simple module Arduino Uno prendra en charge la signalisation. Un autre avantage est que les ILS comptent sans état d’âme tout ce qui rentre et sort du canton. Parmi les inconvénients, les trains sont considérés comme ponctuels puisque seule la locomotive est détectée mais pas les wagons qui suivent ; ce système est plutôt à réserver à des circulations d’autorails, de draisines, de locomotives haut-le-pied (sans wagons) ou bien de trains courts constitués d’un ou deux wagons maximum.

Notre circuit en forme d’ovale est maintenant terminé ; il est divisé en quatre cantons, chaque canton est associé à un signal à trois feux donnant l’état d’occupation du canton et dispose d’une zone d’arrêt qui empêche un engin moteur de quitter le canton si le canton suivant n’est pas libre. Voyons maintenant comment le module Arduino va gérer ce circuit.

Gestion du circuit par Arduino

Sur le plan matériel, on voit qu’Arduino doit pouvoir commander le courant dans quatre sections de voie (les zones d’arrêt) et pour le faire, il va utiliser le shield Arduino quatre relais. Comme il ne peut y avoir qu’un engin moteur à la fois sur la zone d’arrêt à commander, on peut penser que le courant maximum sera de 1 A tout au plus (en N ou H0). Les contacts des relais de ce shield sont capable de passer 2 A sous 30 V, ce qui est donc suffisant quelle que soit l’échelle. On rappelle que les broches utilisées pour les quatre relais sont les broches 4, 7, 8 et 12. Il faut de plus quatre broches pour surveiller les ILS, et quatre fois 3 broches pour allumer les signaux à trois feux de type BAL. Au total, on arrive à 20 broches numériques d’entrées-sorties, ce qui tient sur un module Uno. Cependant, pour ne pas avoir à utiliser Tx et Rx, on peut remarquer que l’utilisation d’un relais pour couper le courant sur une zone d’arrêt implique de mettre au rouge le signal correspondant. Les DEL   rouges peuvent être connectées aux broches de commande des relais (4, 7, 8 et 12), ce qui économise quatre broches.

Sur le plan logiciel, tout ce qu’il y a à connaître est l’état d’occupation des cantons. On peut utiliser une variable booléenne égale à TRUE (ou 1) si le canton est occupé et FALSE (ou 0) s’il est libre. En fonction de l’état d’occupation des cantons, on règle les signaux à trois feux selon les règles du B.A.L citées plus haut. L’algorithme est donc :
ILS N détecté >>> Canton N occupé, Canton N-1 libéré >>> Signal N au rouge ET ZA (canton N-1) non alimenté ( STOP)

Si un signal est au rouge, la zone d’arrêt qui se trouve devant le signal est non alimentée, ce qui fait qu’aucun train ne peut passer le signal tant que le canton n’est pas libéré. Les feux des signaux sont commandés par un état HIGH sur les broches correspondantes ; ils doivent être à cathodes communes. La figure 3 montre comment relier le module Arduino Uno et son shield « 4 Relays » aux éléments du circuit. Pour chaque signal, un seul feu est allumé à la fois, ce qui permet de n’avoir qu’une seule résistance de limitation par signal (de l’ordre de 330 Ω, voir article Fonctionnement et pilotage d’une DEL).

Figure 3 - Liaisons entre carte shield et accessoires du circuit


Le câblage avec le circuit est très simple : les ZPV sont constamment alimentées (1), les ZA le sont par la cartes shield (2), ainsi que les LED rouges des signaux (3), les LED oranges et vertes des signaux sont alimentées par des sorties numériques du module Arduino (4).

  • (1)  : ceci a été expliqué un peu plus haut.
  • (2)  : les ZA sont reliées aux connecteurs NC des relais, les connecteurs C étant reliées au + de la sortie DC du transformateur. Chaque relais alimente la zone d’arrêt du canton précédent, donc le relais 1 alimente la zone d’arrêt du canton 4.
  • (3)  : les sorties 4, 7, 8 et 12 sont à repiquer sur le shield 4 relais
  • (4)  : voir la figure 3

Le logiciel de contrôle

Pour être certain de ne pas louper de fermetures d’ILS, le mieux est de faire appel aux interruptions. Sur un module Arduino Uno, seules deux broches savent gérer les interruptions externes, ce qui est insuffisant puisque nous avons quatre ILS à surveiller. Heureusement pour nous, le microcontrôleur ATmega328P qui équipe les cartes Arduino sait gérer des interruptions externes sur d’autres broches et en utilisant le travail d’autres programmeurs (et notamment une bibliothèque spécialisée), nous pouvons programmer des interruptions externes sur les entrées analogiques du module (au nombre de 6, ce qui est suffisant pour nos 4 ILS qui sont reliés aux entrées analogiques A0 à A3, utilisées comme des entrées numériques). Je vous invite à lire l’article de Jean-Luc Les interruptions (1) afin de comprendre comment utiliser la bibliothèque permettant de créer des interruptions externes sur les broches analogiques. Je n’ai rien fait d’autre que d’adapter son programme aux besoins de mon montage.

La routine d’interruption est très simple puisqu’elle ne fait que gérer les variables booléennes associées aux cantons. Le programme en lui-même règle les signaux en fonction des états d’occupation des cantons. Bien entendu, il vous faudra importer dans l’IDE la bibliothèque « PinChangeInt », comme expliqué dans l’article de Jean-Luc (voir également l’article Installer une bibliothèque). Commentons un peu le programme donné ci-dessous.

La première ligne permet d’utiliser la bibliothèque puis on définit les branchements des ILS et des feux pour chaque signal ainsi que quelques variables. Ensuite, on définit les routines d’interruptions qui seront exécutées lors des fermetures des ILS ; elles ne font que définir l’état d’occupation des cantons concernés. Le setup déclare les entrées d’ILS en INPUT_PULLUP, ce qui évite d’avoir à utiliser des résistances de rappels (on utilise celles internes au microcontrôleur), déclare les sorties pour commander les feux et les relais, puis allume tous les signaux au vert et enfin déclare la façon dont les interruptions externes sont rattachées aux entrées des ILS (voir l’article de Jean-Luc Les interruptions (1)). La fonction loop examine comment allumer les signaux en fonction des états d’occupation des cantons suivants en respectant les règles du B.A.L ; on rappelle qu’un signal positionné au rouge entraîne la coupure du courant sur la ZA précédant le signal. La modification de l’état d’un signal lumineux implique d’éteindre complètement le signal avant d’allumer le feu qui doit l’être.

  1. /*
  2.  * programme "cantons_Arduino.ino"
  3.  *
  4.  * ce programme gere le cantonnement du locodrome 4 cantons
  5.  * le montage a realiser est celui de la figure 3
  6.  * il utilise la carte shield 4 relais d Arduino
  7.  * la commande d un relais coupe l alimentation de la ZA et par
  8.  * la meme occasion met le signal au rouge
  9.  */
  10.  
  11. #include <PinChangeInt.h>
  12.  
  13. // definition des ILS
  14. const byte pinILS1 = A0;
  15. const byte pinILS2 = A1;
  16. const byte pinILS3 = A2;
  17. const byte pinILS4 = A3;
  18.  
  19. // Signal 1
  20. const byte S1_vert = 2;
  21. const byte S1_orange = 3;
  22. const byte S1_rouge = 4;
  23.  
  24. // Signal 2
  25. const byte S2_vert = 5;
  26. const byte S2_orange = 6;
  27. const byte S2_rouge = 7;
  28.  
  29. // Signal 3
  30. const byte S3_vert = 9;
  31. const byte S3_orange = 10;
  32. const byte S3_rouge = 8;
  33.  
  34. // Signal 4
  35. const byte S4_vert = 11;
  36. const byte S4_orange = 13;
  37. const byte S4_rouge = 12;
  38.  
  39. volatile boolean canton1 = false;
  40. volatile boolean canton2 = false;
  41. volatile boolean canton3 = false;
  42. volatile boolean canton4 = false;
  43.  
  44. const unsigned long dureeAntiRebond = 1;
  45.  
  46. void interruptILS1()
  47. {
  48. static unsigned long dateDernierChangement = 0;
  49.  
  50. unsigned long date = millis();
  51. if ((date - dateDernierChangement) > dureeAntiRebond) {
  52. canton1 = true;
  53. canton4 = false;
  54. dateDernierChangement = date;
  55. }
  56. }
  57.  
  58. void interruptILS2()
  59. {
  60. static unsigned long dateDernierChangement = 0;
  61.  
  62. unsigned long date = millis();
  63. if ((date - dateDernierChangement) > dureeAntiRebond) {
  64. canton2 = true;
  65. canton1 = false;
  66. dateDernierChangement = date;
  67. }
  68. }
  69.  
  70. void interruptILS3()
  71. {
  72. static unsigned long dateDernierChangement = 0;
  73.  
  74. unsigned long date = millis();
  75. if ((date - dateDernierChangement) > dureeAntiRebond) {
  76. canton3 = true;
  77. canton2 = false;
  78. dateDernierChangement = date;
  79. }
  80. }
  81.  
  82. void interruptILS4()
  83. {
  84. static unsigned long dateDernierChangement = 0;
  85.  
  86. unsigned long date = millis();
  87. if ((date - dateDernierChangement) > dureeAntiRebond) {
  88. canton4 = true;
  89. canton3 = false;
  90. dateDernierChangement = date;
  91. }
  92. }
  93.  
  94. void setup()
  95. {
  96. /*
  97.   * Programme les broches des ILS en entree
  98.   * et active le pullup interne
  99.   */
  100. pinMode(pinILS1, INPUT_PULLUP);
  101. pinMode(pinILS2, INPUT_PULLUP);
  102. pinMode(pinILS3, INPUT_PULLUP);
  103. pinMode(pinILS4, INPUT_PULLUP);
  104.  
  105. /*
  106.   * Programme les feux des signaux en sortie
  107.   */
  108. for(int i = 2; i < 14; i++){
  109. pinMode(i, OUTPUT);
  110. }
  111.  
  112. /*
  113.   * Eteint tous les feux des signaux
  114.   */
  115. for(int j = 2; j < 14; j++){
  116. digitalWrite(j, LOW);
  117. }
  118.  
  119. /*
  120.   * Allume les quatre signaux au vert au debut du jeu
  121.   */
  122. digitalWrite(S1_vert, HIGH);
  123. digitalWrite(S2_vert, HIGH);
  124. digitalWrite(S3_vert, HIGH);
  125. digitalWrite(S4_vert, HIGH);
  126.  
  127. /*
  128.   * accroche les ISR aux pins
  129.   */
  130. PCintPort::attachInterrupt(pinILS1, interruptILS1, FALLING);
  131. PCintPort::attachInterrupt(pinILS2, interruptILS2, FALLING);
  132. PCintPort::attachInterrupt(pinILS3,

    > interruptILS3, FALLING);
  133. PCintPort::attachInterrupt(pinILS4, interruptILS4, FALLING);
  134. }
  135.  
  136. void loop()
  137. {
  138. // Traitement du signal 1
  139. if(canton1){ // Signal 1 au rouge
  140. digitalWrite(S1_vert, LOW);
  141. digitalWrite(S1_orange, LOW);
  142. digitalWrite(S1_rouge, HIGH); // + ZA4 stop
  143. }
  144. if(!canton1 && canton2){ // Signal 1 a l orange
  145. digitalWrite(S1_vert, LOW);
  146. digitalWrite(S1_rouge, LOW); // + ZA4 go
  147. digitalWrite(S1_orange, HIGH);
  148. }
  149. if(!canton1 && !canton2){ // Signal 1 au vert
  150. digitalWrite(S1_orange, LOW);
  151. digitalWrite(S1_rouge, LOW);
  152. digitalWrite(S1_vert, HIGH);
  153. }
  154.  
  155. // Traitement du signal 2
  156. if(canton2){ // Signal 2 au rouge
  157. digitalWrite(S2_vert, LOW);
  158. digitalWrite(S2_orange, LOW);
  159. digitalWrite(S2_rouge, HIGH); // + ZA1 stop
  160. }
  161. if(!canton2 && canton3){ // Signal 2 a l orange
  162. digitalWrite(S2_vert, LOW);
  163. digitalWrite(S2_rouge, LOW); // + ZA1 go
  164. digitalWrite(S2_orange, HIGH);
  165. }
  166. if(!canton2 && !canton3){ // Signal 2 au vert
  167. digitalWrite(S2_orange, LOW);
  168. digitalWrite(S2_rouge, LOW);
  169. digitalWrite(S2_vert, HIGH);
  170. }
  171.  
  172. // Traitement du signal 3
  173. if(canton3){ // Signal 3 au rouge
  174. digitalWrite(S3_vert, LOW);
  175. digitalWrite(S3_orange, LOW);
  176. digitalWrite(S3_rouge, HIGH); // + ZA2 stop
  177. }
  178. if(!canton3 && canton4){ // Signal 3 a l orange
  179. digitalWrite(S3_vert, LOW);
  180. digitalWrite(S3_rouge, LOW); // + ZA2 go
  181. digitalWrite(S3_orange, HIGH);
  182. }
  183. if(!canton3 && !canton4){ // Signal 3 au vert
  184. digitalWrite(S3_orange, LOW);
  185. digitalWrite(S3_rouge, LOW);
  186. digitalWrite(S3_vert, HIGH);
  187. }
  188.  
  189. // Traitement du signal 4
  190. if(canton4){ // Signal 4 au rouge
  191. digitalWrite(S4_vert, LOW);
  192. digitalWrite(S4_orange, LOW);
  193. digitalWrite(S4_rouge, HIGH); // + ZA3 stop
  194. }
  195. if(!canton4 && canton1){ // Signal 4 a l orange
  196. digitalWrite(S4_vert, LOW);
  197. digitalWrite(S4_rouge, LOW); // + ZA3 go
  198. digitalWrite(S4_orange, HIGH);
  199. }
  200. if(!canton4 && !canton1){ // Signal 4 au vert
  201. digitalWrite(S4_orange, LOW);
  202. digitalWrite(S4_rouge, LOW);
  203. digitalWrite(S4_vert, HIGH);
  204. }
  205.  
  206. }

Télécharger

Voici une vidéo de démonstration de ce block automatique lumineux :

Améliorations possibles de ce B.A.L

Le B.A.L que nous venons de créer est extrêmement simplifié et présente des limitations : un seul sens de circulation, arrêt et démarrage brusques, non prise en compte des wagons, non possibilité de trains en pousse, etc. Néanmoins, cet exercice est tout de même intéressant car il reproduit le fonctionnement d’un B.A.L sur un circuit de base (un ovale de voie) en permettant la circulation de deux autorails (ou deux locomotives haut-le-pied plutôt que deux longs trains) et sa réalisation ne demande aucun bricolage électronique compliqué puisqu’on fait appel à une carte Arduino Uno et le shield 4 relais. C’est donc un montage à la portée de tout débutant en Arduino, qui peut bien sûr être adapté à un réseau plus complexe.

Une fois les principes de base bien compris, il est possible d’améliorer ce montage. On peut par exemple remplacer les ILS par des détecteurs d’occupation par consommation de courant qui délivreront un signal à Arduino en fonction de la présence d’engins sur la voie. Bien évidemment, pour connaître l’état d’occupation d’un canton, il faut tester l’occupation à la fois sur la ZPV mais aussi sur la ZA du canton ! On peut aussi mémoriser les états des signaux afin de détecter les changements, ce qui permet de faire démarrer les trains progressivement en injectant un courant pulsé sur la voie. On peut aussi réduire la vitesse des trains au passage d’un signal à l’orange de la même façon. Cela demande un peu plus d’électronique mais ce site vous permet de trouver des solutions à tous ces problèmes. À vous de vous amuser en perfectionnant ce montage en fonction de vos besoins.

7 Messages

Réagissez à « Block Automatique Lumineux avec la carte shield "Arduino 4 relays" »

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

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

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


Jean-Luc

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


Christian Bézanger

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

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


Dominique

Les articles les plus lus

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

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

Une barrière infrarouge

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

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

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

Feux tricolores

La rétro-signalisation sur Arduino

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

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