LOCODUINO

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

lundi 29 mai 2023

67 visiteurs en ce moment

Block Automatique Lumineux à 8 cantons analogiques

. Par : Christian

DIFFICULTÉ :

L’article Block Automatique Lumineux avec la carte shield "Arduino 4 relays" proposait un B.A.L limité à 4 cantons construit avec une carte shield qui évitait d’avoir à concevoir soi-même une carte électronique. Un lecteur m’avait demandé s’il était possible d’augmenter le nombre de cantons. Comme on trouve des cartes à 8 relais, je vous propose dans cet article de concevoir un B.A.L à 8 cantons fonctionnant en analogique et basé sur l’algorithme développé à l’époque pour 4 cantons. Le principe peut être étendu à un nombre de cantons encore plus grand en utilisant une deuxième carte relais et les sorties de la carte Mega non utilisées.

Article mis à jour le 2 août 2022 : programme revu avec suppression de la bibliothèque PinChangeInt.

Principe de fonctionnement

Je vous invite en premier à lire l’article Block Automatique Lumineux avec la carte shield "Arduino 4 relays" qui vous permettra de comprendre le fonctionnement de ce B.A.L sur un nombre restreint de cantons. Il s’agit d’un montage simple accessible aux débutants, mais cette simplicité a pour conséquence des limitations d’utilisations, bien décrites dans l’article. Malgré cela, ce B.A.L peut trouver sa place sur votre réseau et permettre à plusieurs trains de se suivre tout en montrant une signalisation conforme.

Contrairement à l’article précédemment cité, ce B.A.L à huit cantons n’utilise pas la bibliothèque PinChangeInt : en effet, cette dernière n’est plus distribuée et de plus, nos trains se déplaçant lentement par rapport à la vitesse de travail d’un microcontrôleur, il suffit de scruter les capteurs (I.L.S) pour savoir où sont positionnés les trains. Le programme gagne en simplicité et est ainsi plus facile à comprendre.

Maintenant que vous avez compris les grands principes de ce B.A.L à 4 cantons, nous allons voir comment améliorer le montage pour obtenir 8 cantons. Ceux qui voudront moins de cantons (par exemple 6 cantons seulement) pourront adapter le programme (en retirant quelques lignes pour les numéros de cantons qui ne servent plus [1]). L’important est d’avoir compris le principe de fonctionnement.

Commençons par rappeler quelques éléments importants à respecter : le B.A.L développé fonctionne sur un circuit analogique bouclé (par exemple un ovale, cas très fréquent en modélisme ferroviaire) parcouru dans un seul sens de marche. Si votre réseau comporte deux voies de circulation, il faudra réaliser deux fois le montage, un pour chaque voie.

Ce circuit est constitué de plusieurs cantons. Chaque canton est constitué d’une zone de pleine voie (ZPV) toujours alimentée, d’une zone d’arrêt (ZA) alimentée ou non suivant que le train peut passer ou doit s’arrêter, et d’un signal lumineux à trois feux (vert, rouge, orange). L’alimentation de la zone d’arrêt se fait grâce à un relais (en 5 V) de type 1RT (un contact repos-travail). Un ILS (Interrupteur à Lames Souples) est positionné en début de canton et permet de savoir si un engin (muni d’un aimant) entre dans le canton.

Seule la locomotive du train est détectée dans ce système : le B.A.L sera donc plus réaliste avec des trains courts ou bien des autorails ou des locomotives haut-le-pied. On part du principe que lorsqu’un train entre dans un canton, il libère le canton précédent (dans le sens de la marche). Le signal de canton doit être mis au rouge (sémaphore) et la zone d’arrêt du canton précédent doit être non alimentée pour que le train s’arrête devant le signal rouge. L’algorithme de travail 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)

On examine également pour chaque signal, la couleur à allumer : vert (Voie Libre VL) si le canton du signal et le canton suivant sont libres, orange (avertissement A) si le canton du signal est libre mais que le canton suivant est occupé et rouge (sémaphore S) si le canton du signal est occupé.

La figure 1 présente le circuit du B.A.L dans le cas de huit cantons ; les légendes sont les mêmes que pour la figure 2 de l’article Block Automatique Lumineux avec la carte shield "Arduino 4 relays". Enfin, il faut se rappeler que le circuit est bouclé ; le canton qui précède le canton 1 est donc le canton 8.

Figure 1
Figure 1
Le circuit avec 8 cantons qui sont parcourus dans le sens des aiguilles d’une montre.

Matériel nécessaire

Les 8 signaux à 3 feux de B.A.L doivent être à cathodes communes pour le montage tel qu’il est décrit ici. Néanmoins, des signaux à anodes communes peuvent être utilisés en modifiant légèrement les lignes 17 et 18 du programme, comme expliqué dans les commentaires des lignes. Dans ce cas, le fil commun des signaux (avec la résistance de limitation de courant) est à relier au 5 V.

Chaque signal occupe trois sorties numériques d’une carte Arduino et il y a 8 signaux ; une carte Mega est donc indispensable pour offrir ces 24 sorties numériques auxquelles s’ajoutent 8 sorties pour commander les relais et 8 entrées pour raccorder les I.L.S. Comme il faut un relais par canton, soit 8 relais en tout, il est recommandé de se procurer une carte à 8 relais (en 5 V) de type 1RT (un contact repos-travail) qu’on trouve facilement sur internet.

À ce matériel, il faut ajouter 8 ILS et 8 résistances de 330 ou 470 ohms (pour limiter le courant dans les LED des signaux).

Entrées-sorties utilisées et montage des composants

Les huit ILS qui constituent les capteurs surveillant le circuit sont reliés aux entrées analogiques A0 à A7.

Les sorties numériques commandant les relais sont les sorties 2 à 9 de la carte Mega.

Les signaux sont branchés sur les sorties numériques 22 à 45 de la carte Mega. Chaque feu est relié dans l’ordre vert-orange-rouge sur trois sorties consécutives. Exemple, signal 1 sur 22 (vert), 23 (orange), 24 (rouge), signal 2 sur 25 (vert), 26 (orange), 27 (rouge), etc. Chaque feu doit avoir sa résistance sur le fil commun : 330 ou 470 ohms pour ne pas trop tirer sur la carte Mega [2]. Les fils communs des feux (avec résistance) sont reliés au GND de la carte Arduino (ou bien au 5 V si les signaux sont à anodes communes).

La figure 2 représente le montage à réaliser avec tous les composants. La carte Mega est alimentée soit par l’USB, soit par la prise jack avec, dans ce cas, une alimentation comprise entre 7 et 9 V. Le connecteur servant à relier les signaux est entouré en jaune. Les fils bleus ciel (cyan) sont des câbles DuPont Mâle (côté Arduino) et Femelle (côté carte relais). Câblez aussi le 5 V en rouge, pris sur la carte Arduino. Les ILS sont reliés aux entrées A0 à A7 ainsi qu’à la masse (GND) de la carte.

Figure 2
Figure 2
Block Automatique Lumineux à huit cantons avec une carte Mega et une carte à 8 relais de type 1RT.

La carte 8 relais doit avoir une alimentation à part. Elle doit délivrer 5 V en courant continu. Pour cela, ôter le jumper (en jaune sur la figure) et utiliser les deux bornes extrêmes (GND pour le MOINS de l’alimentation et JD-Vcc pour le PLUS de l’alimentation). Un bloc de trois piles de 1,5 V peut aussi faire l’affaire, pour avoir 4,5 V qui devraient suffire à commander les relais.

Le fil marron est le fil de l’alimentation traction du transformateur qui alimente le rail qui a été découpé pour faire les zones d’arrêt (Rail positif de droite dans le sens de la marche : voir l’article Block Automatique Lumineux avec la carte shield "Arduino 4 relays"). Il arrive sur les plots milieu (commun) des sorties de relais. Les fils oranges alimentent les zones d’arrêt ZA1 à ZA8 : ils sont branchés aux sorties de relais NC (normalement connectées si le relais est non excité, par opposition aux sorties NO, normalement ouvertes). Si les lettres NC et NO ne figurent pas sur votre carte relais, regardez le petit schéma de connexion des sorties, représentatif d’un relais non excité.

La figure 3 montre que la commande d’un relais passe par un optocoupleur qui assure l’isolation galvanique entre la carte Arduino et les relais alimentés à part. Le GND représente le moins de l’alimentation séparée alors que le plus est connecté à la borne JD-VCC.

Figure 3
Figure 3
Schéma de commande d’un relais de la carte.

Le programme

Récupérez le programme grâce au bouton "Télécharger". Si vous utilisez des signaux à anodes commune, changez les lignes 17 et 18 comme l’indiquent les commentaires en fin de ligne. Sauvegardez le programme sous le nom "BAL_8_Cantons_Monosens" puis téléversez-le dans votre carte Arduino Mega. Réalisez ensuite le câblage des différents composants (il est conseillé de programmer la carte avant de faire le câblage).

Voici le listing du programme :

  1. /* --------------------------------------------------------------
  2.  * programme "BAL_8_Cantons_Monosens.ino"
  3.  * --------------------------------------------------------------
  4.  * ce programme gere un B.A.L de 8 cantons avec 8 signaux a
  5.  * CATHODES COMMUNES. (Signaux a anodes communes possibles)
  6.  * la commande du relais x par INx coupe l alimentation de la ZAx
  7.  * _______________________________________________
  8.  * | |
  9.  * | C EST UN ETAT LOW QUI COMMANDE LE RELAIS !!! |
  10.  * |_______________________________________________|
  11.  *
  12.  * Relais de 9 à 2 - Signaux luimineux de 22 à 45
  13.  * Relais 1 : D09 -> IN1 - ZA1 => Relais 8 : D02 -> IN8 - ZA8
  14.  * Signaux sur sorties qui se suivent ordre vert - orange - rouge
  15.  * ------------------------------------------------------------*/
  16.  
  17. const byte etatLedON = HIGH; // Mettre LOW si signaux a anodes communes
  18. const byte etatLedOFF = LOW; // Mettre HIGH si signaux a anodes communes
  19.  
  20. // definition des ILS
  21. // ------------------
  22. const byte pinILS1 = A0;
  23. const byte pinILS2 = A1;
  24. const byte pinILS3 = A2;
  25. const byte pinILS4 = A3;
  26. const byte pinILS5 = A4;
  27. const byte pinILS6 = A5;
  28. const byte pinILS7 = A6;
  29. const byte pinILS8 = A7;
  30.  
  31. // Commandes des relais (etat LOW sur INx excite relais x)
  32. // -------------------------------------------------------
  33. const byte R1 = 9;
  34. const byte R2 = 8;
  35. const byte R3 = 7;
  36. const byte R4 = 6;
  37. const byte R5 = 5;
  38. const byte R6 = 4;
  39. const byte R7 = 3;
  40. const byte R8 = 2;
  41.  
  42. // Les signaux de B.A.L
  43. // --------------------
  44. // Signal 1
  45. const byte S1_vert = 22;
  46. const byte S1_orange = 23;
  47. const byte S1_rouge = 24;
  48.  
  49. // Signal 2
  50. const byte S2_vert = 25;
  51. const byte S2_orange = 26;
  52. const byte S2_rouge = 27;
  53.  
  54. // Signal 3
  55. const byte S3_vert = 28;
  56. const byte S3_orange = 29;
  57. const byte S3_rouge = 30;
  58.  
  59. // Signal 4
  60. const byte S4_vert = 31;
  61. const byte S4_orange = 32;
  62. const byte S4_rouge = 33;
  63.  
  64. // Signal 5
  65. const byte S5_vert = 34;
  66. const byte S5_orange = 35;
  67. const byte S5_rouge = 36;
  68.  
  69. // Signal 6
  70. const byte S6_vert = 37;
  71. const byte S6_orange = 38;
  72. const byte S6_rouge = 39;
  73.  
  74. // Signal 7
  75. const byte S7_vert = 40;
  76. const byte S7_orange = 41;
  77. const byte S7_rouge = 42;
  78.  
  79. // Signal 8
  80. const byte S8_vert = 43;
  81. const byte S8_orange = 44;
  82. const byte S8_rouge = 45;
  83.  
  84. // Occupation des cantons
  85. // ----------------------
  86. volatile bool canton1 = false; // true si occupe
  87. volatile bool canton2 = false;
  88. volatile bool canton3 = false;
  89. volatile bool canton4 = false;
  90. volatile bool canton5 = false;
  91. volatile bool canton6 = false;
  92. volatile bool canton7 = false;
  93. volatile bool canton8 = false;
  94.  
  95. void setup()
  96. {
  97. // Broches des ILS en entree et active le pullup interne
  98. pinMode(pinILS1, INPUT_PULLUP);
  99. pinMode(pinILS2, INPUT_PULLUP);
  100. pinMode(pinILS3, INPUT_PULLUP);
  101. pinMode(pinILS4, INPUT_PULLUP);
  102. pinMode(pinILS5, INPUT_PULLUP);
  103. pinMode(pinILS6, INPUT_PULLUP);
  104. pinMode(pinILS7, INPUT_PULLUP);
  105. pinMode(pinILS8, INPUT_PULLUP);
  106.  
  107. // Programmes les broches relais en sortie
  108. for(int i = 2; i <= 9; i++) {
  109. pinMode(i, OUTPUT);
  110. }
  111.  
  112. // Met les broches relais à HIGH (relais non excites)
  113. for(int i = 2; i <= 9; i++) {
  114. digitalWrite(i, HIGH);
  115. }
  116.  
  117. // Programme les feux des signaux en sortie
  118. for(int j = 22; j <= 45; j++){
  119. pinMode(j, OUTPUT);
  120. }
  121.  
  122. // Eteint tous les feux des signaux
  123. for(int j = 22; j <= 45; j++){
  124. digitalWrite(j, LOW);
  125. }
  126.  
  127. // Allume les huit signaux au vert au debut du jeu
  128. digitalWrite(S1_vert, HIGH);
  129. digitalWrite(S2_vert, HIGH);
  130. digitalWrite(S3_vert, HIGH);
  131. digitalWrite(S4_vert, HIGH);
  132. digitalWrite(S5_vert, HIGH);
  133. digitalWrite(S6_vert, HIGH);
  134. digitalWrite(S7_vert, HIGH);
  135. digitalWrite(S8_vert, HIGH);
  136. } // Fin de setup
  137.  
  138. void loop()
  139. {
  140. // Scrutation des ILS
  141. if(digitalRead(pinILS1)==LOW) {
  142. canton1 = true;
  143. canton8 = false;
  144. }
  145. if(digitalRead(pinILS2)==LOW) {
  146. canton2 = true;
  147. canton1 = false;
  148. }
  149. if(digitalRead(pinILS3)==LOW) {
  150. canton3 = true;
  151. canton2 = false;
  152. }
  153. if(digitalRead(pinILS4)==LOW) {
  154. canton4 = true;
  155. canton3 = false;
  156. }
  157. if(digitalRead(pinILS5)==LOW) {
  158. canton5 = true;
  159. canton4 = false;
  160. }
  161. if(digitalRead(pinILS6)==LOW) {
  162. canton6 = true;
  163. canton5 = false;
  164. }
  165. if(digitalRead(pinILS7)==LOW) {
  166. canton7 = true;
  167. canton6 = false;
  168. }
  169. if(digitalRead(pinILS8)==LOW) {
  170. canton8 = true;
  171. canton7 = false;
  172. }
  173.  
  174. // Traitement du signal 1
  175. if(canton1){ // Signal 1 au rouge
  176. digitalWrite(S1_vert, etatLedOFF);
  177. digitalWrite(S1_orange, etatLedOFF);
  178. digitalWrite(S1_rouge, etatLedON);
  179. // ZA precedente stop
  180. digitalWrite(R8, LOW);
  181. }
  182. if(!canton1 && canton2){ // Signal 1 a l orange
  183. digitalWrite(S1_vert, etatLedOFF);
  184. digitalWrite(S1_rouge, etatLedOFF);
  185. // ZA precedente go
  186. digitalWrite(R8, HIGH);
  187. digitalWrite(S1_orange, etatLedON);
  188. }
  189. if(!canton1 && !canton2){ // Signal 1 au vert
  190. digitalWrite(S1_orange, etatLedOFF);
  191. digitalWrite(S1_rouge, etatLedOFF);
  192. digitalWrite(S1_vert, etatLedON);
  193. }
  194.  
  195. // Traitement du signal 2
  196. if(canton2){ // Signal 2 au rouge
  197. digitalWrite(S2_vert, etatLedOFF);
  198. digitalWrite(S2_orange, etatLedOFF);
  199. digitalWrite(S2_rouge, etatLedON);
  200. // ZA1 stop
  201. digitalWrite(R1, LOW);
  202. }
  203. if(!canton2 && canton3){ // Signal 2 a l orange
  204. digitalWrite(S2_vert, etatLedOFF);
  205. digitalWrite(S2_rouge, etatLedOFF);
  206. // ZA1 go
  207. digitalWrite(R1, HIGH);
  208. digitalWrite(S2_orange, etatLedON);
  209. }
  210. if(!canton2 && !canton3){ // Signal 2 au vert
  211. digitalWrite(S2_orange, etatLedOFF);
  212. digitalWrite(S2_rouge, etatLedOFF);
  213. digitalWrite(S2_vert, etatLedON);
  214. }
  215.  
  216. // Traitement du signal 3
  217. if(canton3){ // Signal 3 au rouge
  218. digitalWrite(S3_vert, etatLedOFF);
  219. digitalWrite(S3_orange, etatLedOFF);
  220. digitalWrite(S3_rouge, etatLedON);
  221. // ZA2 stop
  222. digitalWrite(R2, LOW);
  223. }
  224. if(!canton3 && canton4){ // Signal 3 a l orange
  225. digitalWrite(S3_vert, etatLedOFF);
  226. digitalWrite(S3_rouge, etatLedOFF);
  227. // ZA2 go
  228. digitalWrite(R2, HIGH);
  229. digitalWrite(S3_orange, etatLedON);
  230. }
  231. if(!canton3 && !canton4){ // Signal 3 au vert
  232. digitalWrite(S3_orange, etatLedOFF);
  233. digitalWrite(S3_rouge, etatLedOFF);
  234. digitalWrite(S3_vert, etatLedON);
  235. }
  236.  
  237. // Traitement du signal 4
  238. if(canton4){ // Signal 4 au rouge
  239. digitalWrite(S4_vert, etatLedOFF);
  240. digitalWrite(S4_orange, etatLedOFF);
  241. digitalWrite(S4_rouge, etatLedON);
  242. // ZA3 stop
  243. digitalWrite(R3, LOW);
  244. }
  245. if(!canton4 && canton5){ // Signal 4 a l orange
  246. digitalWrite(S4_vert, etatLedOFF);
  247. digitalWrite(S4_rouge, etatLedOFF);
  248. // ZA3 go
  249. digitalWrite(R3, HIGH);
  250. digitalWrite(S4_orange, etatLedON);
  251. }
  252. if(!canton4 && !canton5){ // Signal 4 au vert
  253. digitalWrite(S4_orange, etatLedOFF);
  254. digitalWrite(S4_rouge, etatLedOFF);
  255. digitalWrite(S4_vert, etatLedON);
  256. }
  257.  
  258. // Traitement du signal 5
  259. if(canton5){ // Signal 5 au rouge
  260. digitalWrite(S5_vert, etatLedOFF);
  261. digitalWrite(S5_orange, etatLedOFF);
  262. digitalWrite(S5_rouge, etatLedON);
  263. // ZA4 stop
  264. digitalWrite(R4, LOW);
  265. }
  266. if(!canton5 && canton6){ // Signal 5 a l orange
  267. digitalWrite(S5_vert, etatLedOFF);
  268. digitalWrite(S5_rouge, etatLedOFF);
  269. // ZA4 go
  270. digitalWrite(R4, HIGH);
  271. digitalWrite(S5_orange, etatLedON);
  272. }
  273. if(!canton5 && !canton6){ // Signal 5 au vert
  274. digitalWrite(S5_orange, etatLedOFF);
  275. digitalWrite(S5_rouge, etatLedOFF);
  276. digitalWrite(S5_vert, etatLedON);
  277. }
  278.  
  279. // Traitement du signal 6
  280. if(canton6){ // Signal 6 au rouge
  281. digitalWrite(S6_vert, etatLedOFF);
  282. digitalWrite(S6_orange, etatLedOFF);
  283. digitalWrite(S6_rouge, etatLedON);
  284. // ZA5 stop
  285. digitalWrite(R5, LOW);
  286. }
  287. if(!canton6 && canton7){ // Signal 6 a l orange
  288. digitalWrite(S6_vert, etatLedOFF);
  289. digitalWrite(S6_rouge, etatLedOFF);
  290. // ZA5 go
  291. digitalWrite(R5, HIGH);
  292. digitalWrite(S6_orange, etatLedON);
  293. }
  294. if(!canton6 && !canton7){ // Signal 6 au vert
  295. digitalWrite(S6_orange, etatLedOFF);
  296. digitalWrite(S6_rouge, etatLedOFF);
  297. digitalWrite(S6_vert, etatLedON);
  298. }
  299.  
  300. // Traitement du signal 7
  301. if(canton7){ // Signal 7 au rouge
  302. digitalWrite(S7_vert, etatLedOFF);
  303. digitalWrite(S7_orange, etatLedOFF);
  304. digitalWrite(S7_rouge, etatLedON);
  305. // ZA6 stop
  306. digitalWrite(R6, LOW);
  307. }
  308. if(!canton7 && canton8){ // Signal 7 a l orange
  309. digitalWrite(S7_vert, etatLedOFF);
  310. digitalWrite(S7_rouge, etatLedOFF);
  311. // ZA6 go
  312. digitalWrite(R6, HIGH);
  313. digitalWrite(S7_orange, etatLedON);
  314. }
  315. if(!canton7 && !canton8){ // Signal 7 au vert
  316. digitalWrite(S7_orange, etatLedOFF);
  317. digitalWrite(S7_rouge, etatLedOFF);
  318. digitalWrite(S7_vert, etatLedON);
  319. }
  320.  
  321. // Traitement du signal 8
  322. if(canton8){ // Signal 8 au rouge
  323. digitalWrite(S8_vert, etatLedOFF);
  324. digitalWrite(S8_orange, etatLedOFF);
  325. digitalWrite(S8_rouge, etatLedON);
  326. // ZA7 stop
  327. digitalWrite(R7, LOW);
  328. }
  329. if(!canton8 && canton1){ // Signal 8 a l orange
  330. digitalWrite(S8_vert, etatLedOFF);
  331. digitalWrite(S8_rouge, etatLedOFF);
  332. // ZA7 go
  333. digitalWrite(R7, HIGH);
  334. digitalWrite(S8_orange, etatLedON);
  335. }
  336. if(!canton8 && !canton1){ // Signal 8 au vert
  337. digitalWrite(S8_orange, etatLedOFF);
  338. digitalWrite(S8_rouge, etatLedOFF);
  339. digitalWrite(S8_vert, etatLedON);
  340. }
  341.  
  342. } // Fin de loop

Télécharger

La variable booléenne associée au canton est ’true’ si le canton est occupé et ’false’ si le canton est libre. En début de loop, on examine l’état des entrées sur lesquelles sont reliés les I.L.S. Si on trouve un état LOW, c’est que l’I.L.S est déclenché : un train est en train d’entrer sur le canton et libère donc le canton précédent. On met la variable booléenne de canton à ’true’ et la variable booléenne du canton précédent à ’false’.

Il n’est pas nécessaire de traiter les rebonds des I.L.S ; en effet, si on détecte plusieurs fois en peu de temps un état LOW, le programme fera plusieurs fois les mêmes actions et au final, le résultat sera le même, à savoir les variables seront mises aux bonnes valeurs.

Une fois que toutes les entrées des I.L.S ont été examinées, on regarde signal par signal quels sont les feux à allumer selon le principe des signaux de B.A.L. On applique pour cela les règles de logique : le symbole ’ !’ signifie NON et équivaut à considérer le contraire de la valeur (exemple, si la valeur est false, son contraire est true). Le symbole ’&&’ est le ET et une expression contenant ET est vraie si les deux membres (de part et d’autre du ET) sont vrais.

Quand tous les signaux sont traités, on recommence la boucle loop.

Comme précisé dans le commentaire de tête, c’est un signal LOW sur la sortie d’Arduino qui permet d’exciter le relais, et donc de retirer l’alimentation sur la zone d’arrêt.

Enfin, il faut se rappeler que le circuit est bouclé ; le canton qui précède le canton 1 est donc le canton 8 (ou le canton ayant le numéro le plus élevé si le nombre de cantons est différent de 8).

Lors de la mise en route du montage, tous les signaux doivent être verts et toutes les zones d’arrêt doivent être alimentées. Le parcours d’une première locomotive sur le circuit aubinera les signaux selon les règles d’un B.A.L. Les locomotives suivantes s’arrêteront si le signal est rouge.

Le montage et ce programme ont été testés sur le simulateur d’Arduino Wokwi (https://wokwi.com/) et l’ensemble fonctionne correctement.

Augmenter encore plus le nombre de cantons ?

La figure 2 (plus haut) nous permet de voir que toutes les entrées-sorties (E/S) de la carte Mega ne sont pas utilisées. On peut donc encore ajouter quelques cantons mais il faut penser à respecter la limitation totale en courant de la carte Mega (200 mA). Rajouter des cantons revient à rajouter des signaux, donc des LED à allumer. Il faut aussi penser que les optocoupleurs des cartes relais sont constitués de LED qui consomment également du courant (voir figure 3).

Une fois vos calculs faits, vous pouvez utiliser les entrées analogiques A8 à A15 pour brancher les ILS supplémentaires et les sorties numériques 14 à 21 pour commander la deuxième carte relais. Les signaux seront branchés sur les E/S restantes, à savoir 46 à 53 ainsi que 10 à 13, soit 12 sorties pour 4 signaux supplémentaires à 3 feux.

On a donc ajouté 4 cantons supplémentaires pour la partie décorée du réseau (la partie visible), et on peut disposer de 4 autres cantons qui n’auront pas leur feux mais qui peuvent être utilisés pour des gares cachées.

Conclusion

Bien que ce montage soit inspiré du montage décrit dans l’article Block Automatique Lumineux avec la carte shield "Arduino 4 relays", il a un avantage certain car il permet d’utiliser des signaux à anodes communes sans avoir à rajouter des composants électroniques pour inverser les sorties. En effet, grâce au nombre plus important d’entrées-sorties sur une carte Mega, les LED des signaux sont commandées indépendamment des relais, ce qui n’était pas le cas avec la carte shield qui commandait à la fois le relais (par un état HIGH) et le feu rouge du signal qui devait impérativement être à cathodes communes. Ce montage permet donc, en modifiant un peu le programme, d’utiliser n’importe quel type de signaux (cathodes ou anodes communes) comme cela a été expliqué plus haut. Enfin, ce montage est plus adapté aux grands circuits qui permettent un nombre plus élevé de cantons.

Ce nouveau B.A.L sera sans doute appréciée de ceux qui disposent d’un réseau assez grand, d’autant que son prix de revient n’est pas très élevé et qu’il est encore possible de rajouter quelques cantons. N’hésitez pas à nous faire savoir comment vous l’aurez amélioré.

[1En fait, il suffit de commenter ces lignes, comme cela elles sont toujours présentes et prêtes à être décommentées si on veut ajouter un canton un jour. Pensez aussi à modifier le numéro du canton qui précède le canton 1.

[2La résistance peut même aller jusqu’à 1 kilo si vos LED sont à haute luminosité afin de limiter encore plus le courant.

2 Messages

Réagissez à « Block Automatique Lumineux à 8 cantons analogiques »

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

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)

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

Affichage publicitaire avec Arduino (1)

Affichage publicitaire avec Arduino (2)

Fabrication d’un programmateur pour microcontrôleurs ATtiny

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

TCO Web interactif avec des ESP32 et des ESP8266 (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

La carte Satellite V1

La carte Satellite V1

La carte Satellite V1

La carte Satellite V1

Les derniers articles

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


utpeca

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


utpeca

Fabrication d’un programmateur pour microcontrôleurs ATtiny


Christian, Dominique, Jean-Luc

Affichage publicitaire avec Arduino (2)


catplus, Christian

Affichage publicitaire avec Arduino (1)


catplus, Christian

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


msport

Banc de test pour les décodeurs DCC


msport

Va-et-vient pour deux trains


msport

Boitier 3D pour la station DCC minimale


msport

Mon premier décodeur pour les aiguillages DCC


msport

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)

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

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

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

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

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

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

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

Fabrication d’un programmateur pour microcontrôleurs ATtiny