Block Automatique Lumineux à 8 cantons analogiques

. Par : Christian. URL : https://www.locoduino.org/spip.php?article297

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.