Le cahier des charges
Le passage à niveau doit protéger une double voie, dont l’une des branches est en "Y". Il y a donc 5 sections de voies de part et d’autre du passage à niveau.
Sur chaque branche, sont disposés 2 détecteurs de type interrupteur à lame souple, "ILS".
Il y en a donc 10 au total.
Le plus proche du passage à niveau doit déclencher la fermeture des barrières lorsque le train va vers le passage.
Le plus éloigné du passage à niveau doit déclencher l’ouverture des barrières lorsque le train s’éloigne du passage. Attention toutefois, les barrières ne doivent pas s’ouvrir tant qu’il reste un autre train dans la zone comprise entre tous les détecteurs éloignés.
Tant que les barrières ne sont pas complètement ouvertes, les feux rouges de chaque coté, sur la route doivent clignoter. Comme dans la réalité, ce sont des lampes à incandescence qui s’allume et s’éteignent avec une certaine inertie, on reproduira cette inertie sur des Leds rouges, gräce aux commandes analogiques.
Enfin, l’ouverture et la fermeture des barrières est opéré par un moteur Fulgurex livré avec le passage à niveau. Ce moteur devra donc être alimenté dans un sens ou dans l’autre pendant 4 à 5 secondes environ. Les feux restent donc en service pendant cette manoeuvre.
Le matériel nécessaire
Compte tenu de ce cahier des charges, un Arduino Mini suffira. L’absence de port USB est compensée par le fait que je dispose d’interface "Bob" d’Elektor qui se raccordent facilement sur le Mini dont les pins sont sur un des petits cotés. On trouve également sur le web des interfaces USB-serie pour presque rien. Dernièrement j’ai même trouvé un Arduino Mini avec l’interface USB-série séparée, le tout pour 6€ environ (avec le chip original FT232 de FTDI).
Attention : il faut bien relier la sortie TxD de l’interface USB avec l’entrée RxD du Mini, ainsi que la sortie TxD du Mini avec l’entrée RxD de l’interface USB. Ensuite on relie le Vcc au Vcc, le Gnd au Gnd et la sortie DTR de l’interface USB à la patte marquée GRN sur le Mini (c’est ce qui permet à l’IDE Arduino de passer le Mini en mode programmation).
- Arduino Pro-Mini
Les ILS sont raccordés directement sur 10 pins de l’Arduino, les communs des ILS étant regroupés sur le 0V.
Les feux sont réalisés avec 2 Leds rouges en série, sur une pin analogique (à sortie en PWM) du Mini.
Les commandes du moteur sont faites avec une carte à 2 relais qui se pilote par 2 sorties du Mini. J’ai choisi 2 pins analogiques, utilisées en digital.
- Une extension à 2 relais unipolaires
Pour alimenter l’Arduino, les Leds et les relais, j’ai réalisé une petite alimentation régulée par un 7805, avec un pont de diode et quelques condensateurs. J’ai préféré cela au régulateur embarqué dans le Mini, qui me semble un peu sous-dimensionné pour alimenter les relais et les Leds.
Au total, on peut s’en sortir avec 10€ de matériel, sans les ILS ni le passage à niveau.
Le schéma
Sur ce schéma, la carte à 2 relais est représentée par seulement 2 relais, n’ayant pas le dessin de l’élément acheté qui se raccorde par 4 contacts : relai 1, relai 2, 5V et 0V.
- Schéma du Passage à Niveau
La source d’alimentation est prise sur celle du moteur Fulgurex. Comme sa tension peut être comprise entre 8 et 15 volts, le régulateur externe 7805 tiendra bien le choc (la tension maximum est de 40V au lieu de 12V pour un Arduino Mini).
La réalisation
Une planchette en bois sert de support direct aux composants. Elle permet un étiquetage clair des connexions.
- Les ingrédients sur une planchette
Petite anecdote : Lors d’un essai précédent, avant l’ajout de la petite alimentation 5V, j’avais utilisé le régulateur intégré de l’Arduino Mini. Résultat d’une erreur : le régulateur intégré est parti en fumée. Mais tout le reste de l’Arduino est intact : quel chance, mais aussi quelle robustesse ! C’est pour cela qu’on peut voir une zone noircie sur le Mini. Depuis, j’ai refait le montage avec un Mini tout neuf.
Les dominos ordinaires aurait pu être avantageusement remplacés par cette superbe plaque à borniers.
Le programme
C’est la partie la plus intéressante du projet !
Je précise tout de suite que ce n’est pas le meilleur programme possible : il ne couvre pas tous les cas possibles. Ca se coince parfois lors de manoeuvres spéciales.
Mais c’est un programme convenable pour les cas ordinaires et assez simple à comprendre pour les débutants.
Nous verrons plus loin que cet article aura une suite, justement pour explorer un peu plus cet automate qui n’est pas si trivial que ça en a l’air.
On commence donc par la déclaration des ports d’entrée et sortie :
// Pins utilisées pour les connexions aux detecteurs Reed
#define ReedA1 2 //RA1 = O1-29G
#define ReedB1 3 //RB1 = F1-29G
#define ReedC1 4 //RB2 = F1-29D
#define ReedD1 5 //RD2 = O1-29D
#define ReedA2 6 //RA2 = O2-30G
#define ReedB2 7 //RB2 = F2-30G
#define ReedC2 8 //RC2 = F2-3031D
#define ReedD2 9 //RD2 = O2-3031D
#define ReedA3 A2 //RA3 = O2-31G
#define ReedB3 A3 //RB3 = F2-31G
// Pins utilisées pour la Led et le PAN
#define LED 13 // on board
#define Feux 11 // PWM ou digital OUT
#define PANPWM 12 // not used
#define PAN1 A0 //digital OUT IN2 relai
#define PAN2 A1 //digital OUT IN1 relai
#define PANMOVE 5000 // duree d'activation du moteur Fulgurex
Puis, pour éviter tout problème de contact au niveau des ILS, on utilise intensivement la bibliothèque Bounce.
#include <Bounce2.h> // librairie de gestion des contacts Reed
// Instantie 8 objets Bounce avec une durée de 10 millisecond de debounce
Bounce bounceA1 = Bounce();
Bounce bounceB1 = Bounce();
Bounce bounceC1 = Bounce();
Bounce bounceD1 = Bounce();
Bounce bounceA2 = Bounce();
Bounce bounceB2 = Bounce();
Bounce bounceC2 = Bounce();
Bounce bounceD2 = Bounce();
Bounce bounceA3 = Bounce();
Bounce bounceB3 = Bounce();
Petit programme, donc peu de variables :
// Variables
boolean RA1, RA2, RB1, RB2, RC1, RC2, RD1, RD2, RA3, RB3 = false;
int etat1, etat2 = 0; // libre
boolean dir1, dir2 = false;
boolean etat_PAN = true; // true=ouvert, false=fermé
unsigned long TimerFeux, TimerPAN;
int fadeValue; // valeur variable de la durée du fading des feux
int fading = 10; // 10 croit/decroit ou 1000 allume/eteint
int cycle = 0; // 0 eteint, 1 croit, 2 allumé, 3 decroit
int panValue = PANMOVE; //durée impulsion ouverture et fermeture pour Fulgurex
boolean Fulgurex = false; // true seulement pour envoyer le courant au moteur
A ce stade, j’avoue que la déclaration de plusieurs variables de même type sur la même ligne avec la dernière = 0, n’entraine pas nécessairement que la première (et les autres) soient aussi = 0
Le Setup
// SETUP
void setup() {
// entrées
// sorties
//définition des objets bounce
bounceA1.attach(ReedA1);
bounceB1.attach(ReedB1);
bounceC1.attach(ReedC1);
bounceD1.attach(ReedD1);
bounceA2.attach(ReedA2);
bounceB2.attach(ReedB2);
bounceC2.attach(ReedC2);
bounceD2.attach(ReedD2);
bounceA3.attach(ReedA3);
bounceB3.attach(ReedB3);
bounceA1.interval(50);
bounceB1.interval(50);
bounceC1.interval(50);
bounceD1.interval(50);
bounceA2.interval(50);
bounceB2.interval(50);
bounceC2.interval(50);
bounceD2.interval(50);
bounceA3.interval(50);
bounceB3.interval(50);
}
La boucle Loop contient 4 types d’actions :
- La détection des ILS
- La gestion de l’automate de clignotement des feux
- La gestion du moteur Fulgurex (ouverture ou fermeture) pendant le temps défini par PANMOVE
Détections des ILS
Chaque détection est faite par la bibliothèque Bounce et entraîne une action spécifique à chaque ILS.
// Update the debouncer
bounceA1.update ( );
bounceB1.update ( );
bounceC1.update ( );
bounceD1.update ( );
bounceA2.update ( );
bounceB2.update ( );
bounceC2.update ( );
bounceD2.update ( );
bounceA3.update ( );
bounceB3.update ( );
// Une transition de HIGH à LOW entraine une action (fonction)
if ( bounceA1.fell() ) {
action1();
}
if ( bounceB1.fell() ) {
action2();
}
if ( bounceC1.fell() ) {
action3();
}
if ( bounceD1.fell() ) {
action4();
}
if ( bounceA2.fell() ) {
action5();
}
if ( bounceA3.fell() ) {
action5();
}
if ( bounceB2.fell() ) {
action6();
}
if ( bounceB3.fell() ) {
action6();
}
if ( bounceC2.fell() ) {
action7();
}
if ( bounceD2.fell() ) {
action8();
}
On notera que les actions pour la branche déviée de l’"Y" sont les même que celles de la branche droite.
On verra le contenu de ces actions un peu plus loin.
L’automate des feux
Il est bien évidemment interdit d’utiliser l’instruction delay().
L’astuce consiste à détecter l’écoulement d’un laps de temps défini par la variable "fading" et à invoquer le fonction FeuxON(). C’est cette dernière qui réalise l’automate par une série d’états associés chacun à une valeur particulière de"fading", ce que nous verrons plus loin.
if ((TimerFeux
+ fading
) < millis()) {
TimerFeux = TimerFeux + fading;
if (!etat_PAN)
{
FeuxON();
}
}
Cette petite partie fait simplement avancer l’automate FeuxON() à chaque période définie par la variable fading dont la valeur change dans l’automate.
On peut obtenir ainsi un comportement sophistiqué de manière simple.
L’automate du moteur de barrière
Du même principe, il stoppe le moteur à la fin d’une tempo initialisée dans une des actions liées aux détections d’ILS.
// commande de barrière (impulsion de duree panValue)
if (Fulgurex)
{
FeuxON(); // le feu reste allume pendant la manoeuvre
if ((TimerPAN
+ panValue
) < millis()) // depassement timer {
Fulgurex = false;
if (etat_PAN)
{
FeuxOFF(); // extinction feu à la fin de l'ouverture
}
}
}
On notera que le feu rouge pour les voitures doit rester allumé pendant la manœuvre de la barrière.
Les actions en réponse aux détections ILS
L’état libre ou occupé des voies est représenté par les variables état1 et état2.
Pour tenir compte de la possibilité de la présence de plusieurs trains dans la zone, chaque entrée de train se traduit par l’incrémentation de la variable étatx.
La sortie des trains, par symétrie, se fait par décrémentation de cette variable.
Il faut qu’elle passe à zéro pour constater que la zone est libre !
void action1() // detecteur loin a gauche du PaN voie 1
{
/*- RA1 - O1-29G
-> si etat1=false, alors etat1=true, dir1=ADroite (entrée par la gauche de la voie 1, direction vers droite)
-> si etat1=true, alors etat1=false, (sortie par la gauche de la voie 1)
et -> si etat2=false (voie 2 libre), alors etat_PAN=ouvert (ouverture PAN autorisée)
*/
if (etat1 == 0) // etat libre, entrée par la gauche voie 1
{
etat1++; // voie 1 occupée
dir1=true; // vers la droite
} else { // sinon pas libre donc c'est une sortie vers la gauche
// ou une autre entree par la gauche
if (!dir1) // sortie
{
if (etat1 > 0)
{
etat1--; // voie 1 libre
}
} else { // entree
etat1++;
dir1=true;
}
if ((etat1 == 0) && (etat2 == 0)) // si voies 1 et 2 libres
{
etat_PAN=true; // ouverture si l'autre voie est libre
FeuxON();
OuvreBarriere();
}
}
}
/////////////////////
void action2() // detecteur pres à gauche du PaN voie 1
{
// RB1 - F1-29G
// -> si etat1>0 et dir1=ADroite alors etat_PAN = ferme (fermeture PAN)
if (etat1 && dir1 && etat_PAN) // vers la droite 2e détecteur à gauche du PaN
{
etat_PAN=false; // fermeture
FeuxON();
FermeBarriere();
}
}
/////////////////////
void action3() // detecteur près à droite du PaN voie 1
{
//- RC1 - F1-29D
// -> si etat1>0 et dir1=AGauche alors etat_PAN = ferme (fermeture PAN)
if (etat1 && !dir1 && etat_PAN) // vers la gauche 2e détecteur à droite du PaN
{
etat_PAN=false; // fermeture
FermeBarriere();
FeuxON();
}
}
/////////////////////
void action4() // detecteur loin a droite du PaN voie 1
{
/*- RD1 - O1-29D
-> si etat1=false, alors etat1=true, dir1=AGauche (entrée par la droite de la voie 1, direction vers gauche)
-> si etat1=true, alors etat1=false (sortie par la droite de la voie 1)
et si etat2=false (voie 2 libre), alors etat_PAN=ouvert (ouverture PAN)
*/
if (etat1 == 0) // etat libre, entrée par la droite voie 1
{
etat1++; // voie 1 occupee
dir1=false; // vers la gauche
} else { // sinon pas libre donc c'est une sortie vers la droite
// ou une nouvelle entree par le droite
if (dir1) // sortie
{
if (etat1 > 0)
{
etat1--;
}
} else { // sinon entree
etat1++;
dir1=false;
}
if ((etat1==0) && (etat2==0))
{
etat_PAN=true;
FeuxON();
OuvreBarriere();
}
}
}
/////////////////////
void action5()
{
/*- RA2 ou RA3
- O2-30G -> si etat2=false, alors etat2=true, dir2=ADroite (entrée par la gauche de la voie 2, direction vers droite)
- O2-31G -> si etat2=true alors etat2=false (sortie par la gauche de la voie 2)
et -> si etat1=false (voie 1 libre), alors etat_PAN=ouvert (ouverture PAN)
*/
if (etat2 == 0) // voie 2 libre, entree par la gauche
{
etat2++;
dir2=true;
} else { // sinon pas libre donc c'est une sortie vers la gauche
// ou nouvelle entree par la gauche
if (!dir2) // sortie
{
if (etat2 > 0)
{
etat2--;
}
} else { // sinon entree
etat2++;
dir2=true;
}
if ((etat1==0) && (etat2==0))
{
etat_PAN=true;
OuvreBarriere();
}
}
}
/////////////////////
void action6()
{
//- RB2 ou RB3 - F2-30G ou F2-31G
// -> si etat2=true et dir2=ADroite alors etat_PAN = ferme (fermeture PAN)
if (etat2 && dir2 && etat_PAN)
{
etat_PAN=false;
FeuxON();
FermeBarriere();
}
}
/////////////////////
void action7()
{
//- RC2 - F2-3031D
// -> si etat2=true et dir2=AGauche alors etat_PAN = ferme (fermeture PAN)
if (etat2 && !dir2 && etat_PAN)
{
etat_PAN=false;
FeuxON();
FermeBarriere();
}
}
/////////////////////
void action8()
{
/*- RD2
- O2-3031D
-> si etat2=0, alors etat2=true, dir2=AGauche (entrée par la droite de la voie 2, direction vers gauche)
-> si etat2=true alors etat2=false (sortie par la droite de la voie 2 et )
et -> si etat1=false (voie 1 libre), alors etat_PAN=ouvert (ouverture PAN)
*/
if (etat2 == 0) //entree par la droite, direction vers gauche
{
etat2++;
dir2=false;
} else { // sinon sortie vers la droite
// ou nouvelle entree
if (dir2)
{
if (etat2 > 0)
{
etat2--;
}
} else {
etat2++;
dir2=false;
}
if ((etat1==0) && (etat2==0))
{
etat_PAN=true;
FeuxON();
OuvreBarriere();
}
}
}
Les fonctions d’ouverture et fermeture de la barrière
Le fait de passer la variable Fulgurex à true va démarrer le décomptage du temps dans la loop.
void OuvreBarriere()
{
Fulgurex = true;
}
void FermeBarriere()
{
Fulgurex = true;
}
Le clignotement réaliste des feux
Cette partie peut être réutilisée dans beaucoup d’animations lumineuses réalistes.
On considère 4 phases dans l’allumage des feux :
- une phase de luminosité croissante pendant 1/10e de seconde
- une phase de luminosité maximum pendant 1 seconde
- une phase de luminosité décroissante pendant 1/10e de seconde
- une phase de luminosité nulle pendant 1/2 seconde
On passe d’une phase à l’autre à l’écoulement de la variable fading, initialisée à la phase précédente et testée avec le temps système dans la loop.
void FeuxON()
{
switch (cycle)
{
case 0: //éteint >> démarrage croissance
cycle = 1;
fading = 10;
fadeValue = 10;
break;
//
case 1: //croissance
fadeValue = fadeValue + 10;
if (fadeValue > 255)
{
fading = 1000;
cycle = 2;
}
break;
//
case 2: //allumé >> démarrage décroissance
cycle = 3;
fading = 10;
fadeValue = 255;
break;
//
case 3: // decroissance
fadeValue = fadeValue - 10;
if (fadeValue < 0)
{
fading = 500;
cycle = 0;
}
break;
}
}
L’extinction des feux
Le code complet
On trouvera dans le document joint le code complet du passage à niveau.
Dans ce code j’ai ajouté une fonction de DEBUG qui utilise la console de l’IDE Arduino pour afficher un message à chaque événement et l’état des principales variables.
Il y a aussi une possibilité de simuler les détections d’ILS en tapant des chiffres au clavier.
On peut faire disparaître du code l’ensemble de la fonction de DEBUG en mettant la définition au début en commentaire.
//#define DEBUG // a mettre en commentaire pour enlever les echanges avec la console
- Le sketch du Passage à Niveau (version 0.9 du 1/03/2015)
L’installation in situ a eu lieu et le montage fonctionne bien… dans presque tous les cas… sauf quelques uns ;(.
Comme toujours dans un projet, il y a quelques améliorations que je ne manquerai pas de vous donner dans un prochain article.
Mais en réalité c’est une nouvelle manière de raisonner et un nouvel automate qui vous sera présenté par Jean-Pierre très prochainement, car le passage à niveau est un cas d’école !!!
Ensuite, nous y ajouterons l’incontournable sonnerie qui accompagne toujours la fermeture de la barrière. Le tout dans notre Mini, avec un lecteur de carte SD en plus : OUI il arrive à tout faire !
Enfin, nous espérons vous proposer une nouvelle réalisation avec un circuit imprimé.
Donc ne ratez pas les prochains articles !
s’allument dès le déclenchement de l’arrivée du train