Partie N°0: graphes d’état / système séquentiel
Pré-requis :
Connaissance des structures algorithmiques de l'informatique
Méthode, principes et caractéristiques de la programmation informatique (Arduino)
Compétences visées :
Comprendre et mettre en œuvre des programmes « séquentiels » à l’aide de la méthode des graphes d’état
Plan du chapitre:
- Partie N°1 : présentation
- Partie N°2 : on résume
- Partie N°3 : un exemple détaillé
- Partie N°4 : exercices
- Partie N°5 : la représentation dans SysMl
- Partie N°6 : exercices
Partie N°1 : présentation
Dans un certain nombre de cas, le système (produit, application, prototype, …) que nous devons concevoir va reposer sur une structure séquentielle (on fait une chose puis une autre puis une autre ….) à l’image d’une recette de cuisine que l’on réalise étape par étape.
Nous allons voir une méthode (la méthode du graphe d’états) qui permet de réaliser le programme associé.
Exemple simple pour bien comprendre : perceuse automatisée
fonctionnement de la perceuse:
après appui sur le B.P. DCY (bouton poussoir « départ cycle »), la perceuse se met en marche (P) et en même temps elle descend (D) jusqu’au capteur « bas ». Ensuite elle remonte (M) jusqu’au capteur « haut » et s’arrête. Le cycle est alors prêt à recommencer.
Programmer ce genre d’automatisme en langage informatique n’est pas « naturel » ou évident.
On va donc d’abord créer un graphe d’état qui va nous permettre de structurer notre programme. Ensuite on pourra passer à la programmation !
On peut voir que notre système possède 3 entrées et 3 sorties :
On peut remarquer que notre programme aura 3 périodes « stables », que l’on va appeler « états » :
- arrêt : on attend un appui sur DCY
- descente : la perceuse descend alors que le forêt est en rotation et ce jusqu’au capteur « bas »
- montée : la perceuse monte (forêt toujours en rotation) jusqu’au capteur « haut »
On va pouvoir dessiner notre graphe d’état comme cela (ordre des sorties : P M D):
Comment programmer cela en C++ (Arduino) ?
Rappels des instructions Arduino vues en TP :
- ………………………………………..
- ………………………………………..
- ………………………………………..
- ………………………………………..
- ………………………………………..
- ………………………………………..
Logiquement on aurait envie d’utiliser des IF ou des WHILE:
digitalWrite(P_pin,LOW) ;
digitalWrite(M_pin,LOW) ;
digitalWrite(D_pin,LOW) ;
While ( !dcy)
{
dcy=digitalRead(DCY_pin) ;
}
digitalWrite(P_pin,HIGH) ;
digitalWrite(M_pin,LOW) ;
digitalWrite(D_pin,HIGH) ;
While ( !bas)
{
bas=digitalRead(BAS_pin) ;
}
…
…
...
Énorme inconvénient (en fait totalement inacceptable): le programme reste bloqué à certains moment, pendant les boucles WHILE et ne fait rien d’autre ! Cela limite beaucoup l’intérêt de ce genre de structures !
La solution s’appelle : Switch - case
Petit rappel sur une instruction Arduino : Switch - case
La construction "switch – case" permet d'écrire des programmes faciles à écrire et plus lisibles
Le principe est de faire certaines choses selon l'état d'une variable, et cela remplace une série de if consécutifs avec l'avantage d'une mise en évidence des cas possibles.
Les cas possibles sont numérotés, le numéro du cas intéressant est stocké dans une variable.
Exemple (programme incomplet):
int toto; //la variable
switch toto {
case 5:
// la variable toto a la valeur 5
. . . instructions à exécuter;
break;
case 2:
. . .
default:
}
On remarque que la syntaxe est particulière. Tous les cas sont dans une même accolade et chaque cas est terminé par le cas suivant. L'instruction « break » fait sortir du switch.
Cela revient à :
loop()
{
dcy=digitalRead(DCY_pin) ;
bas=digitalRead(BAS_pin) ;
haut=digitalRead(HAUT_pin) ;
switch etat {
case arret:
digitalWrite(P_pin,LOW) ;
digitalWrite(M_pin,LOW) ;
digitalWrite(D_pin,LOW) ;
if (dcy==1) etat=descente ;
break;
case descente:
digitalWrite(P_pin,HIGH) ;
digitalWrite(M_pin,LOW) ;
digitalWrite(D_pin,HIGH) ;
if (bas==1) etat=montee;
break;
case montee:
digitalWrite(P_pin,HIGH) ;
digitalWrite(M_pin,LOW) ;
digitalWrite(D_pin,HIGH) ;
if (haut==1) etat=arret;
break;
} // fin du switch
} // fin du loop
Démarche à mettre en œuvre :
- on établit une liste des entrées et des sorties (capteurs/actionneurs)
- on définit les différents états (ou étapes) du système
- pour chaque état on note les valeurs des sorties
- on liste les transitions entre chaque état
- on définit les conditions logiques associées à ces transitions
- on trace le graphe
La partie graphique :
- Un fois le graphe d’état établi il ne reste plus qu’à écrire le programme en suivant les informations du graphe d’état :
on définit les états (utilisation préconisée de « enum » en C++) - on y associe les valeurs des sorties
- on écrit les transitions
- on teste !!!!!!!!!!!!
Partie N°3 : un exemple détaillé
Prototype de monte-charge (2 arrêts) réalisé avec une carte Arduino.
La cabine du monte charge est déplacée par un moteur relié à un circuit électrique (contacteurs, protections, ..) qui permet la montée et la descente (on notera les commandes : Monte et Descend). Deux capteurs de fin de course Haut et Bas détectent les positions des étages (contacts TOR).
Deux poussoirs AppelHaut et AppelBas permettent de faire monter et descendre la cabine.
Voici une proposition de marche à suivre pour faciliter le dessin du graphe d'état :
• établissez la liste des entrées puis des sorties
• définissez des états pour le système
• notez les valeurs de sortie pour chaque état
• repérez les transitions entre les états
• notez les conditions associées à ces transitions.
Une fois le graphe d'état établi, il ne restera plus qu’à écrire le programme en suivant le graphe d'état :
Réponses :
Le système a 4 entrées :
• ……………………..
• ……………………
• ……………………
• ……………………
Il a 2 sorties :
• ………………………………………………………………
• ………………………………………………………………
Il y a 3 états :
• ……………………………………………………………
• ……………………
• ……………………
Remarque : on notera les deux valeur correspondantes à Monte et Descend dans chaque état.
Voici un graphe d'état possible :
Remarque: on va utiliser la fonction enum (énumération) du langage C++ afin de rentre le programme plus lisible
L'instruction enum en programmation Arduino permet de créer un groupe de constantes entières personnalisées et lisibles pour simplifier le code
Une énumération se déclare avec le mot-clé enum suivi d'une liste de noms entre accolades. Par défaut, le premier élément vaut 0, le deuxième 1, et ainsi de suite (mais ces numéros ne nous intéressent pas car on va justement uiliser les noms associés à ces numéros).
Le programme Arduino :
// Dans le programme, les états sont identifiés par un enum et mémorisés dans une variable d'état :
// définition des broches liées au câblage
#define Monte_pin 1
#define Descend_pin 2
#define AppelHaut_pin 3
#define AppelBas_pin 4
#define Haut_pin 5
#define Bas_pin 6
enum {Repos, Montee, Descente};
int Etat;
boolean AppelHaut, AppelBas, Haut, Bas;
void setup()
{
pinMode(Monte_pin, ……………);
pinMode(Descend_pin, ……………);
pinMode(AppelHaut_pin, ……………);
pinMode(AppelBas_pin, ……………);
pinMode(Haut_pin, ……………);
pinMode(Bas_pin, ……………);
Etat=Repos;
}
void loop () {
// lecture des entrées
AppelHaut= digitalRead(AppelHaut_pin);
AppelBas= digitalRead(AppelBas_pin);
Haut= digitalRead(Haut_pin);
Bas= digitalRead(Bas_pin);
// gestion des états
switch (Etat) {
case Repos :
………………………………………
………………………………………
……………………………………………………
……………………………………………………
break;
case Montee :
………………………………………
………………………………………
break;
case Descente :
………………………………………
………………………………………
break;
}
}
Petit résumé en une image:
Petit résumé en vidéo: (le lien: ici)
Exercice N°1 : déplacement d’un chariot
Fonctionnement : si l'on appuie sur le bouton poussoir M lorsque le chariot est au repos en A. ce dernier quitte A, arrive en B et revient en A où il s'arrête. La position A est l’état initial du système.
1. Donnez toutes les étapes permettant de réaliser ce graphe.
2. Dessinez le graphe d’état du système.
3. Proposez une version de programme (langage Arduino)
Exercice N°2 : réaliser le graphe d’états du système consistant en deux ampoules et un bouton.
Fonctionnement : quand les deux ampoules sont éteintes, une première pression sur le bouton allume la première ampoule : une deuxième pression sur le bouton allume la deuxième ampoule tout en éteignant la première ; une troisième pression sur le bouton permet d’avoir les deux ampoules allumées en même temps : et une quatrième pression sur le bouton éteint les ampoules. Si on presse de nouveau sur le bouton, le cycle reprend.
Exercice N°3 – graphe d’état de la cafetière programmable (voir TP)
1. Proposez un graphe d’état pour le fonctionnement de la cafetière programmable réalisée en TP (https://sti2d.ecolelamache.org/prototype_de_cafetire_20.html). On ne s’occupera pas des sorties (chauffage de l’eau, écran, ...) mais juste de la structure du graphe.
Principe de fonctionnement :
Fonctionnement manuel : lorsque l’utilisateur ou l’utilisatrice appuie sur le bouton poussoir MA_AT, la cafetière se met en marche (elle fait du café). Un nouvel appui sur ce même bouton arrête la cafetière.
Mode réglage : quand on appuie sur le bouton poussoir REG, on entre dans le mode « réglage des heures». Avec les touches BP+ et BP-, on augmente ou on diminue les heures. Un nouvel appui sur REG nous emmène dans le mode « réglage des minutes » que l’on ajuste toujours avec BP+ et BP-. Un dernier appui sur REG remet la cafetière dans son monde d’attente (arrêt).
Fonctionnement automatique : un appui sur le bouton PROG met la cafetière en mode automatique. Quand l’heure réglée correspond à l’heure en cours, la cafetière se met en route (elle s’arrêtera par un appui sur le bouton MA_AT). Si, en attente de l’heure, l’utilisateur ou l’utilisatrice appuie sur MA_AT, la cafetière sort du mode automatique.
Faire le graphe d’état (il sera utilisé ensuite pour votre TP).
Exercice N°4 – graphe d’état
Un wagon réalise le cycle indiqué dans l’image ci-après. A chaque arrêt, le wagon attend 20 secondes.
Réalisez le graphe d’état de cet automatisme (mettre en évidence toutes les étapes de la réalisation).
Exercice N°5 – graphe d’état
1. Réalisez le graphe d’état de cet automatisme (mettre en évidence toutes les étapes de la réalisation).
2. Proposez une version du programme adaptée à Arduino
Partie N°5 : la représentation dans SysMl
Il existe aussi un équivalent des graphes d’état dans la norme SysMl. Il y en a même 2 !
1er diagramme : State Machine diagram
il représente les différents états que peut prendre un élément ou une opération ainsi que ses réactions aux évènements extérieurs. Il ressemble beaucoup dans le principe au diagramme d’état vu précédement.
Le diagramme d'état sysMl se compose
• d'états
• de transitions
• d'évènements
• de conditions
• d'effets
• d'activités
Un état (state) représente une situation d'un bloc fonctionnel pendant laquelle :
• il satisfait une certaine condition
• il exécute une certaine activité
Quelques éléments graphiques utilisés :
cadre du diagramme SysMl (on dessine le diagramme dedans) :
Voici le diagramme d’état de la gestion d’une lampe commandée par un B.P.:
Exemple d’un diagramme pour un distributeur de boisson :
2ème diagramme :Sequence diagram (diagramme de séquence)
le diagramme de séquence modélise la chronologie des interactions entre les éléments du système ou entre le système et l'extérieur.
La progression temporelle est verticale et les éléments sont représentés horizontalement.
Les éléments sont les entités qui sont en mesure de délivrer des messages. Un utilisateur peut donc figurer dans le diagramme de séquence.
Un diagramme simple peut se limiter aux lignes de vie et aux messages, mais souvent il faudra faire appel aux fragments combinés qui permettent d'affiner la représentation.
Lignes de vie :
Comme cela a déjà été annoncé, la ligne de vie décrit une entité du système. La progression chronologique se fait du haut vers le bas. Lorsque l'entité s'active, le trait en pointillé est remplacé par un trait large. Lorsqu'un système n'est plus en fonction toutes les entités sont désactivées.
Messages :
Ce sont des éléments de communication unidirectionnel entre les lignes de vie qui déclenchent une activité dans le destinataire. La réception d’un message provoque un événement chez le récepteur.
La flèche pointillée représente un retour. Cela signifie que le message en question est le résultat direct du message précédent
Exemple : une balance de marché
Exercice N°7 – Diagramme SysMl d'un parking (barrière)
Nous allons construire un diagramme d’états SysMl pour la barrière de parking selon les règles suivantes :
• la barrière est initialement Fermée
• lorsque l’événement Note payée se produit, un comportement Ouvrir la barrière est appelé, et la barrière est alors supposée Ouverte
• lorsque l’événement Franchissement se produit, un comportement Fermer la barrière est appelé, et la barrière est alors supposée Fermée.
Complétez le diagramme d’état :
Exercice N°8 – Diagramme SysMl d'un feu tricolore
Faire le diagramme d’état SysMl d’un feu tricolore (le vert dure 50 secondes, le orange 10 secondes et le rouge 40).
Exercice N°9 – Diagramme SysMl d'un système de lavage de voitures
On va s’occuper d’un système automatique de lavage de voiture. Le système lave la voiture, la sèche et la lustre.
Nous allons réaliser (ou plutôt compléter) le diagramme d’état SysMl de cet automatisme de lavage de voiture.
1. Compléter (indiquez) le « début de scénario » et les 2 « fin de scénario » (fin de l’automatisme) sur le diagramme fourni
2. Complétez les 3 étapes de l’automatisme
3. Que se passe-t-il en cas d’arrêt d’urgence ?
