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 : un exemple détaillé
• Partie N°3 : exercices de construction de graphes d'état
• Partie N°4 : transcription en langage Arduino
• Partie N°5 : suite de l’exemple détaillé
• Partie N°6 : Petit résumé en images
• Partie N°7 : exercices (transcription en langage Arduino)
• Partie N°8 : la représentation dans SysMl 
• Partie N°9 : exercices Sysml

 
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 commence par analyser notre système :

  

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

Résumé de la démarche à mettre en œuvre :

1. on établit une liste des entrées et des sorties (capteurs/actionneurs)
2. on définit les différents états (ou étapes) du système
3. pour chaque état on note les valeurs des sorties
4. on liste les transitions entre chaque état
5. on définit les conditions logiques associées à ces transitions
6. 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 
• on y associe les valeurs des sorties
• on écrit les transitions
• on teste !!!!!!!!!!!!

 

 

Partie N°2 : 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 :

 

Partie N°3 : exercices de construction de graphes d'état

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.

 

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

Réalisez le graphe d’état de cet automatisme (mettre en évidence toutes les étapes de la réalisation).
  

 

Partie N°4 : transcription en langage Arduino

Comment programmer un graphe d’état 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 complément 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. L’instruction Break permet de sortie de l’instruction une fois un « case » exécuté.

 

 

Exemple (programme incomplet):

int toto; //la variable

switch toto {

   case 5:

      // la variable toto a la valeur 5

      . . . instructions à exécuter;

     break;

case 2:

      . . .

break;

default:

        …..

        break;

}// fin du switch

 

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

 

Remarque 2 : notre variable caractérisant nos états est un chiffre entier. Ce n’est pas très parlant dans le programme. L’astuce consiste à utiliser l’instruction enum (voir exemple ci dessous). Cette instruction se chargera de remplacer nos noms d’états (arret, montee et descente) par des chiffres entier. Le programme devient plus lisible.

Cela revient à (programme incomplet):

int etat ;

enum {arret, montee, descente};

…..

loop() {

dcy=digitalRead(DCY_pin) ;

bas=digitalRead(BAS_pin) ;

h
aut=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

 

Remarque importante : on note que dans chaque « case » on a :

• une gestion des sorties (ici 3 digitalWrite pour gérer les 3 sorties)
• un (ou plusieurs si nécessaire) test de capteur permettant de changer d’état

 

 

Partie N°5 : suite de l’exemple détaillé

Prototype de monte-charge (2 arrêts) réalisé avec une carte Arduino.

On reprend l’exercice de la partie N°2 de ce cours.

 

Le programme Arduino (tiré du graphe d’état de la partie N°2 de ce cours) :

// Dans le programme, les états sont identifiés par un enum et mémorisés dans une variable nommée Etat:

// 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;

    }

}

 

 

Partie N°6 : Petit résumé en images:

 

 Petit résumé en vidéo (le lien ici)

  

 

Partie N°7 : exercices (transcription en langage Arduino)

 

Exercice N°1 : déplacement d’un wagonnet

Soit le wagonnet ci dessous, wagonnet positionné en A au départ puis qui va en B se charger et revient en E pour décharger

 

Voici le graphe d’état (ordre des sorties : Gauche, Droite, Aiguillage en B, Aiguillage en A)

 
Câblage Arduino :

 

Proposez une version du programme Arduino.

 

 

Exercice N°2 – graphe d’état (ventilateurs d’un tunnel routier)

Gestion de la ventilation d’un tunnel :
Afin d’assurer la sécurité des personnes dans les tunnels et de respecter la législation en vigueur sur ces ouvrages, il est nécessaire d’installer un système de ventilation permettant la circulation de l’air, et donc d’évacuer les gaz.
Le tunnel étudié est équipé de :

• 3 ventilateurs indépendants.
• un capteur analogique de température (0 à 60°). La variable associée au capteur de température est temp. Pour avoir la température en degrés il faut prendre la valeur numérique lue par la carte et la multiplier par 0,06
• un capteur de CO2 (TOR), associé à une variable binaire. Lorsque le niveau de CO2 dépasse le seuil autorisé, CO2=1 et lorsque le niveau de CO2 est inférieur au seuil, CO2=0.

 

Voici le graphe d’état du système de gestion de la ventilation :

Câblage Arduino :

 
Proposez une version du programme Arduino

  

 

Partie N°8 : 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é

 

 

Partie N°9 : exercices

 

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 ?