LOCODUINO

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

vendredi 19 octobre 2018

15 visiteurs en ce moment

Comment concevoir rationnellement votre système

. Par : Jean-Luc

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.

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.

Enchainement des états du passage à niveau.

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’état PN_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’état PN_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’état PN_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’état PN_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’état PN_OUVERT.

L’automate est complété avec, en rouge, les gardes que nous venons de définir.

PNG - 96.8 ko

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’état PN_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’état PN_TEMPO, la date à laquelle on ouvrira le passage à niveau est calculée ;
  • Lorsque le passage à niveau passe de l’état PN_TEMPO à l’état PN_S_OUVRE, les servomoteurs sont mis en mouvement pour ouvrir les barrières ;
  • Enfin, lors du passage de l’état PN_S_OUVRE à l’état PN_OUVERT, le clignotement des feux est stoppé.

Les actions que nous venons de définir sont ajoutées à l’automate. Nous avons terminé.

PNG - 126 ko

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’état PN_FERME ;
  • Lorsque le passage à niveau se trouve dans l’état PN_S_OUVRE, la présence d’un train provoque le passage dans l’état PN_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.

PNG - 151.7 ko

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) :

  1. 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.

  1. /* La pin du capteur et les informations renvoyées */
  2. const byte capteurPin = 2;
  3. const byte trainPresent = LOW;
  4. const byte trainAbsent = HIGH;

Vient ensuite ce qui concerne les barrières du passage à niveau.

  1. /* Les pins des servos */
  2. const byte barriere1Pin = 4;
  3. const byte barriere2Pin = 5;
  4.  
  5. /* Les positions cibles des barrières */
  6. const float positionOuverteBarriere1 = 0.0;
  7. const float positionFermeeBarriere1 = 1.0;
  8. const float positionOuverteBarriere2 = 1.0;
  9. const float positionFermeeBarriere2 = 0.0;
  10.  
  11. /* Les servos */
  12. SMSSmooth barriere1;
  13. SMSSmooth barriere2;
  14.  
  15. /* La temporisation entre la fin du train et l'ouverture des barrières
  16.   en ms
  17. */
  18. 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.

  1. /* Le feu clignotant */
  2. const byte feu1Pin = 6;
  3. const byte feu2Pin = 7;
  4.  
  5. /* Deux LightDimmerSoft pour chaque feu */
  6. LightDimmerSoft clignotantFeu1;
  7. 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.

  1. void setup()
  2. {
  3. /* capteur de présence */
  4. pinMode(capteurPin, INPUT);
  5. /* les clignotants */
  6. clignotantFeu1.begin(feu1Pin, HIGH);
  7. clignotantFeu2.begin(feu2Pin, HIGH);
  8. /* les barrières */
  9. barriere1.setPin(barriere1Pin);
  10. barriere1.setSpeed(2.0);
  11. barriere1.setInitialPosition(0.1);
  12. barriere1.goTo(positionOuverteBarriere1);
  13. barriere2.setPin(barriere2Pin);
  14. barriere2.setSpeed(2.0);
  15. barriere2.setInitialPosition(0.1);
  16. barriere2.goTo(positionOuverteBarriere2);
  17. }

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.

  1. 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.

  1. case PN_OUVERT:
  2. /* lecture du capteur pour détecter un train */
  3. if (digitalRead(capteurPin) == trainPresent) {
  4. /* train présent */
  5. /* On ferme les barrière */
  6. barriere1.goTo(positionFermeeBarriere1);
  7. barriere2.goTo(positionFermeeBarriere2);
  8. /* On démarre le clignotement */
  9. clignotantFeu1.startBlink();
  10. clignotantFeu2.startBlink();
  11. /* Le PN est en train de se fermer */
  12. etatPN = PN_SE_FERME;
  13. }
  14. break;

L’état PN_SE_FERME

  1. case PN_SE_FERME:
  2. /* Si les deux servos sont arrêtés, le PN a terminé de se fermer */
  3. if (barriere1.isStopped() && barriere2.isStopped()) {
  4. etatPN = PN_FERME;
  5. }
  6. break;

L’état PN_FERME

  1. case PN_FERME:
  2. /* lecture du capteur pour détecter le départ du train */
  3. if (digitalRead(capteurPin) == trainAbsent) {
  4. dateOuverture = millis() + temporisationOuverture;
  5. etatPN = PN_TEMPO;
  6. }
  7. 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.

  1. case PN_TEMPO:
  2. /* Un train est présent, on retourne à l'état PN_FERME */
  3. if (digitalRead(capteurPin) == trainPresent) {
  4. etatPN = PN_FERME;
  5. }
  6. else {
  7. /* Si la date est arrivée, on ouvre */
  8. if (millis() >= dateOuverture) {
  9. /* On ouvre les barrière */
  10. barriere1.goTo(positionOuverteBarriere1);
  11. barriere2.goTo(positionOuverteBarriere2);
  12. etatPN = PN_S_OUVRE;
  13. }
  14. }
  15. break;

L’état PN_S_OUVRE

  1. case PN_S_OUVRE:
  2. /* Un train est présent, on retourne à l'état PN_SE_FERME et on ferme la barrière */
  3. if (digitalRead(capteurPin) == trainPresent) {
  4. barriere1.goTo(positionFermeeBarriere1);
  5. barriere2.goTo(positionFermeeBarriere2);
  6. etatPN = PN_SE_FERME;
  7. }
  8. else {
  9. /* Si les deux servos sont arrêtés, le PN a terminé de s'ouvrir */
  10. if (barriere1.isStopped() && barriere2.isStopped()) {
  11. /* stoppe le feu */
  12. clignotantFeu1.off();
  13. clignotantFeu2.off();
  14. etatPN = PN_OUVERT;
  15. }
  16. }
  17. break;

Le sketch complet

Voici le résultat.

https://www.youtube.com/watch?v=QQQoqmtMFBM

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.

Sketch de passage à niveau
Mise en œuvre de l’automate.

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.

18 Messages

Réagissez à « Comment concevoir rationnellement votre système »

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)

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

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

TCOs en Processing


Pierre59

Ces tableaux qui peuvent nous simplifier le développement Arduino


bobyAndCo

Processing pour nos trains


Pierre59

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


bobyAndCo

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


bobyAndCo

Démarrer en Processing (1)


DDEFF

Les articles les plus lus

Les interruptions (1)

Les Timers (I)

Comment gérer le temps dans un programme ?

Bien utiliser l’IDE d’Arduino (1)

Les chaînes de caractères

Calculer avec l’Arduino (1)

Ces tableaux qui peuvent nous simplifier le développement Arduino

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

Le monde des objets (1)

TCOs en Processing (2)