Les améliorations possibles

La détection des trains
La première chose que nous pouvons améliorer est la détection des trains. Nous avons fait le choix de positionner des capteurs ponctuels à la périphérie de la zone de voies à surveillée, solution qui a le mérite de ne nécessiter aucun travaux sur les voies en elles-mêmes. Nous avons fait le choix d’utiliser des ILS mais ceux-ci ont des contacts mécaniques qui peuvent parfois se rompre ou rester collés (sans parler des problèmes de rebonds mais nous en avions tenu compte par une temporisation de 2 s). Il peut être intéressant de remplacer ces ILS par des capteurs à effet Hall qui réagissent également à la présence d’un champ magnétique ; ces capteurs sont faciles à trouver et bon marché. Le signal transmis à la carte Arduino doit rester compris entre 0 et 5 V. Pour plus d’informations sur la mise en oeuvre de capteurs à effet Hall, vous pouvez consulter l’article Capteurs à effet Hall.

Que ce soit des ILS ou bien des capteurs à effet Hall, il faut que les locomotives soient équipées d’un aimant, ce qui peut constituer une contrainte si vous voulez que vos amis viennent sur votre réseau avec leurs locomotives personnelles qui ne sont peut-être pas équipées d’aimant. On peut alors faire appel à des capteurs infra-rouge par réflexion qui vont également se fixer sous la voie entre deux traverses et qui restent relativement discrets. Encore une fois, le signal délivré à la carte Arduino doit rester compris entre 0 et 5 V et il faudra faire un traitement informatique car le capteur verra passer chaque wagon qu’il faudra ensuite reconstituer comme un seul et unique train. Ceci n’est pas très compliqué ; il suffit de mettre une temporisation pour filtrer le temps relativement court de non détection entre wagons.

Comme on l’a dit au début, le nec plus ultra est de faire de la détection d’occupation de voies par consommation de courant. On peut utiliser des détecteurs d’occupation du commerce ou bien monter ses propres détecteurs en s’inspirant de schémas trouvés sur internet ou sur notre forum. Le signal délivré doit être compris entre 0 et 5 V pour être envoyé à la carte Arduino ; si ce n’est pas le cas, on peut utiliser un coupleur optique comme on l’a fait pour le module son. Néanmoins, l’utilisation de détecteur d’occupation par consommation de courant nécessite de créer physiquement des zones de détection en coupant une file de rail aux endroits stratégiques. Les voitures et wagons doivent consommer du courant pour être détectés. Pour des voitures, c’est assez simple si elles sont éclairées et pour les wagons, il suffit de graphiter les essieux ou de mettre des feux de fin de convois.

La figure 1 montre en bleu la forme des zones de protection du PN pour chaque voie ainsi que le positionnement de certains accessoires (cliquez sur l’image pour l’agrandir). La distance "L" est la longueur du plus long train circulant sur le réseau. L’utilisation de ce genre de détecteurs est d’autant plus facile que le réseau a été conçu en ce sens, en créant par exemple des cantons pour que plusieurs trains puissent se suivre. Une fois le réseau monté, c’est plus compliqué d’intervenir dessus sans être pour autant impossible ; il suffit de couper les rails et de souder sur les flancs un fil électrique pour réalimenter la portion. Avec le décor en place, cela peut devenir assez sportif…

Figure 1

Zones de protection des voies avec des détecteurs d’occupation

Le gros avantage des détecteurs d’occupation par rapport aux capteurs ponctuels en périphérie de zone à protéger est qu’on n’a plus à tenir compte de conditions à respecter lors de l’initialisation. Si un détecteur envoie un signal, c’est que la zone est occupée et qu’un train approche du PN et il n’y a plus à se poser la question de l’état antérieur de la zone. Mais il faut aussi un minimum de tension sur la voie pour détecter un train arrêté en gare ; ceci ne concerne pas un réseau en DCC puisque la voie est toujours sous tension, même avec des trains à l’arrêt.

Il faut aussi se rappeler que la mise en parallèle de plusieurs capteurs sur une même entrée n’est possible que pour des contacts (ILS tels qu’ils ont été montés dans ce projet) ou bien des sorties à collecteur ouvert (capteurs à effet Hall ou détecteurs d’occupation par consommation de courant). Un peu d’électronique peut se révéler nécessaire pour traiter plusieurs capteurs. Dans le cas de la figure 1, il ne faut que deux détecteurs d’occupation (un sur chaque voie) qui peuvent alors être reliés aux entrées 2 et 3 de la carte Uno ; dans ce cas, l’entrée 3 travaille de la même façon que l’entrée 2 pour déterminer l’occupation globale du PN comme nous l’avons expliqué dans le premier article et le traitement de l’information n’est plus qu’un simple exercice de programmation.

Les programmes donnés dans cette série d’articles ont été conçus pour traiter des événements de courte durée (fermeture d’ILS) et ils surveillent la périphérie de la zone PN en faisant appel aux interruptions pour ne pas louper des événements. Les détecteurs d’occupation fournissent des signaux de longue durée (tant que la zone à surveiller est occupée) ; le programme est considérablement simplifié puisqu’il suffit de lire l’état des entrées reliées aux détecteurs en début de boucle loop pour déterminer l’état d’occupation de la zone du PN. Toutes les entrées sont utilisables à la condition que le signal fourni par le détecteur soit ramené dans l’intervalle 0-5 V.

Quatre feux de PN au lieu de deux
Il suffit de rajouter deux LED et une résistance de 470 Ω sur la sortie 5 (PWM) comme le montre la figure 2, et bien évidemment modifier le programme. Chaque ensemble de deux LED sera positionné d’un côté ou l’autre des voies et bien évidemment les LED d’un même ensemble seront positionnées de chaque côté de la route pour être vues par les automobilistes devant s’arrêter avant la barrière.

Figure 2

Montage pour quatre feux de passage à niveau

Concernant le programme, il suffit d’instancier un deuxième objet (feu2PN) avec LightDimmer. Chaque opération sur le premier objet est répétée sur le deuxième.

/*******************************************************************************
 * PN_TIB_4Feux_Barrieres_SortieSon_InitFerme.ino
 * *****************************************************************************
 * Programme developpe pour le projet de PN pour Train In Box.
 * Il prend en compte l arrivee du train, le clignotement des feux en simulant 
 * une ampoule a filaments, un delai avant mouvement des barrieres,
 * le mouvements des deux barrieres sur 90° d amplitude (depend de 
 * la transmission adoptee).
 * Le programme s'initialise barrieres fermees, donc AVEC TRAIN EN GARE SUR TIB.
 * La LED_SON est allumee tant que sonnerie doit jouer ; cette sortie commande
 * le module sonore.
 * *****************************************************************************
 * Christian BEZANGER - 13 Novembre 2018 - 2 Juin 2019 - 29 mai 2020
 ******************************************************************************/

#include <LightDimmer.h>  // Bibliotheque pour gerer les feux du PN
#include <Servo.h>        // Bibliotheque pour gerer les barrieres du PN

const byte ILS=2; // entree des capteurs 
const byte LED=6; // sortie PWM pour deux feux du PN
const byte LED2=5; // sortie PWM pour deux autres feux du PN
const byte LED_SON=7; // sortie pour indiquer sonnerie
const byte S1=4; // sortie pour le servomoteur 1
const byte S2=8; // sortie pour le servomoteur 2
unsigned int compteur = 1;  // compteur d evenements (survol ILS)

// Variables utilisateur pour reglage du mouvement des barrieres
// -------------------------------------------------------------
unsigned long delaiFermeture = 0; // Regle le delai entre clignotement LED 
// et fermeture barrieres - entre 2000 et 8000 mais 0 sur TIB (pas de delai)
int speedServo = 30;  // Regle la vitesse de mouvement des barrieres

// Variables non utilisateur
// -------------------------
volatile static boolean etatZonePN = true; // true si la zone du PN est occupee
volatile static boolean old_etatZonePN = false; // etat anterieur de la zone
volatile static unsigned long old_top_debutISR;  // Date anterieure d appel ISR
unsigned long old_top = 0;  // variable pour afficher donnees utiles
int posServo = 90; // position courante a initialiser imperativement FERMEE
int posOuvert = 0;  // barriere a la verticale
int posFerme = 90; // barriere a l'horizontale (90° de la verticale)
unsigned long topAttente = 0; // top pris au début franchissement de la zone PN
boolean etatSon = false; // true si sonnerie doit retentir

// Instanciations
LightDimmer feuPN;
LightDimmer feu2PN;
Servo servo1;
Servo servo2;

void changeEtat() { // routine d'interruption (ISR)
  unsigned long top_debutISR = millis();  // date appel ISR
  if((top_debutISR - old_top_debutISR) > 2000) {
    // 2 secondes au moins entre execution ISR
    etatZonePN = !etatZonePN; // etat passe a etat oppose
    old_top_debutISR = top_debutISR;  // initialisation date anterieure d appel ISR
  }
} // fin de ISR

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200); // communication avec le moniteur
  pinMode (ILS, INPUT_PULLUP);  // entree capteur
  pinMode (LED_BUILTIN, OUTPUT);  // LED du module allumee si Zone PN occupee
  pinMode (LED, OUTPUT);  // sortie pour feux du PN
  pinMode (LED2, OUTPUT); // sortie pour autres feux du PN
  pinMode (LED_SON, OUTPUT);
  attachInterrupt (digitalPinToInterrupt(ILS), changeEtat, FALLING);
  digitalWrite (LED_BUILTIN, LOW);
  feuPN.begin(LED, HIGH); // LED s'allume avec etat haut
  feu2PN.begin(LED2, HIGH); // LED2 s'allume avec etat haut
  servo1.attach(S1);
  servo2.attach(S2);
  // initialisation des barrieres en position fermee
  servo1.write(posFerme); // barriere 1 FERMEE apres initialisation
  servo2.write(posFerme); // barriere 2 FERMEE apres initialisation
  delay(2000);
  digitalWrite (LED_BUILTIN, HIGH); // Indique fin de setup
}  // fin de setup

void loop() {
  // put your main code here, to run repeatedly:
  if(etatSon == false) {digitalWrite (LED_SON, LOW);}
  if(etatSon == true) {digitalWrite (LED_SON, HIGH);}
  if(etatZonePN == false) {
    old_etatZonePN = etatZonePN;
    digitalWrite (LED_BUILTIN, LOW); // eteint LED de controle de la zone PN
    etatSon = false;  // pas de sonnerie
    feuPN.stopBlink();  // arrete le clignotement
    feu2PN.stopBlink(); // arrete le clignotement
    feuPN.off();  // eteint les feux
    feu2PN.off(); // eteint les feux
    // ouverture barriere
    if(posServo > posOuvert) {
      posServo = posServo - 1;
      servo1.write(posServo);
      servo2.write(posServo);
      delay(speedServo);
    }  // fin du test sur position des servos
  }  // fin du test sur etat de la Zone du PN -> false
  if(etatZonePN == true) {
    if(etatZonePN != old_etatZonePN) {
      topAttente = millis();  // prend un top d'entree dans zone PN
      old_etatZonePN = etatZonePN;
      etatSon = true; // sonnerie
    }  // fin du deuxieme if
  digitalWrite (LED_BUILTIN, HIGH); // allume LED de controle de la zone PN
  feuPN.startBlink(); // commence le clignotement
  feu2PN.startBlink();  // commence le clignotement
  // fermeture barriere après attente
  if(millis() - topAttente > delaiFermeture) {
      if(posServo <= posFerme) {
        posServo = posServo + 1;
        servo1.write(posServo);
        servo2.write(posServo);
        if(posServo >= 89) {etatSon = false;}
        delay(speedServo);
      }  // fin du test sur position des servos 
    }  // fin du test sur delai avant ouverture
  }  // fin du test sur etat de la Zone du PN -> true
  LightDimmer::update();
  if(old_top_debutISR != old_top) { // Affichage pour chaque nouveau survol ILS
    Serial.print(compteur);
    Serial.print("     ");
    Serial.print(old_top_debutISR);
    Serial.print("     ");
    Serial.println(old_top_debutISR - old_top);
    old_top = old_top_debutISR; 
    compteur = compteur + 1;   
  }
}  // fin de loop

Vous pouvez voir le fonctionnement de ce PN en cliquant sur le lien ci-dessous :
https://wokwi.com/projects/40546224...
Wokwi ne permettant pas de mettre deux LED en série, chaque sortie de feu de PN n’est donc constituée que d’une seule LED.

La bibliothèque LightDimmer permet de régler la fréquence de clignotement, les temps de montée et descente de la luminosité des ampoules pour reproduire l’inertie thermique des filaments. Les choix faits par défaut dans la bibliothèque reproduisent très bien un PN français de la SNCF, si bien qu’il n’est pas forcément nécessaire de les changer. Reportez-vous au fichier « readme » fourni avec la bibliothèque.

Mouvement des barrières
Comme on l’a dit, les barrières en plastique du PN Auhagen sont très fragiles et ce PN ne ressemble pas vraiment à ce qu’on trouve en France. On peut donc envisager d’autres marques mais si on veut appliquer la transmission du mouvement décrite dans cette série d’articles, la commande de la barrière doit se faire en tirant ou poussant une tige ou une corde à piano. Peu importe la valeur du déplacement, il suffit de modifier la forme de la came. Par contre, une corde à piano devra être rigidifiée comme on l’a fait pour le PN Auhagen. Parmi les candidats possibles, nous conseillons les barrières réalisées en impression 3D par NTrail45 ; l’avantage est que vous n’avez pas à monter la barrière car elle est livrée fonctionnelle, l’inconvénient est que le mouvement est limité à l’ouverture par le socle sur lequel vient buter le contrepoids. Il convient de limer un peu ce socle sur un côté. Il existe aussi des feux équipés d’une LED donc fonctionnels ; un ensemble de deux barrières et de deux feux vous coûtera un peu plus de 50 € (prix 2020) mais ceci vous évite quelques heures de travail.

Il existe aussi de très beaux kits en laiton de barrières oscillantes manœuvrées par un ou une garde-barrières. Il fallait tourner une manivelle pour faire descendre ces barrières qui rebondissaient un peu en arrivant en bout de course. Ceux qui voudront reproduire ce mouvement de façon très réaliste auront intérêt à utiliser la bibliothèque SlowMotionServo de LOCODUINO qu’on trouve dans le gestionnaire de bibliothèques de l’IDE. Pour plus d’informations sur la bibliothèque SlowMotionServo, consultez l’article La bibliothèque SlowMotionServo.

Une autre amélioration possible est de construire un passage à niveau automatique SAL 4, c’est-à-dire avec quatre barrières. Il suffit de rajouter deux autres servomoteurs, d’alimenter tous les servos à part (parce que cela ferait trop pour votre carte Uno) et bien évidemment, modifier le programme. C’est un peu plus compliqué de fermer quatre barrières, car elles se ferment deux par deux, les unes après les autres. Par contre, elles s’ouvrent en même temps. La sonnerie s’arrête juste après la fermeture des deux premières barrières. Voilà donc un bel exercice de programmation !

La vidéo ci-dessous vous donne un exemple de PN SAL 4 :

Recherche de pannes

Vous avez installé le PN sur votre réseau, conformément à cette série d’articles et lors de la mise en route de la carte Arduino, ça ne fonctionne pas comme cela devrait. Voici quelques éléments de réponses aux questions que vous vous posez.

Lorsque la carte est branchée, rien ne se passe

Vérifiez que la carte Arduino est bien alimentée (sa LED ON doit être allumée).

Si elle l’est, vérifiez que la LED reliée à la sortie 13 est allumée après l’initialisation (la zone est supposée être occupée à l’initialisation).

Si oui, les LED du PN clignotent-elles ? Non, alors vérifiez qu’elles ne sont pas montées à l’envers et vérifiez aussi les connexions avec la carte Arduino. Cette partie du montage doit fonctionner sans problème.

Le train tourne mais rien ne se passe

Avez-vous pensé à mettre un aimant sous la locomotive ? Car sans aimant, pas de déclenchement des ILS !

Vérifiez que la carte Arduino est bien alimentée (sa LED ON doit être allumée).

Essayez de surpasser un ILS en pontant les fils qui en sortent au niveau du domino de connexion. Cette action équivaut à la fermeture des contacts de l’ILS et doit donc déclencher des actions au niveau de la LED de la carte Arduino, des LED de feux de PN, des mouvements de barrières.

Les barrières s’ouvrent quand elles devraient se fermer et se ferment quand elles devraient être ouvertes.

Cela peut être dû à une mauvaise initialisation de la carte Arduino. Amenez un train dans la gare du réseau TIB puis appuyez sur le bouton RESET de la carte Arduino. Attendez que l’initialisation se fasse ; les barrières doivent être fermées et les feux doivent clignoter. Faites démarrer le train et laissez-le tourner ; le comportement du passage à niveau doit être correct. Sinon, c’est qu’un ILS ne joue pas son rôle et ne détecte pas quand un train passe. La solution est de le changer. Pour tester tous les ILS, laisser le train tourner sur toutes les voies possibles.

La barrière n’est pas horizontale quand elle est fermée

Essayez de régler la rallonge de la tige de commande sans forcer.

La barrière est à moitié ouverte au lieu de complètement ouverte

La tige de commande ne redescend pas assez et ceci doit se voir car elle ne frotte plus sur la came. Changez l’élastique de rappel pour un plus petit qui exercera une force de rappel un peu plus grande.

Le fonctionnement des feux est correct mais les barrières ne bougent pas

Vérifiez la connexion des servomoteurs à la carte Arduino. Vérifiez aussi que la transmission mécanique ne soit pas coincée par un objet ou un élastique tirant trop fort sur la tige de commande. Au besoin, retirez les deux cames et regardez si les servomoteurs tournent correctement.

Vérifiez que les servomoteurs que vous avez utilisés ne consomment pas trop de courant par rapport à ce que peut délivrer la sortie 5 V de la carte Arduino ; au besoin, alimentez les servomoteurs avec une alimentation à part.

Une des deux barrières ne bouge pas

Vérifiez le fonctionnement de son servomoteur et que rien ne bloque la transmission mécanique.

Tout fonctionne sauf le son

Vérifiez que la carte Arduino du module sonore est bien alimentée (sa LED ON doit être allumée) et vérifiez les connexions avec la carte Uno de commande du PN.

Lors de l’initialisation de la carte Arduino du module sonore, vous devez entendre la sonnerie durant trois secondes ; est-ce le cas ?

Vérifiez les connexions du DFPlayer avec la carte Arduino du module sonore.

Vérifiez que vous avez bien inséré la carte SD et que celle-ci contient bien un fichier audio au format MP3.

Si cela ne fonctionne toujours pas, branchez la carte Arduino du module sonore à votre ordinateur, ouvrez le moniteur et regardez les messages envoyés par DFPlayer ; ils vous permettront de comprendre d’où peut venir le problème.

J’entends la sonnerie durant trois secondes, puis plus rien

Vérifiez la sortie son de la carte Arduino de commande du PN en branchant une LED entre cette sortie et la masse (GND) ; cette LED doit être allumée lorsque la sonnerie doit jouer.

Vérifiez alors la connexion de cette sortie son avec le module sonore.

Si vous entendez la sonnerie en reliant l’entrée 2 de la carte Arduino du module sonore à la masse (GND) de cette carte, alors le problème vient sans doute du coupleur optique ; remplacez-le.

Le fonctionnement de mon PN est erratique : un coup ça marche, puis ça ne marche plus

C’est certainement dû à des mauvais contacts dans le câblage. Vérifiez le câblage, les connecteurs Dupont utilisés. Remplacer les dominos d’électricien par de vraies soudures bien plus fiables.

Le programme ne veut pas se téléverser sur ma carte Arduino

Vérifiez que vous avez sélectionné le bon type de carte dans le menu Outils et que le port série utilisé est le bon ; au besoin, réglez ces paramètres.

Vérifiez que vous avez pensé à inclure la bibliothèque « LightDimmer » dans votre IDE ; sans cette bibliothèque, la compilation génère un message d’erreur (puisqu’il manque une « partie » du programme), ce qui empêche le téléversement.

Le programme a été modifié et depuis, plus rien ne marche

Visiblement, cette modification est la cause du dysfonctionnement. Il faut trouver pourquoi en demandant de l’aide sur notre forum.

Il est toujours possible de revenir en arrière, il suffit de téléverser à nouveau dans votre carte Arduino le programme publié dans cette série d’articles (ou l’avant dernière version que vous avez modifiée et qui fonctionnait).

Conclusion

Faire une recherche de panne n’a rien de compliqué, il suffit d’être méthodique. Souvent, on oublie de brancher quelque chose, parfois c’est un composant qui claque. Mais la plupart du temps, ce sont des mauvais contacts dus à des liaisons mal serrées ou à de mauvaises soudures. Le problème peut aussi se cacher derrière quelque chose qu’on ne remet pas en cause parce qu’on est persuadé d’avoir bien fait ; par exemple, vous êtes certain que votre carte SD contient bien un fichier MP3 car vous avez vous-même fait la copie de ce fichier mais êtes vous certain que cette copie n’a pas corrompu votre fichier ? Le diable se cache parfois dans les détails !

Ce montage n’est pas seulement un montage électronique ; il y a aussi une partie de pure mécanique qui peut gripper ou casser, mais ce genre de panne n’arrive qu’au bout d’un certain temps de fonctionnement. Par exemple, un élastique peut devenir cassant avec le temps. Il est donc important de bien surveiller les organes mécaniques de ce passage à niveau.

Enfin rassurez-vous : les montages bien construits peuvent aussi fonctionner parfaitement et ne jamais connaître de panne !