LOCODUINO

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

samedi 5 décembre 2020

34 visiteurs en ce moment

Passage à niveau géré par Arduino (1)

La détection de l’approche des trains

. Par : Christian

Cet article est le premier d’une série de cinq (voir les titres dans l’encadré) présentant un projet de passage à niveau automatisé conçu par étapes successives et particulièrement adapté au réseau Train’ In Box vendu par LR-Modélisme. Bien évidemment, le PN réalisé ici peut aussi convenir à des réseaux plus grands qui permettront d’ailleurs de mieux reproduire la réalité alors que certaines concessions ont dû être faites pour le réseau TIB. Mais la série d’articles est aussi l’occasion d’un tuto pour les débutants expliquant comment on conçoit un projet complexe et comment on choisit les solutions technologiques.

Locoduino a déjà présenté des projets de passage à niveau dans les articles Un automatisme de Passage à Niveau et Etude d’un passage à niveau universel ainsi que dans l’article Comment concevoir rationnellement votre système. Mais ce projet-ci a été conçu pour être facilement monté sur des réseaux déjà terminés en ne nécessitant aucun travail sur les voies ou le décor. Cela nous a amenés à adopter des solutions technologiques simples, parfaitement adaptées à ceux qui débutent alors que d’autres choix auraient pu se révéler plus judicieux. Comme vous le verrez, cette simplicité n’a rien cédé à la fiabilité. Ce premier article explique comment repérer l’approche d’un train pour protéger le passage à niveau, une étape capitale puisque tout le reste en dépend.

Que se passe-t-il lorsqu’un train approche un passage à niveau ?

Le train doit être détecté très en amont du PN afin de laisser du temps pour les différentes actions à faire dans l’ordre :
-  Sonnerie et clignotement des feux routiers
-  Attendre un certain délai (de l’ordre de 8 secondes)
-  Abaissement et fermeture des barrières
-  Arrêt de la sonnerie alors que les feux continuent à clignoter

Quasiment aussitôt que le train est passé, on observe simultanément l’arrêt du clignotement des feux routiers et l’ouverture des barrières.

La vidéo suivante montre un PN à deux barrières (PN SAL 2) :

Cas d’une voie unique parcourue dans un seul sens

La figure 1 montre un PN avec une voie unique que nous supposerons parcourue dans un seul sens, de la gauche vers la droite. Afin de laisser du temps pour réaliser les différentes actions, la zone sur laquelle on doit détecter l’arrivée du train n’est pas symétrique par rapport au PN, comme le montre la figure 1.

Figure 1
Figure 1
Zone de détection à consommation de courant

Tant que le moindre essieu est sur la zone, le PN doit rester fermé ; dès qu’il n’y a plus d’essieu sur la zone, le PN peut s’ouvrir. La zone n’est pas symétrique pour que le PN s’ouvre dès que le train est entièrement passé.

Le mieux pour détecter des essieux est d’utiliser des détecteurs de consommation et d’avoir des wagons avec essieux graphités ou bien consommateurs de courant (éclairage par exemple). Cette solution qui est possible pour l’analogique comme pour le numérique, requiert néanmoins des coupures dans le rail qui sont souvent difficiles à réaliser si le réseau existe déjà et n’a pas été conçu dans ce sens. Le cinquième article évoquera l’utilisation de détecteurs de consommation comme une amélioration possible de ce montage.

Pour la suite de cet article, nous évoquerons des moyens de détection qui peuvent être ajoutés facilement à un réseau existant sans avoir à modifier celui-ci. Ces moyens de détection sont des capteurs IR, des ILS (Interrupteur à Lames Souples) ou bien des détecteurs à effet Hall. Ces deux derniers composants nécessitent la pose d’un aimant sous la locomotive et seule celle-ci est réellement détectée ; il faut donc tenir compte des wagons qui suivent alors que leur présence n’est pas vue par les détecteurs. Les trois moyens de détection sont utilisables aussi bien en analogique qu’en numérique. De façon générale, nous appellerons capteur ces moyens de détection et un capteur délivre un signal électrique lorsqu’il détecte la locomotive d’un train.

Cas d’une voie unique banalisée

La figure 2 montre un PN avec une voie unique banalisée, c’est-à-dire pouvant être parcourue dans les deux sens. La zone sur laquelle il faut détecter les trains (en rouge) est cette fois symétrique. Des capteurs sont posés sur cette voie à la frontière de la zone ; lorsqu’ils sont déclenchés par une locomotive, rien ne nous permet de savoir si celle-ci entre ou sort de la zone. Cependant, si on connaît l’état antérieur de la zone (libre ou occupée), on peut en déduire s’il s’agit d’une entrée ou d’une sortie.

Figure 2
Figure 2
Voie unique banalisée

Examinons la figure 2 et supposons que le train se déplace de A vers B. La zone est libre et lorsque le train arrive sur le capteur C1, celui-ci se déclenche. Il y a bien franchissement de la frontière de la zone et comme celle-ci était jusqu’alors libre, on peut en déduire que le train entre dans la zone qui devient alors occupée. Lorsque le train arrive au capteur C2, celui-ci déclenche et comme la zone était occupée, on en déduit que le train sort de la zone et qu’elle devient à nouveau libre.

Le raisonnement serait le même pour un train se déplaçant de B vers A. On comprend alors que tout déclenchement de capteur fait basculer l’état de la zone (de libre vers occupée ou réciproquement). Il est donc important de lancer le programme de surveillance avec les bonnes conditions initiales, par exemple, si on décide que les conditions initiales sont zone libre, alors il faut mettre en route le programme en absence de train sur la zone. On peut aussi décider que les conditions initiales sont zone occupée et dans ce cas, il faut démarrer le programme en présence d’un train sur la zone.

Supposons maintenant qu’un train se déplace de A vers B, la zone étant initialement libre. En arrivant sur le capteur C1, celui-ci déclenche et la zone devient occupée. Supposons que le train s’arrête et reparte en marche arrière (il refoule) : lorsque la locomotive repasse le capteur C1, celui-ci déclenche et la zone devient libre. Le train est sorti de la zone par où il est rentré et l’automatisme a fonctionné quand même. Le refoulement est pris en compte.

Pour les dimensions de la zone, la distance PN-frontière doit être supérieure à la longueur du plus grand train roulant ; ainsi, lorsque la locomotive ressort de la zone, l’ensemble du convoi est bien passé et le PN peut s’ouvrir (voir figure 2).

Cas de deux voies parcourues dans un seul sens

La figure 3 montre un PN avec deux voies, chacune étant parcourue dans un seul sens avec des trains qui roulent à gauche (cas général de la SNCF). On peut augmenter la largeur de la zone pour inclure les deux voies. Il faudra alors disposer deux autres capteurs C3 et C4 sur la deuxième voie.

Figure 3
Figure 3
PN à deux voies

La zone étant libre, un train arrive sur la voie 1 de A vers B ; il déclenche C1 et la zone devient occupée. Peu de temps après, un deuxième train se déplace sur la voie 2 de B vers A ; il déclenche C4 et la zone redevient libre alors qu’elle est en réalité occupée par les deux trains ! On voit que le système protégeant le PN ne fonctionne pas.

Pour s’affranchir de cette difficulté, on peut supposer que C1 et C4 sont des capteurs entrant (vu le sens de circulation des trains) alors que C2 et C3 sont des capteurs sortant. Le déclenchement d’un capteur entrant fait que la voie devient occupée et le déclenchement d’un capteur sortant fait que la voie devient libre ; on parle alors des voies et non de la zone. La zone est libre si les deux voies sont libres et elle est occupée dès qu’une des deux voies est occupée. Le système de protection du PN fonctionne mais la spécialisation des capteurs (entrant ou sortant) fait que le refoulement n’est plus pris en compte : si un train passe par C1, la zone devient occupée et le PN se ferme mais si le train ressort par C1 après refoulement, le déclenchement de ce capteur fait que la zone reste occupée et que le PN reste fermé alors que plus aucun train n’occupe la zone.

Cette solution n’est donc pas suffisante. Le mieux est de considérer que chaque voie est banalisée (deux sens de circulation possibles même si un sens est imposé) et dispose de sa propre zone de protection de PN (comme étudié dans le paragraphe précédent). La zone Z de protection du PN est alors constituée de deux sous-zones Z1 et Z2 et pour être libre, les deux sous-zones doivent être libres. Dès qu’une sous-zone est occupée, la zone de protection du PN doit être considérée comme occupée. C’est ce que montre la figure 4.

Figure 4
Figure 4
PN à deux voies avec protection complète

Cette solution permet la circulation de trains dans n’importe quel sens sur n’importe quelle voie et peut aussi être extrapolée à un nombre de voies quelconque. Elle prend aussi en compte des bifurcations (aiguilles) situées en amont ou en aval du PN ; il suffit de bien définir les sous-zones pour chaque voie munie ou non d’aiguilles. Les capteurs doivent être positionnés suffisamment loin du PN pour que la préparation des feux et des barrières ait le temps de se faire et ceci n’est pas toujours facile à réaliser sur de petits réseaux comme TIB (Train’In Box) vendu par LR-Modélisme.

Cas général de faisceaux de voies

La figure 5 montre une configuration de voies avec aiguilles en amont ou en aval (ce cas correspond à la figure 9 de l’article Etude d’un passage à niveau multivoies). On y voit deux sous-zones Z1 et Z2 et 6 capteurs C1 à C6. C1 et C2 concernent la zone Z1 et C3 à C6 la zone Z2. L’automatisme fonctionne pour tous les sens de circulation et prend en compte le refoulement possible des trains.

Figure 5
Figure 5
PN avec convergence de voies

Mise en œuvre

Voici le cahier des charges à respecter :
- Pour chaque zone ou chaque sous-zone, les capteurs peuvent être mis en parallèle sur une même entrée d’Arduino (une entrée par sous-zone) puisque leur rôle est identique (détecter un franchissement de la frontière de la zone ou sous-zone).

- Chaque zone ou sous-zone a un état qui est une variable booléenne (par exemple, false pour libre et true pour occupé).

- Tout déclenchement de capteur fait basculer l’état de la zone ou sous-zone concernée.

- Le programme doit être lancé en respectant les conditions initiales (absence ou présence de train suivant que l’état initial est libre ou occupé).

- Si une zone est constituée de sous-zones, toutes celles-ci doivent être libres pour que la zone soit libre.

- Dès que la zone de protection du PN est occupée, le PN doit se fermer et le rester (sonnerie, feux, barrières). Lorsque la zone devient libre, le PN s’ouvre.

La fait de mettre tous les ILS de la zone sur une seule entrée n’est pas fait uniquement pour simplifier le montage ; ce choix permet une évolution du projet pour un PN à deux voies. En effet, si une zone est constituée de deux sous-zones (cas de la figure 4), celles-ci peuvent et doivent être surveillées par les entrées 2 et 3 de la carte Uno qui permettent une interruption externe. Ceci impose une modification du programme car tout ce qui est fait pour la première zone doit être répété pour la deuxième. Ensuite le programme doit faire un petit traitement logique des conditions de chaque sous-zone pour déterminer si la zone globale est occupée ou non.

Application au coffret Train’In Box (TIB)

Comme il n’y a qu’un seul train qui circule sur le réseau TIB, nous pouvons nous contenter de délimiter qu’une seule zone pour protéger le PN. La première chose à faire est de déterminer l’emplacement des capteurs ; ceux-ci doivent se trouver suffisamment loin du PN pour laisser le temps pour la manœuvre des barrières et aussi pour tenir compte de la longueur du plus long train qui circule sur le réseau. Sur un grand réseau, ce n’est pas difficile, mais sur un petit réseau comme TIB, c’est plus délicat. La figure 6 montre où placer les capteurs qui sont des ILS sur le réseau TIB (repérés par des points jaunes) ; ceux-ci divisent le réseau en deux portions quasiment identiques, ce qui fait que les barrières ne sont pas plus souvent fermées qu’ouvertes (dans la réalité, les barrières sont plus souvent ouvertes que fermées). Les ILS se trouvent à 0,65 m de part et d’autre du PN ce qui donne une longueur de voies surveillées de 1,30 m soit 47% de la longueur totale du circuit (approximativement 2,75 m pour la voie intérieure). Pour une vitesse "raisonnable" de la locomotive, les essais de circulation ont montré que le délai entre la détection et l’arrivée du train juste avant le PN est compris entre 2,5 et 4 secondes (ce qui est peu mais TIB est un petit réseau de début qui peut imposer quelques concessions : pas de trop grands trains, pas de délai entre le début de sonnerie et la fermeture des barrières, vitesse de roulement pas trop élevée pour les trains, etc.).

Figure 6
Figure 6
Emplacement des capteurs ILS sur le réseau TIB

Une fois positionnés, ces quatre ILS sont reliés à la carte Arduino Uno selon le schéma de la figure 7. Sur le réseau TIB, un seul train peut circuler à la fois, donc il n’y a pas besoin d’envisager des sous-zones et tous les ILS peuvent être reliés à la même entrée d’Arduino ; nous choisissons l’entrée numérique 2 car elle a la particularité de pouvoir provoquer une interruption.

Figure 7
Figure 7
Schéma pour relier les ILS à la carte Arduino Uno

Le programme suivant allume la LED L (LED_BUILTIN) reliée à la sortie 13 de la carte Uno chaque fois que la zone PN est occupée et permet de vérifier que nos trains sont bien détectés. Si la carte Arduino est reliée à un ordinateur, le programme affiche également dans le moniteur de l’IDE trois données :
- un numéro de survol d’un ILS
- l’heure de ce survol (en ms)
- le temps écoulé depuis le survol de l’ILS précédent (en ms)
Cet affichage n’est pas indispensable mais permet d’avoir le temps de parcours de la zone du PN et peut se révéler utile pour vérifier qu’il n’y a pas de déclenchement intempestif d’ILS [1] ; le programme fonctionne même si la carte Arduino n’est pas reliée à un ordinateur.

Le fait de faire apparaître le moniteur de l’IDE provoque un RESET de la carte Arduino ; il faut veiller à ce qu’un train soit sur la zone de protection du PN puisque cette zone est supposée occupée lors de l’initialisation.

Une routine d’interruption (changeEtat()) est exécutée chaque fois que l’entrée 2 passe de HIGH à LOW (front descendant) mais pour éviter que le même ILS déclenche deux fois de suite (rebond, problème de positionnement de l’aimant par rapport à l’ILS, etc.), on ne prend pas en compte un front descendant qui arriverait moins de deux secondes après le front descendant déjà pris en compte. Cela revient à dire que si la routine d’interruption est exécutée deux fois en moins de deux secondes, seule la première aura un effet pour changer l’état de la zone entre false (zone libre) et true (zone occupée). En fait, l’utilisation d’une interruption permet de ne pas louper l’approche d’un train par rapport à un ILS et la temporisation de deux secondes permet à la locomotive de dégager l’ILS pour ne pas avoir plusieurs déclenchements sur le même événement.

La fonction millis() ne s’incrémente plus à l’intérieur d’une routine d’interruption (ISR), aussi quand on l’utilise pour dater l’événement (survol ILS), elle renvoie la dernière valeur qu’elle avait avant l’exécution de l’ISR ; ceci n’est pas bien gênant car la précision recherchée n’est pas à ce point.

La boucle principale reprend l’état de la zone pour allumer ou éteindre la LED de la carte Uno, puis procède à l’affichage des trois données chaque fois qu’il y a survol d’un ILS.

  1. /********************************************************************************
  2.  * PN_TIB_survey.ino
  3.  ********************************************************************************
  4.  * Ce programme est dans le domaine public. Il surveille la zone du PN
  5.  * Dernière mise a jour : 27 mai 2020
  6.  * pour eviter que ILS declenche deux fois lors du meme survol
  7.  *******************************************************************************/
  8. const byte ILS=2; // Entree commune pour tous les ILS
  9. unsigned int compteur = 1; // compteur d evenements (survol ILS)
  10.  
  11. volatile static boolean etatZonePN = true; // Initialiser avec trains en gare sur TIB
  12. volatile static unsigned long old_top_debutISR; // Date anterieure d appel ISR
  13. unsigned long old_top = 0; // variable pour afficher donnees utiles
  14.  
  15. void changeEtat() { // routine d'interruption (ISR)
  16. unsigned long top_debutISR = millis(); // date appel ISR
  17. if((top_debutISR - old_top_debutISR) > 2000) {
  18. // 2 secondes au moins entre execution ISR
  19. etatZonePN = !etatZonePN; // etat passe a etat oppose
  20. old_top_debutISR = top_debutISR; // initialisation date anterieure d appel ISR
  21. }
  22. } // fin de ISR
  23.  
  24. void setup() {
  25. // put your setup code here, to run once:
  26. Serial.begin(115200); // Communication avec le moniteur
  27. pinMode (ILS, INPUT_PULLUP);
  28. pinMode (LED_BUILTIN, OUTPUT);
  29. // changeEtat est la routine d'interruption sur l'entree ILS
  30. // elle est declenchee par un front descendant
  31. attachInterrupt (digitalPinToInterrupt(ILS), changeEtat, FALLING);
  32. digitalWrite (LED_BUILTIN, LOW);
  33. } // fin de setup
  34.  
  35. void loop() {
  36. // put your main code here, to run repeatedly:
  37. if(etatZonePN == false) {digitalWrite (LED_BUILTIN, LOW);}
  38. if(etatZonePN == true) {digitalWrite (LED_BUILTIN, HIGH);}
  39. if(old_top_debutISR != old_top) { // Affichage pour chaque nouveau survol ILS
  40. Serial.print(compteur);
  41. Serial.print(" ");
  42. Serial.print(old_top_debutISR);
  43. Serial.print(" ");
  44. Serial.println(old_top_debutISR - old_top);
  45. old_top = old_top_debutISR;
  46. compteur = compteur + 1;
  47. }
  48. } // fin de loop

Télécharger

Nous étudierons à la fin de cette série d’articles différentes possibilités pour améliorer la détection des trains.

Maintenant que nous savons détecter l’approche d’un train, il ne reste plus qu’à rajouter les autres actions à faire pour reproduire le comportement d’un passage à niveau automatique, comme par exemple ouvrir ou fermer les barrières en conséquence. Mais n’allons pas trop vite et continuons à travailler par étapes successives. Dans le prochain article, nous nous occuperons de faire clignoter les feux du PN.

[1La locomotive a parcouru 100 fois le tour du réseau TIB sans aucune erreur de lecture d’ILS.

3 Messages

Réagissez à « Passage à niveau géré par Arduino (1) »

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 « Programmation »

Comment gérer le temps dans un programme ?

La programmation, qu’est ce que c’est

Types, constantes et variables

Installation de l’IDE Arduino

Répéter des instructions : les boucles

Les interruptions (1)

Instructions conditionnelles : le if … else

Instructions conditionnelles : le switch … case

Comment concevoir rationnellement votre système

Comment gérer l’aléatoire ?

Calculer avec l’Arduino (1)

Calculer avec l’Arduino (2)

La compilation d’un projet Arduino

Les structures

Systèmes de numération

Les fonctions

Trois façons de déclarer des constantes

Transcription d’un programme simple en programmation objet

Ces tableaux qui peuvent nous simplifier le développement Arduino

Les chaînes de caractères

Trucs, astuces et choses à ne pas faire !

Processing pour nos trains

Arduino : toute première fois !

Démarrer en Processing (1)

TCOs en Processing

TCOs en Processing (2)

Comment réussir son projet Arduino

Le monde des objets (1)

Le monde des objets (2)

Le monde des objets (3)

Le monde des objets (4)

Les pointeurs (1)

Les pointeurs (2)

Les Timers (I)

Les Timers (II)

Les Timers (III)

Les Timers (IV)

Les Timers (V)

Bien utiliser l’IDE d’Arduino (1)

Bien utiliser l’IDE d’Arduino (2)

Piloter son Arduino avec son navigateur web et Node.js (1)

Piloter son Arduino avec son navigateur web et Node.js (2)

Piloter son Arduino avec son navigateur web et Node.js (3)

Piloter son Arduino avec son navigateur web et Node.js (4)

Les derniers articles

Passage à niveau géré par Arduino (5)


Christian

Passage à niveau géré par Arduino (4)


Christian

Passage à niveau géré par Arduino (3)


Christian

Passage à niveau géré par Arduino (2)


Christian

Passage à niveau géré par Arduino (1)


Christian

La compilation d’un projet Arduino


Thierry

TCOs en Processing (2)


Pierre59

Comment concevoir rationnellement votre système


Jean-Luc

Comment réussir son projet Arduino


Christian

Piloter son Arduino avec son navigateur web et Node.js (4)


bobyAndCo

Les articles les plus lus

Les Timers (I)

Les interruptions (1)

Instructions conditionnelles : le if … else

Ces tableaux qui peuvent nous simplifier le développement Arduino

La compilation d’un projet Arduino

Calculer avec l’Arduino (1)

Répéter des instructions : les boucles

Les Timers (III)

Comment gérer le temps dans un programme ?

Les Timers (II)