LOCODUINO

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

jeudi 26 mai 2022

15 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 aujourd’hui 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.

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.

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 ; la carte Uno ne permettait de commander que 4 signaux, c’est pourquoi nous utiliserons dans ce montage une carte Mega.

Le shield "Arduino four relays" ne comportait que 4 relais et ne permettait donc de ne commander que 4 zones d’arrêt, soit 4 cantons. Pour monter à 8 cantons, il est nécessaire 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

Le programme utilise la bibliothèque PinChangeInt. Celle-ci est donnée dans le fichier ZIP ci-dessous. Le répertoire appelé PinChangeInt est à placer dans sa totalité dans Documents > Arduino > libraries.

Fichier source contenant programme et bibliothèque

Le répertoire appelé BAL_8_Cantons_Monosens est à placer dans sa totalité dans Documents > Arduino ; c’est là que se trouvent les programmes pour Arduino. Ce répertoire est créé lors de l’installation du logiciel de programmation IDE.

Je conseille de programmer la carte avant de faire le câblage. Ouvrez l’IDE et allez chercher le programme « BAL_8_Cantons_Monosens.ino ». Téléchargez-le dans la carte Mega. Cette opération ne devrait pas poser de problème si la bibliothèque PinChangeInt a été mise dans le répertoire « libraries » AVANT.

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. #include <PinChangeInt.h>
  21.  
  22. // definition des ILS
  23. // ------------------
  24. const byte pinILS1 = A0;
  25. const byte pinILS2 = A1;
  26. const byte pinILS3 = A2;
  27. const byte pinILS4 = A3;
  28. const byte pinILS5 = A4;
  29. const byte pinILS6 = A5;
  30. const byte pinILS7 = A6;
  31. const byte pinILS8 = A7;
  32.  
  33. // Commandes des relais (etat LOW sur INx excite relais x)
  34. // -------------------------------------------------------
  35. const byte R1 = 9;
  36. const byte R2 = 8;
  37. const byte R3 = 7;
  38. const byte R4 = 6;
  39. const byte R5 = 5;
  40. const byte R6 = 4;
  41. const byte R7 = 3;
  42. const byte R8 = 2;
  43.  
  44. // Les signaux de B.A.L
  45. // --------------------
  46. // Signal 1
  47. const byte S1_vert = 22;
  48. const byte S1_orange = 23;
  49. const byte S1_rouge = 24;
  50.  
  51. // Signal 2
  52. const byte S2_vert = 25;
  53. const byte S2_orange = 26;
  54. const byte S2_rouge = 27;
  55.  
  56. // Signal 3
  57. const byte S3_vert = 28;
  58. const byte S3_orange = 29;
  59. const byte S3_rouge = 30;
  60.  
  61. // Signal 4
  62. const byte S4_vert = 31;
  63. const byte S4_orange = 32;
  64. const byte S4_rouge = 33;
  65.  
  66. // Signal 5
  67. const byte S5_vert = 34;
  68. const byte S5_orange = 35;
  69. const byte S5_rouge = 36;
  70.  
  71. // Signal 6
  72. const byte S6_vert = 37;
  73. const byte S6_orange = 38;
  74. const byte S6_rouge = 39;
  75.  
  76. // Signal 7
  77. const byte S7_vert = 40;
  78. const byte S7_orange = 41;
  79. const byte S7_rouge = 42;
  80.  
  81. // Signal 8
  82. const byte S8_vert = 43;
  83. const byte S8_orange = 44;
  84. const byte S8_rouge = 45;
  85.  
  86. // Occupation des cantons
  87. // ----------------------
  88. volatile bool canton1 = false; // true si occupe
  89. volatile bool canton2 = false;
  90. volatile bool canton3 = false;
  91. volatile bool canton4 = false;
  92. volatile bool canton5 = false;
  93. volatile bool canton6 = false;
  94. volatile bool canton7 = false;
  95. volatile bool canton8 = false;
  96.  
  97. const unsigned long dureeAntiRebond = 1;
  98.  
  99. // Les routines d'interruption
  100. // ---------------------------
  101. void interruptILS1()
  102. {
  103. static unsigned long dateDernierChangement = 0;
  104.  
  105. unsigned long date = millis();
  106. if ((date - dateDernierChangement) > dureeAntiRebond) {
  107. canton1 = true;
  108. canton8 = false;
  109. dateDernierChangement = date;
  110. }
  111. }
  112.  
  113. void interruptILS2()
  114. {
  115. static unsigned long dateDernierChangement = 0;
  116.  
  117. unsigned long date = millis();
  118. if ((date - dateDernierChangement) > dureeAntiRebond) {
  119. canton2 = true;
  120. canton1 = false;
  121. dateDernierChangement = date;
  122. }
  123. }
  124.  
  125. void interruptILS3()
  126. {
  127. static unsigned long dateDernierChangement = 0;
  128.  
  129. unsigned long date = millis();
  130. if ((date - dateDernierChangement) > dureeAntiRebond) {
  131. canton3 = true;
  132. canton2 = false;
  133. dateDernierChangement = date;
  134. }
  135. }
  136.  
  137. void interruptILS4()
  138. {
  139. static unsigned long dateDernierChangement = 0;
  140.  
  141. unsigned long date = millis();
  142. if ((date - dateDernierChangement) > dureeAntiRebond) {
  143. canton4 = true;
  144. canton3 = false;
  145. dateDernierChangement = date;
  146. }
  147. }
  148.  
  149. void interruptILS5()
  150. {
  151. static unsigned long dateDernierChangement = 0;
  152.  
  153. unsigned long date = millis();
  154. if ((date - dateDernierChangement) > dureeAntiRebond) {
  155. canton5 = true;
  156. canton4 = false;
  157. dateDernierChangement = date;
  158. }
  159. }
  160.  
  161. void interruptILS6()
  162. {
  163. static unsigned long dateDernierChangement = 0;
  164.  
  165. unsigned long date = millis();
  166. if ((date - dateDernierChangement) > dureeAntiRebond) {
  167. canton6 = true;
  168. canton5 = false;
  169. dateDernierChangement = date;
  170. }
  171. }
  172.  
  173. void interruptILS7()
  174. {
  175. static unsigned long dateDernierChangement = 0;
  176.  
  177. unsigned long date = millis();
  178. if ((date - dateDernierChangement) > dureeAntiRebond) {
  179. canton7 = true;
  180. canton6 = false;
  181. dateDernierChangement = date;
  182. }
  183. }
  184.  
  185. void interruptILS8()
  186. {
  187. static unsigned long dateDernierChangement = 0;
  188.  
  189. unsigned long date = millis();
  190. if ((date - dateDernierChangement) > dureeAntiRebond) {
  191. canton8 = true;
  192. canton7 = false;
  193. dateDernierChangement = date;
  194. }
  195. }
  196.  
  197. void setup()
  198. {
  199. // Broches des ILS en entree et active le pullup interne
  200. pinMode(pinILS1, INPUT_PULLUP);
  201. pinMode(pinILS2, INPUT_PULLUP);
  202. pinMode(pinILS3, INPUT_PULLUP);
  203. pinMode(pinILS4, INPUT_PULLUP);
  204. pinMode(pinILS5, INPUT_PULLUP);
  205. pinMode(pinILS6, INPUT_PULLUP);
  206. pinMode(pinILS7, INPUT_PULLUP);
  207. pinMode(pinILS8, INPUT_PULLUP);
  208.  
  209. // Programmes les broches relais en sortie
  210. for(int i = 2; i <= 9; i++) {
  211. pinMode(i, OUTPUT);
  212. }
  213.  
  214. // Met les broches relais à HIGH (relais non excites)
  215. for(int i = 2; i <= 9; i++) {
  216. digitalWrite(i, HIGH);
  217. }
  218.  
  219. // Programme les feux des signaux en sortie
  220. for(int j = 22; j <= 45; j++){
  221. pinMode(j, OUTPUT);
  222. }
  223.  
  224. // Eteint tous les feux des signaux
  225. for(int j = 22; j <= 45; j++){
  226. digitalWrite(j, LOW);
  227. }
  228.  
  229. // Allume les huit signaux au vert au debut du jeu
  230. digitalWrite(S1_vert, HIGH);
  231. digitalWrite(S2_vert, HIGH);
  232. digitalWrite(S3_vert, HIGH);
  233. digitalWrite(S4_vert, HIGH);
  234. digitalWrite(S5_vert, HIGH);
  235. digitalWrite(S6_vert, HIGH);
  236. digitalWrite(S7_vert, HIGH);
  237. digitalWrite(S8_vert, HIGH);
  238.  
  239. // Accroche les ISR aux pins
  240. PCintPort::attachInterrupt(pinILS1, interruptILS1, FALLING);
  241. PCintPort::attachInterrupt(pinILS2, interruptILS2, FALLING);
  242. PCintPort::attachInterrupt(pinILS3, interruptILS3, FALLING);
  243. PCintPort::attachInterrupt(pinILS4, interruptILS4, FALLING);
  244. PCintPort::attachInterrupt(pinILS5, interruptILS5, FALLING);
  245. PCintPort::attachInterrupt(pinILS6, interruptILS6, FALLING);
  246. PCintPort::attachInterrupt(pinILS7, interruptILS7, FALLING);
  247. PCintPort::attachInterrupt(pinILS8, interruptILS8, FALLING);
  248. } // Fin de setup
  249.  
  250. void loop()
  251. {
  252. // Traitement du signal 1
  253. if(canton1){ // Signal 1 au rouge
  254. digitalWrite(S1_vert, etatLedOFF);
  255. digitalWrite(S1_orange, etatLedOFF);
  256. digitalWrite(S1_rouge, etatLedON);
  257. // ZA precedente stop
  258. digitalWrite(R8, LOW);
  259. }
  260. if(!canton1 && canton2){ // Signal 1 a l orange
  261. digitalWrite(S1_vert, etatLedOFF);
  262. digitalWrite(S1_rouge, etatLedOFF);
  263. // ZA precedente go
  264. digitalWrite(R8, HIGH);
  265. digitalWrite(S1_orange, etatLedON);
  266. }
  267. if(!canton1 && !canton2){ // Signal 1 au vert
  268. digitalWrite(S1_orange, etatLedOFF);
  269. digitalWrite(S1_rouge, etatLedOFF);
  270. digitalWrite(S1_vert, etatLedON);
  271. }
  272.  
  273. // Traitement du signal 2
  274. if(canton2){ // Signal 2 au rouge
  275. digitalWrite(S2_vert, etatLedOFF);
  276. digitalWrite(S2_orange, etatLedOFF);
  277. digitalWrite(S2_rouge, etatLedON);
  278. // ZA1 stop
  279. digitalWrite(R1, LOW);
  280. }
  281. if(!canton2 && canton3){ // Signal 2 a l orange
  282. digitalWrite(S2_vert, etatLedOFF);
  283. digitalWrite(S2_rouge, etatLedOFF);
  284. // ZA1 go
  285. digitalWrite(R1, HIGH);
  286. digitalWrite(S2_orange, etatLedON);
  287. }
  288. if(!canton2 && !canton3){ // Signal 2 au vert
  289. digitalWrite(S2_orange, etatLedOFF);
  290. digitalWrite(S2_rouge, etatLedOFF);
  291. digitalWrite(S2_vert, etatLedON);
  292. }
  293.  
  294. // Traitement du signal 3
  295. if(canton3){ // Signal 3 au rouge
  296. digitalWrite(S3_vert, etatLedOFF);
  297. digitalWrite(S3_orange, etatLedOFF);
  298. digitalWrite(S3_rouge, etatLedON);
  299. // ZA2 stop
  300. digitalWrite(R2, LOW);
  301. }
  302. if(!canton3 && canton4){ // Signal 3 a l orange
  303. digitalWrite(S3_vert, etatLedOFF);
  304. digitalWrite(S3_rouge, etatLedOFF);
  305. // ZA2 go
  306. digitalWrite(R2, HIGH);
  307. digitalWrite(S3_orange, etatLedON);
  308. }
  309. if(!canton3 && !canton4){ // Signal 3 au vert
  310. digitalWrite(S3_orange, etatLedOFF);
  311. digitalWrite(S3_rouge, etatLedOFF);
  312. digitalWrite(S3_vert, etatLedON);
  313. }
  314.  
  315. // Traitement du signal 4
  316. if(canton4){ // Signal 4 au rouge
  317. digitalWrite(S4_vert, etatLedOFF);
  318. digitalWrite(S4_orange, etatLedOFF);
  319. digitalWrite(S4_rouge, etatLedON);
  320. // ZA3 stop
  321. digitalWrite(R3, LOW);
  322. }
  323. if(!canton4 && canton1){ // Signal 4 a l orange
  324. digitalWrite(S4_vert, etatLedOFF);
  325. digitalWrite(S4_rouge, etatLedOFF);
  326. // ZA3 go
  327. digitalWrite(R3, HIGH);
  328. digitalWrite(S4_orange, etatLedON);
  329. }
  330. if(!canton4 && !canton1){ // Signal 4 au vert
  331. digitalWrite(S4_orange, etatLedOFF);
  332. digitalWrite(S4_rouge, etatLedOFF);
  333. digitalWrite(S4_vert, etatLedON);
  334. }
  335.  
  336. // Traitement du signal 5
  337. if(canton5){ // Signal 5 au rouge
  338. digitalWrite(S5_vert, etatLedOFF);
  339. digitalWrite(S5_orange, etatLedOFF);
  340. digitalWrite(S5_rouge, etatLedON);
  341. // ZA4 stop
  342. digitalWrite(R4, LOW);
  343. }
  344. if(!canton5 && canton6){ // Signal 5 a l orange
  345. digitalWrite(S5_vert, etatLedOFF);
  346. digitalWrite(S5_rouge, etatLedOFF);
  347. // ZA4 go
  348. digitalWrite(R4, HIGH);
  349. digitalWrite(S5_orange, etatLedON);
  350. }
  351. if(!canton5 && !canton1){ // Signal 5 au vert
  352. digitalWrite(S5_orange, etatLedOFF);
  353. digitalWrite(S5_rouge, etatLedOFF);
  354. digitalWrite(S5_vert, etatLedON);
  355. }
  356.  
  357. // Traitement du signal 6
  358. if(canton6){ // Signal 6 au rouge
  359. digitalWrite(S6_vert, etatLedOFF);
  360. digitalWrite(S6_orange, etatLedOFF);
  361. digitalWrite(S6_rouge, etatLedON);
  362. // ZA5 stop
  363. digitalWrite(R5, LOW);
  364. }
  365. if(!canton6 && canton7){ // Signal 6 a l orange
  366. digitalWrite(S6_vert, etatLedOFF);
  367. digitalWrite(S6_rouge, etatLedOFF);
  368. // ZA5 go
  369. digitalWrite(R5, HIGH);
  370. digitalWrite(S6_orange, etatLedON);
  371. }
  372. if(!canton6 && !canton7){ // Signal 6 au vert
  373. digitalWrite(S6_orange, etatLedOFF);
  374. digitalWrite(S6_rouge, etatLedOFF);
  375. digitalWrite(S6_vert, etatLedON);
  376. }
  377.  
  378. // Traitement du signal 7
  379. if(canton7){ // Signal 7 au rouge
  380. digitalWrite(S7_vert, etatLedOFF);
  381. digitalWrite(S7_orange, etatLedOFF);
  382. digitalWrite(S7_rouge, etatLedON);
  383. // ZA6 stop
  384. digitalWrite(R6, LOW);
  385. }
  386. if(!canton7 && canton8){ // Signal 7 a l orange
  387. digitalWrite(S8_vert, etatLedOFF);
  388. digitalWrite(S8_rouge, etatLedOFF);
  389. // ZA6 go
  390. digitalWrite(R6, HIGH);
  391. digitalWrite(S8_orange, etatLedON);
  392. }
  393. if(!canton7 && !canton8){ // Signal 7 au vert
  394. digitalWrite(S7_orange, etatLedOFF);
  395. digitalWrite(S7_rouge, etatLedOFF);
  396. digitalWrite(S7_vert, etatLedON);
  397. }
  398.  
  399. // Traitement du signal 8
  400. if(canton8){ // Signal 8 au rouge
  401. digitalWrite(S8_vert, etatLedOFF);
  402. digitalWrite(S8_orange, etatLedOFF);
  403. digitalWrite(S8_rouge, etatLedON);
  404. // ZA7 stop
  405. digitalWrite(R7, LOW);
  406. }
  407. if(!canton8 && canton1){ // Signal 8 a l orange
  408. digitalWrite(S8_vert, etatLedOFF);
  409. digitalWrite(S8_rouge, etatLedOFF);
  410. // ZA7 go
  411. digitalWrite(R7, HIGH);
  412. digitalWrite(S8_orange, etatLedON);
  413. }
  414. if(!canton8 && !canton1){ // Signal 8 au vert
  415. digitalWrite(S8_orange, etatLedOFF);
  416. digitalWrite(S8_rouge, etatLedOFF);
  417. digitalWrite(S8_vert, etatLedON);
  418. }
  419.  
  420. } // Fin de 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.

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

Ce montage ressemble beaucoup au montage décrit dans l’article Block Automatique Lumineux avec la carte shield "Arduino 4 relays", mais 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 nouveau montage permet, 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.

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.

3 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

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

Ma première manette pour les aiguillages DCC

Mon premier décodeur pour les aiguillages DCC

Mise en boitier de la station DCC minimale

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

Mise en boitier de la station DCC minimale


msport

Mon premier décodeur pour les aiguillages DCC


msport

Ma première manette pour les aiguillages DCC


msport

Éclairer le réseau (5)


Jean-Luc

CDM-Rail pour Ma première centrale DCC (2)


msport

Éclairer le réseau (4)


Jean-Luc

CDM-Rail pour Ma première centrale DCC (1)


msport

Rocrail pour Ma première centrale DCC


msport

Éclairer le réseau (3)


Jean-Luc

JMRI pour Ma première centrale DCC


msport

Les articles les plus lus

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

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

Une croix de pharmacie animée avec Arduino UNO

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

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

Un chenillard de DEL

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)

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

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