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

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

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

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

Le programme

Récupérez l’archive ZIP ci-dessous ; une fois son contenu extrait, vous obtenez un répertoire appelé BAL_8_Cantons_Monosens qui est à placer dans le dossier contenant vos programmes pour Arduino. Ce répertoire contient le programme BAL_8_Cantons_Monosens.ino.

Si vous utilisez des signaux à anodes commune, changez les lignes 17 et 18 du programme comme l’indiquent les commentaires en fin de ligne. Téléversez-le programme BAL_8_Cantons_Monosens.ino 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 :

/* --------------------------------------------------------------
 * programme "BAL_8_Cantons_Monosens.ino"
 * --------------------------------------------------------------
 * ce programme gere un B.A.L de 8 cantons avec 8 signaux a
 * CATHODES COMMUNES. (Signaux a anodes communes possibles)
 * la commande du relais x par INx coupe l alimentation de la ZAx
 *  _______________________________________________
 * |                                               |
 * | C EST UN ETAT LOW QUI COMMANDE LE RELAIS !!!  |
 * |_______________________________________________|
 * 
 * Relais de 9 à 2 - Signaux luimineux de 22 à 45
 * Relais 1 : D09 -> IN1 - ZA1 => Relais 8 : D02 -> IN8 - ZA8 
 * Signaux sur sorties qui se suivent ordre vert - orange - rouge
 * ------------------------------------------------------------*/
 
const byte etatLedON = HIGH;  // Mettre LOW si signaux a anodes communes
const byte etatLedOFF = LOW; // Mettre HIGH si signaux a anodes communes
 
// definition des ILS
// ------------------
const byte pinILS1 = A0;
const byte pinILS2 = A1;
const byte pinILS3 = A2;
const byte pinILS4 = A3;
const byte pinILS5 = A4;
const byte pinILS6 = A5;
const byte pinILS7 = A6;
const byte pinILS8 = A7;
 
// Commandes des relais (etat LOW sur INx excite relais x)
// -------------------------------------------------------
const byte R1 = 9;
const byte R2 = 8;
const byte R3 = 7;
const byte R4 = 6;
const byte R5 = 5;
const byte R6 = 4;
const byte R7 = 3;
const byte R8 = 2;
 
// Les signaux de B.A.L
// --------------------
// Signal 1
const byte S1_vert = 22;
const byte S1_orange = 23;
const byte S1_rouge = 24;
 
// Signal 2
const byte S2_vert = 25;
const byte S2_orange = 26;
const byte S2_rouge = 27;
 
// Signal 3
const byte S3_vert = 28;
const byte S3_orange = 29;
const byte S3_rouge = 30;
 
// Signal 4
const byte S4_vert = 31;
const byte S4_orange = 32;
const byte S4_rouge = 33;
 
 // Signal 5
const byte S5_vert = 34;
const byte S5_orange = 35;
const byte S5_rouge = 36;
 
// Signal 6
const byte S6_vert = 37;
const byte S6_orange = 38;
const byte S6_rouge = 39;
 
// Signal 7
const byte S7_vert = 40;
const byte S7_orange = 41;
const byte S7_rouge = 42;
 
// Signal 8
const byte S8_vert = 43;
const byte S8_orange = 44;
const byte S8_rouge = 45;
 
// Occupation des cantons
// ----------------------
volatile bool canton1 = false;  // true si occupe
volatile bool canton2 = false;
volatile bool canton3 = false;
volatile bool canton4 = false;
volatile bool canton5 = false;
volatile bool canton6 = false;
volatile bool canton7 = false;
volatile bool canton8 = false;

void setup()
{
  // Broches des ILS en entree et active le pullup interne
   pinMode(pinILS1, INPUT_PULLUP);
   pinMode(pinILS2, INPUT_PULLUP);
   pinMode(pinILS3, INPUT_PULLUP);
   pinMode(pinILS4, INPUT_PULLUP);
   pinMode(pinILS5, INPUT_PULLUP);
   pinMode(pinILS6, INPUT_PULLUP);
   pinMode(pinILS7, INPUT_PULLUP);
   pinMode(pinILS8, INPUT_PULLUP);
 
  // Programmes les broches relais en sortie
   for(int i = 2; i <= 9; i++) {
    pinMode(i, OUTPUT);
   }
 
  // Met les broches relais à HIGH (relais non excites)
   for(int i = 2; i <= 9; i++) {
    digitalWrite(i, HIGH); 
   }
 
  // Programme les feux des signaux en sortie
   for(int j = 22; j <= 45; j++){
     pinMode(j, OUTPUT);
   }
 
  // Eteint tous les feux des signaux
   for(int j = 22; j <= 45; j++){
     digitalWrite(j, LOW);
   }
 
  // Allume les huit signaux au vert au debut du jeu
   digitalWrite(S1_vert, HIGH);
   digitalWrite(S2_vert, HIGH);
   digitalWrite(S3_vert, HIGH);
   digitalWrite(S4_vert, HIGH);
   digitalWrite(S5_vert, HIGH);
   digitalWrite(S6_vert, HIGH);
   digitalWrite(S7_vert, HIGH);
   digitalWrite(S8_vert, HIGH);
}  // Fin de setup
 
void loop()
{
  // Scrutation des ILS
  if(digitalRead(pinILS1)==LOW) {
      canton1 = true;
      canton8 = false;
  }
  if(digitalRead(pinILS2)==LOW) {
      canton2 = true;
      canton1 = false;
  }
  if(digitalRead(pinILS3)==LOW) {
      canton3 = true;
      canton2 = false;
  }
  if(digitalRead(pinILS4)==LOW) {
      canton4 = true;
      canton3 = false;
  }
  if(digitalRead(pinILS5)==LOW) {
      canton5 = true;
      canton4 = false;
  }
  if(digitalRead(pinILS6)==LOW) {
      canton6 = true;
      canton5 = false;
  }
  if(digitalRead(pinILS7)==LOW) {
      canton7 = true;
      canton6 = false;
  }
  if(digitalRead(pinILS8)==LOW) {
      canton8 = true;
      canton7 = false;
  }

  // Traitement du signal 1
  if(canton1){ // Signal 1 au rouge
    digitalWrite(S1_vert, etatLedOFF);
    digitalWrite(S1_orange, etatLedOFF);
    digitalWrite(S1_rouge, etatLedON); 
    // ZA precedente stop
    digitalWrite(R8, LOW);
  }
  if(!canton1 && canton2){ // Signal 1 a l orange
    digitalWrite(S1_vert, etatLedOFF);
    digitalWrite(S1_rouge, etatLedOFF); 
    // ZA precedente go
    digitalWrite(R8, HIGH);
    digitalWrite(S1_orange, etatLedON);    
  }
  if(!canton1 && !canton2){ // Signal 1 au vert
    digitalWrite(S1_orange, etatLedOFF);
    digitalWrite(S1_rouge, etatLedOFF);
    digitalWrite(S1_vert, etatLedON);    
  }
 
  // Traitement du signal 2
  if(canton2){ // Signal 2 au rouge
    digitalWrite(S2_vert, etatLedOFF);
    digitalWrite(S2_orange, etatLedOFF);
    digitalWrite(S2_rouge, etatLedON); 
    // ZA1 stop
    digitalWrite(R1, LOW);
  }
  if(!canton2 && canton3){ // Signal 2 a l orange
    digitalWrite(S2_vert, etatLedOFF);
    digitalWrite(S2_rouge, etatLedOFF); 
    // ZA1 go
    digitalWrite(R1, HIGH);
    digitalWrite(S2_orange, etatLedON);    
  }
  if(!canton2 && !canton3){ // Signal 2 au vert
    digitalWrite(S2_orange, etatLedOFF);
    digitalWrite(S2_rouge, etatLedOFF);
    digitalWrite(S2_vert, etatLedON);    
  }
 
  // Traitement du signal 3
  if(canton3){ // Signal 3 au rouge
    digitalWrite(S3_vert, etatLedOFF);
    digitalWrite(S3_orange, etatLedOFF);
    digitalWrite(S3_rouge, etatLedON); 
    // ZA2 stop
    digitalWrite(R2, LOW);
  }
  if(!canton3 && canton4){ // Signal 3 a l orange
    digitalWrite(S3_vert, etatLedOFF);
    digitalWrite(S3_rouge, etatLedOFF); 
    // ZA2 go
    digitalWrite(R2, HIGH);
    digitalWrite(S3_orange, etatLedON);    
  }
  if(!canton3 && !canton4){ // Signal 3 au vert
    digitalWrite(S3_orange, etatLedOFF);
    digitalWrite(S3_rouge, etatLedOFF);
    digitalWrite(S3_vert, etatLedON);    
  }
 
  // Traitement du signal 4
  if(canton4){ // Signal 4 au rouge
    digitalWrite(S4_vert, etatLedOFF);
    digitalWrite(S4_orange, etatLedOFF);
    digitalWrite(S4_rouge, etatLedON); 
    // ZA3 stop
    digitalWrite(R3, LOW);
  }
  if(!canton4 && canton5){ // Signal 4 a l orange
    digitalWrite(S4_vert, etatLedOFF);
    digitalWrite(S4_rouge, etatLedOFF); 
    // ZA3 go
    digitalWrite(R3, HIGH);
    digitalWrite(S4_orange, etatLedON);    
  }
  if(!canton4 && !canton5){ // Signal 4 au vert
    digitalWrite(S4_orange, etatLedOFF);
    digitalWrite(S4_rouge, etatLedOFF);
    digitalWrite(S4_vert, etatLedON);    
  }
 
  // Traitement du signal 5
  if(canton5){ // Signal 5 au rouge
    digitalWrite(S5_vert, etatLedOFF);
    digitalWrite(S5_orange, etatLedOFF);
    digitalWrite(S5_rouge, etatLedON); 
    // ZA4 stop
    digitalWrite(R4, LOW);
  }
  if(!canton5 && canton6){ // Signal 5 a l orange
    digitalWrite(S5_vert, etatLedOFF);
    digitalWrite(S5_rouge, etatLedOFF); 
    // ZA4 go
    digitalWrite(R4, HIGH);
    digitalWrite(S5_orange, etatLedON);    
  }
  if(!canton5 && !canton6){ // Signal 5 au vert
    digitalWrite(S5_orange, etatLedOFF);
    digitalWrite(S5_rouge, etatLedOFF);
    digitalWrite(S5_vert, etatLedON);    
  }
 
  // Traitement du signal 6
  if(canton6){ // Signal 6 au rouge
    digitalWrite(S6_vert, etatLedOFF);
    digitalWrite(S6_orange, etatLedOFF);
    digitalWrite(S6_rouge, etatLedON); 
    // ZA5 stop
    digitalWrite(R5, LOW);
  }
  if(!canton6 && canton7){ // Signal 6 a l orange
    digitalWrite(S6_vert, etatLedOFF);
    digitalWrite(S6_rouge, etatLedOFF); 
    // ZA5 go
    digitalWrite(R5, HIGH);
    digitalWrite(S6_orange, etatLedON);    
  }
  if(!canton6 && !canton7){ // Signal 6 au vert
    digitalWrite(S6_orange, etatLedOFF);
    digitalWrite(S6_rouge, etatLedOFF);
    digitalWrite(S6_vert, etatLedON);    
  }
 
  // Traitement du signal 7
  if(canton7){ // Signal 7 au rouge
    digitalWrite(S7_vert, etatLedOFF);
    digitalWrite(S7_orange, etatLedOFF);
    digitalWrite(S7_rouge, etatLedON); 
    // ZA6 stop
    digitalWrite(R6, LOW);
  }
  if(!canton7 && canton8){ // Signal 7 a l orange
    digitalWrite(S7_vert, etatLedOFF);
    digitalWrite(S7_rouge, etatLedOFF); 
    // ZA6 go
    digitalWrite(R6, HIGH);
    digitalWrite(S7_orange, etatLedON);    
  }
  if(!canton7 && !canton8){ // Signal 7 au vert
    digitalWrite(S7_orange, etatLedOFF);
    digitalWrite(S7_rouge, etatLedOFF);
    digitalWrite(S7_vert, etatLedON);    
  }
 
  // Traitement du signal 8
  if(canton8){ // Signal 8 au rouge
    digitalWrite(S8_vert, etatLedOFF);
    digitalWrite(S8_orange, etatLedOFF);
    digitalWrite(S8_rouge, etatLedON); 
    // ZA7 stop
    digitalWrite(R7, LOW);
  }
  if(!canton8 && canton1){ // Signal 8 a l orange
    digitalWrite(S8_vert, etatLedOFF);
    digitalWrite(S8_rouge, etatLedOFF); 
    // ZA7 go
    digitalWrite(R7, HIGH);
    digitalWrite(S8_orange, etatLedON);    
  }
  if(!canton8 && !canton1){ // Signal 8 au vert
    digitalWrite(S8_orange, etatLedOFF);
    digitalWrite(S8_rouge, etatLedOFF);
    digitalWrite(S8_vert, etatLedON);    
  }
 
}  // Fin de loop

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.