Vous savez lire un capteur de présence d’un train, quel qu’il soit, manœuvrer un actionneur pour couper une alimentation, changer la position d’une aiguille, voire même envoyer un message DCC. Vous savez donc quelles sont les entrées de votre système et quelles sont les sorties. Il reste maintenant à concevoir la logique de fonctionnement de ce système et à écrire le programme qui va gérer tout ça. On serait tenté d’y aller « à l’arrache », méthode bien connue qui aboutit généralement à une absence de résultats concluants. Il vaut donc mieux disposer de quelques outils pour bien poser le problème et le résoudre.
Comment concevoir rationnellement votre système
.
Par :
DIFFICULTÉ :★★★
Avant de se lancer dans une programmation spaghetti sans savoir exactement où l’on va, il est nécessaire de modéliser le système que l’on veut mettre en œuvre. La modélisation consiste à poser correctement le problème et d’utiliser une façon de présenter les choses, un formalisme, qui soit sûre et qui permettra d’écrire un programme au fonctionnement fiable.
Pour modéliser, nous allons utiliser les automates, formalisme bien adapté aux systèmes que nous voulons concevoir. Un automate se dessine sous forme de cercles et de flèches entre les cercles. Les cercles sont des états et les flèches des transitions. Les transitions portent des conditions de franchissement, les gardes ainsi que des actions effectuées lorsque la transition est franchie. Implicitement, si à partir d’un état aucune garde n’est vraie, le système reste dans l’état courant.
Voyons toute suite la mise en œuvre sur un cas concret.
Commande d’un passage à niveau
Le système que je propose est la commande d’un passage à niveau. Il n’est pas complètement réaliste car la volonté est de proposer un système suffisamment simple à titre d’illustration. Nous allons considérer une voie unique, qui n’est parcourue que dans un seul sens. Lorsque le train approche, un capteur unique, positionné à une certaine distance du passage à niveau, signale sa présence, les feux commencent à clignoter, les barrières, actionnées par des servomoteurs, se ferment. Lorsque le train n’est plus devant le capteur, nous n’avons aucun moyen de savoir si il a quitté le passage à niveau. Nous mettons donc en œuvre une temporisation : le passage à niveau s’ouvre au bout d’un certain temps et les feux s’arrêtent de clignoter.
Quelles sont les entrées du système ?
Le système n’a qu’une seule entrée, le capteur. Le train est présent ou absent.
Quels sont ses états, quelles sont les transitions ?
Les états du système correspondent aux différentes phases par lequel passe le passage à niveau. Nous avons :
- L’état où le passage à niveau est ouvert. Les barrières sont levées. Appelons cet état
PN_OUVERT
. Il s’agit également de l’état initial du système, noté sur la figure ci-dessous par une double ligne ; - L’état où le passage à niveau est en train de se fermer,
PN_SE_FERME
. Les barrières sont en mouvement de haut en bas. Le feu clignote ; - L’état où le passage à niveau est fermé. Le feu clignote. Appelons cet état
PN_FERME
; - L’état où le passage à niveau effectue sa temporisation avant de s’ouvrir,
PN_TEMPO
. Le feu clignote ; - Enfin, l’état ou le passage à niveau est en train de s’ouvrir. Les barrières sont en mouvement de bas en haut, le feu clignote. Appelons cet état
PN_S_OUVRE
Nous pouvons déjà commencer à dessiner notre automate. Nous avons les 5 états donnés ci-dessus et la simple logique de fonctionnement de l’appareil nous donne les transitions qui existent.
Quelles sont les gardes ?
Le passage d’un état à l’autre en suivant une transition ne se fait que lorsque qu’une condition est vraie. Pour notre passage à niveau, les conditions sont plutôt évidentes :
- Si le passage à niveau est dans l’état
PN_OUVERT
, la présence d’un train, qui vient couper le faisceau du capteur, entraine le passage dans l’étatPN_SE_FERME
. Cette condition est notée train présent ; - Si le passage à niveau est dans l’état
PN_SE_FERME
, c’est la fin du mouvement des servomoteurs qui entraine le passage dans l’étatPN_FERME
. Notons cette condition servos arrêtés ; - Si le passage à niveau est dans l’état
PN_FERME
, l’absence du train, qui cesse de couper le faisceau du capteur, provoque le passage dans l’étatPN_TEMPO
. Cette condition est notée train absent ; - Si le passage à niveau est dans l’état
PN_TEMPO
, l’écoulement du temps entraine le passage dans l’étatPN_S_OUVRE
. Notons cette condition temps écoulé ; - Enfin, à partir de l’état
PN_S_OUVRE
, c’est l’arrêt des servomoteurs qui entraine le passage dans l’étatPN_OUVERT
.
L’automate est complété avec, en rouge, les gardes que nous venons de définir.
Quelles sont les actions ?
Il nous reste à définir les actions. Pour que le passage à niveau se ferme, il faut bien que les servomoteurs se mettent en mouvement. Pour mesurer l’écoulement d’un « certain temps » il faut un minuteur. Par conséquent :
- Quand le passage à niveau passe de l’état
PN_OUVERT
à l’étatPN_SE_FERME
, il faut démarrer le clignotement du feu et mettre les servomoteurs en mouvement pour fermer les barrières ; - Lorsqu’il passe de l’état
PN_FERME
à l’étatPN_TEMPO
, la date à laquelle on ouvrira le passage à niveau est calculée ; - Lorsque le passage à niveau passe de l’état
PN_TEMPO
à l’étatPN_S_OUVRE
, les servomoteurs sont mis en mouvement pour ouvrir les barrières ; - Enfin, lors du passage de l’état
PN_S_OUVRE
à l’étatPN_OUVERT
, le clignotement des feux est stoppé.
Les actions que nous venons de définir sont ajoutées à l’automate. Nous avons terminé.
La conception est-elle correcte ?
Il s’agit d’une question que l’on devrait toujours se poser. En effet, lorsqu’on conçoit un système, la tendance naturelle est de se focaliser sur le comportement nominal. Ici nous avons implicitement supposé que, lorsqu’un train quittait la zone du capteur, un autre train ne pouvait pas se présenter avant que la barrière ne soit fermée car ni dans l’état PN_TEMPO
, ni dans l’état PN_S_OUVRE
la présence d’un train n’est testée. Le résultat est qu’un train suivant le train qui sort de la zone du capteur à un intervalle de temps inférieur à la temporisation plus le temps nécessaire pour lever la barrière verra la barrière se lever lors de son passage.
Nous devons donc compléter l’automate pour tenir compte de ces deux cas :
- Lorsque le passage à niveau est dans l’état
PN_TEMPO
, la présence d’un train provoque le passage dans l’étatPN_FERME
; - Lorsque le passage à niveau se trouve dans l’état
PN_S_OUVRE
, la présence d’un train provoque le passage dans l’étatPN_SE_FERME
et les servomoteurs sont mis en mouvement pour fermer les barrières.
L’automate est donc complété de la manière suivante.
La programmation
Maintenant que le fonctionnement du système est correctement spécifié, nous pouvons commencer à écrire le programme. Nous allons utiliser la bibliothèque SlowMotionServo pour mouvoir les barrières. Les feux clignotants seront commandés par la bibliothèque LightDimmer. Les deux sont disponibles dans le gestionnaire de bibliothèques de l’IDE Arduino. Le capteur est un capteur de présence Pololu tout ou rien qui réagit à la présence d’un objet à 5cm ou moins.
Tout d’abord, nous allons déclarer une enum
pour les états de l’automate (voir Trois façons de déclarer des constantes) :
enum { PN_OUVERT, PN_SE_FERME, PN_FERME, PN_TEMPO, PN_S_OUVRE };
Nous déclarons ensuite ce qui concerne le capteur. Il nécessite 1 broche. Si la niveau est un LOW, un objet est présent dans l’axe du capteur à moins de 5cm. Si c’est un HIGH, aucun objet n’est présent.
/* La pin du capteur et les informations renvoyées */
const byte capteurPin = 2;
const byte trainPresent = LOW;
const byte trainAbsent = HIGH;
Vient ensuite ce qui concerne les barrières du passage à niveau.
/* Les pins des servos */
const byte barriere1Pin = 4;
const byte barriere2Pin = 5;
/* Les positions cibles des barrières */
const float positionOuverteBarriere1 = 0.0;
const float positionFermeeBarriere1 = 1.0;
const float positionOuverteBarriere2 = 1.0;
const float positionFermeeBarriere2 = 0.0;
/* Les servos */
SMSSmooth barriere1;
SMSSmooth barriere2;
/* La temporisation entre la fin du train et l'ouverture des barrières
en ms
*/
const unsigned long temporisationOuverture = 5000;
Le feu clignotant est géré au moyen de la bibliothèque LightDimmer qui permet un clignotement simulant l’inertie des ampoules à filament.
/* Le feu clignotant */
const byte feu1Pin = 6;
const byte feu2Pin = 7;
/* Deux LightDimmerSoft pour chaque feu */
LightDimmerSoft clignotantFeu1;
LightDimmerSoft clignotantFeu2;
Dans setup()
, on met en place les clignotants et les servos. Notez que dans cet exemple, les positions effectives des servos pour que les barrières soient fermées ou ouvertes ne sont pas précisées, on reste sur les valeurs par défaut de SlowMotionServo. Si vous réutilisez ce programme pour votre passage à niveau, il faudra se préoccuper de régler ces valeurs.
void setup()
{
/* capteur de présence */
pinMode(capteurPin, INPUT);
/* les clignotants */
clignotantFeu1.begin(feu1Pin, HIGH);
clignotantFeu2.begin(feu2Pin, HIGH);
/* les barrières */
barriere1.setPin(barriere1Pin);
barriere1.setSpeed(2.0);
barriere1.setInitialPosition(0.1);
barriere1.goTo(positionOuverteBarriere1);
barriere2.setPin(barriere2Pin);
barriere2.setSpeed(2.0);
barriere2.setInitialPosition(0.1);
barriere2.goTo(positionOuverteBarriere2);
}
Dans loop()
nous allons faire fonctionner notre automate. Tout d’abord, il nous faut une variable pour mémoriser l’état actuel. Comme nous avons 5 états, un byte
suffira, voir à ce propos « Types, constantes et variables ». Cette variable est initialisée avec l’état initial de notre automate.
byte etatPN = PN_OUVERT;
Ensuite, il nous faut une façon claire et efficace d’exprimer ce que fait l’automate. Nous allons utiliser un switch ... case
, structure de contrôle présentée dans « Instructions conditionnelles : le switch ... case » avec tout naturellement un case
par état. Dans chacun de ces case
la garde de chaque transition sortante est testée et, si elle est vraie, l’action est effectuée et l’état est changé.
L’état PN_OUVERT
La condition de franchissement de la transition vers PN_SE_FERME
est la présence du train. Avec le capteur employé elle s’exprime par une comparaison entre ce que retourne le capteur et la constante préalablement définie.
case PN_OUVERT:
/* lecture du capteur pour détecter un train */
if (digitalRead(capteurPin) == trainPresent) {
/* train présent */
/* On ferme les barrière */
barriere1.goTo(positionFermeeBarriere1);
barriere2.goTo(positionFermeeBarriere2);
/* On démarre le clignotement */
clignotantFeu1.startBlink();
clignotantFeu2.startBlink();
/* Le PN est en train de se fermer */
etatPN = PN_SE_FERME;
}
break;
L’état PN_SE_FERME
case PN_SE_FERME:
/* Si les deux servos sont arrêtés, le PN a terminé de se fermer */
if (barriere1.isStopped() && barriere2.isStopped()) {
etatPN = PN_FERME;
}
break;
L’état PN_FERME
case PN_FERME:
/* lecture du capteur pour détecter le départ du train */
if (digitalRead(capteurPin) == trainAbsent) {
dateOuverture = millis() + temporisationOuverture;
etatPN = PN_TEMPO;
}
break;
L’état PN_TEMPO
Une question se pose lorsque plusieurs transitions sortent d’un état et que plusieurs gardes sont vraies simultanément comme c’est le cas ici. En effet, il faut que l’automate soit déterministe (ou plutôt « déterminisé ») quand on l’écrit sous forme de programme. Dans notre cas, on décide assez logiquement que si simultanément le train est présent et la date d’ouverture est arrivée, c’est la présence du train qui est prioritaire. Cette priorité est tout simplement implémentée via une cascade de if ... then ... else
et les conditions sont simplement testées de la plus prioritaire à la moins prioritaire.
case PN_TEMPO:
/* Un train est présent, on retourne à l'état PN_FERME */
if (digitalRead(capteurPin) == trainPresent) {
etatPN = PN_FERME;
}
else {
/* Si la date est arrivée, on ouvre */
if (millis() >= dateOuverture) {
/* On ouvre les barrière */
barriere1.goTo(positionOuverteBarriere1);
barriere2.goTo(positionOuverteBarriere2);
etatPN = PN_S_OUVRE;
}
}
break;
L’état PN_S_OUVRE
case PN_S_OUVRE:
/* Un train est présent, on retourne à l'état PN_SE_FERME et on ferme la barrière */
if (digitalRead(capteurPin) == trainPresent) {
barriere1.goTo(positionFermeeBarriere1);
barriere2.goTo(positionFermeeBarriere2);
etatPN = PN_SE_FERME;
}
else {
/* Si les deux servos sont arrêtés, le PN a terminé de s'ouvrir */
if (barriere1.isStopped() && barriere2.isStopped()) {
/* stoppe le feu */
clignotantFeu1.off();
clignotantFeu2.off();
etatPN = PN_OUVERT;
}
}
break;
Le sketch complet
Voici le résultat.
Le sketch complet est téléchargeable ci-dessous. Pour la petit histoire, lors du développement de cet exemple, le système a fonctionné au premier essai de manière satisfaisante.
En spécifiant correctement, de manière précise et rigoureuse vos systèmes ferroviaires, en utilisant des représentations adaptées alors que le langage naturel ne suffit pas, on met toutes les chances de son côté pour une réalisation couronnée de succès. J’espère vous avoir montré cette manière de faire dans cet article.