FORMATION SI/STI2D

MODELISATION MULTI-PHYSIQUE J2
Diagrammes d'états avec Stateflow

Le chronomètre

Table des matières

1. Présentation..................................................................................................................... 2
2. Fonctionnalités de base...................................................................................................3
3. Ajout de la fonctionnalité SPLIT.......................................................................................7
4. Pour aller plus loin…........................................................................................................8
ANNEXE 1 - L’interface de Simulink/Sateflow (d’après Philippe Hautcoeur).......................9
ANNEXE 2 – Description des principales fonctionnalités de StateFlow.............................10
ANNEXE 3 - Correspondance entre le diagramme d’état SysML et StateFlow (d’après
Philippe Hautcoeur)............................................................................................................14
ANNEXE 4 – Conception de base du fichier chronobase..................................................16

Source utilisée : StateFlow R2109b par Philippe Hautcoeur.

Le chronomètre 1/16
1. Présentation
L’objectif de cette activité est de simuler le comportement d’un chronomètre qui pourrait
être utilisé par un entraîneur souhaitant mesurer les performances de son athlète.
Les fonctionnalités basiques de ce chronomètre sont représentées dans le diagramme des
cas d’utilisation suivant :

Le chronomètre, comme le montre le diagramme de définition de blocs suivant, est

composé, entre autre, d’une carte à micro-processeur, d’un afficheur qui affiche les
secondes écoulées depuis le début et de deux boutons :
- le bouton A permet de déclencher et d’arrêter le chronomètre
- le bouton B permet d’établir un temps intermédiaire. Il sert également à remettre
l’affichage à zéro.

Le chronomètre 2/16
Le diagramme de bloc interne suivant montre les interconnexions entre certains éléments
du chronomètre. Nous allons reproduire cette architecture dans Simulink.

2. Fonctionnalités de base
Dans cette partie, nous allons poursuivre la construction du modèle du chronomètre dans
Simulink en utilisant un chart (diagramme d’état) StateFlow pour modéliser le
comportement de la carte à micro-processeur tel que défini dans le diagramme d'états
SysML ci-dessous.

Un fichier ChronoBase.slx est fourni. La procédure ayant servi à créer les premiers
élément du fichier (bouton et affichage de Dashboard, chart,… ) est décrite en annexe 4.
Nous allons définir le diagramme d’états décrivant le comportement du système grâce à
l’environnement Stateflow.
1. Ouvir le fichier ChronoBase.slx puis ouvrir le « chart » en double-cliquant dessus.
On accède alors à tous les éléments pouvant composer un diagramme d’états.
2. Nous allons régler le Stop time (durée de la simulation) sur « inf », choisir un Solver
à pas fixes (fixed-step) plutôt qu’à pas variables et imposer un sample time de
0,001 sec. Ainsi, les « ticks » qui vont cadencer l’évolution de la machine à états
auront lieu toutes les millisecondes, ce qui est suffisant pour un chronomètre précis

Le chronomètre 3/16
 au centième de seconde et a fortiori pour notre première version du chronomètre
qui comptera uniquement des secondes.
Pour cela, cliquer sur « VariableStepAuto » en bas à droite de la fenêtre puis sur
l’engrenage et modifier les valeurs comme sur la capture.

Une présentation de l'interface Simulink/StateFlow et de ses fonctionnalités est

donnée en annexes 1 et 2.
3. Ajouter au « Chart » les états par glisser/déposer et les transitions afin que le
diagramme soit tel que le suivant. Les variables utilisées seront définies plus tard.

Le chronomètre 4/16
 Les transitions sont réalisées en approchant la souris du bord d’un état jusqu’à ce
que le pointeur se transforme en croix (+). Il faut alors cliquer, se déplacer jusqu’à
l’état suivant puis relâcher. La transition se spécifie en double cliquant dessus.
L’appui sur le bouton A sera détecté en testant une variable d’entrée (input variable)
nommée « boutonA » à laquelle on connectera la valeur du bloc « constante »
modifiée par l’appui sur le bouton poussoir. Un bloc intermédiaire nommé « Edge
detector » permet de générer une impulsion d’une largeur d’un « tick » lors d’un
appui sur le bouton. Cela permet de ne prendre en compte qu’un seul appui et ainsi
éviter de sauter d’un état à l’autre tant que le bouton n’a pas été relâché.
La condition de garde [boutonA] est équivalente à [boutonA==1]
La variable « compteur » sera une variable locale (local variable).
La variable « affichage » est déjà définie en variable de sortie (output variable).
Toutes ces variables seront déclarées lors de l’exécution de la simulation.
4. Avant de lancer la simulation, il faut synchroniser l’écoulement du temps avec le
temps réel car, sinon, la simulation sera trop rapide pour interagir avec elle. Pour
cela, cliquer sur la petite flèche noire sous le bouton « Run » puis « Simulation
Pacing » → dans la nouvelle fenêtre, cliquer dans la case « Enabling pacing… » et
enfin, fermer cette fenêtre.

Dès lors, le bouton de démarrage ressemble à ceci :

La simulation s'exécutera « en temps réel ».
5. Pour faciliter la déclaration des variables, lancer la simulation. Un message d’erreur
apparaît disant que des symboles n’ont pas été résolus. Il s’agit des variables.

Le chronomètre 5/16
6. Cliquer sur le lien et, dans la nouvelle fenêtre, définir le type des variables tels que
sur la capture.
7. Remonter dans l’arborescence du modèle en cliquant sur la flèche

8. Compléter les liens tels que ci-dessous :

9. Ouvrir le diagramme d’états dans une nouvelle fenêtre afin de suivre l’évolution de
la machine à états tout en manipulant les boutons et en suivant l’évolution de
l’affichage. Pour cela, effectuer un clic droit sur le « chart » → Open in New
Window.

Le chronomètre 6/16
 10. Lancer la simulation et cliquer sur les boutons (A et B) afin de démarrer le
chronomètre, de l’arrêter et de le remettre à zéro.

3. Ajout de la fonctionnalité SPLIT

A présent nous allons ajouter une fonctionnalité supplémentaire : le temps intermédiaire
(split time en anglais) qui correspondra à un état supplémentaire du chronomètre que l'on
nommera « Split ». Lorsque le chronomètre est dans l'état « Split », le comptage du temps
continue, de la même façon que dans l'état « Started ». Ainsi, on peut ajouter un état
composite (appelé également « super-état ») qui englobe les deux états « Started » et
« Split ».

11. Ajouter le super-état « Comptage », placer l'état « Started » à l'intérieur et déplacer

la transition réflexive sur les bord du super-état. Ajouter enfin l’élément « History »
qui mémorise le sous-état qui était actif avant de sortir du super-état.

A compléter

Le chronomètre 7/16
 12. Ajouter le ou les états ainsi que les transitions nécessaires afin que le chronomètre
adopte le comportement suivant :
- Lorsque le chronomètre est lancé, il est possible de suspendre l’affichage en
appuyant sur le bouton B afin de lire un temps intermédiaire. Le chronomètre
bascule dans l'état « Split » continue à tourner en tâche de fond mais la valeur
du temps intermédiaire reste fixe sur l’écran d’affichage.
- Dans cet état « Split », si on rappuie sur B, le chrono tourne toujours et
l’affichage recommence à s’incrémenter en partant de la valeur courante du
compteur.
- Dans l’état « Split », si on appuie sur A, le chrono s’arrête mais l’affichage
reste sur le temps intermédiaire. Si on appuie ensuite sur B, l’affichage montre
la valeur du temps final. Si on rappuie sur B, l’affichage est réinitialisé à 0.

4. Pour aller plus loin…

Dans cette partie, nous souhaitons ajouter l’affichage des centièmes de seconde, des
secondes et des minutes tel que le ferait un véritable chronomètre.

13. Créer 3 nouvelles variables locales : cent, sec et min

et 3 nouvelles variables de sortie : aff_cent (pour affichage centième), aff_sec et
aff_min

14. Ajouter 3 nouveaux afficheurs (display) au modèle Simulink et les connecter aux
trois nouvelles sorties, un pour les minutes, un pour les secondes et un pour les
centièmes de seconde

15. modifier la transition interne des états de comptage en ajoutant un diagramme de

flux (jonctions de décision et transitions) afin de décomposer les minutes les
secondes et les centièmes

Le chronomètre 8/16
ANNEXE 1 - L’interface de Simulink/Sateflow (d’après
Philippe Hautcoeur)

Le chronomètre 9/16
ANNEXE 2 – Description des principales fonctionnalités
de StateFlow
La palette d’outils nécessaire à la construction d’un diagramme d’état par un « glissé /
déposé » est la suivante. Elle comporte plusieurs objets dont certains sont graphiques:

Parmi les éléments importants, on trouve :

• L’état (State) représenté par un rectangle aux angles arrondis : le nom de l’état ou
son étiquette (« state label ») est saisi dans le champ « Name » en haut à gauche
du rectangle. Les actions réalisées dans cet état sont saisies en cliquant sur « {...} »
au-dessous du nom de l’état. Les actions associées aux états peuvent avoir lieu :
◦ à l’activation de l’état : « entry : action ; » ou, en abrégé, « en : action ; »
◦ à la désactivation de l’état : « exit : action ; » ou « ex : action ; »
◦ pendant l’activité de l’état : « during : action ; » ou « du : action ; »
• La transition (transition) représentée par une flèche entre deux états montrant le
sens de passage d’un état à l’autre. Elle est caractérisée par une étiquette
(transition label) qui décrit les circonstances ou les conditions de passage d’un état
à un autre. Elle peut se décomposer de la manière suivante :

Le chronomètre 10/16
 Ce qui s’interprète de la façon suivante :
◦ à l’occurrence de l’événement la transition est évaluée ;
◦ Si la condition est vraie alors la transition est valide et si l’action sur condition
existe, elle est exécutée ;
◦ l’action sur transition, si elle existe, est aussi réalisée avant l’entrée dans l’état
pointé par la transition ;
◦ parfois, une condition seule permet de valider la transition. Elle sera alors
évaluée à chaque pas de calcul afin de savoir si la transition doit être réalisée ;
◦ il est également possible de réaliser une transition externe réflexive, auquel cas,
à chaque transition, on sort de l’état pour y entrer à nouveau.

• La transition par défaut (default transition) : il s’agit de la transition initiale qui

marque le point d’entrée du diagramme d’état ou encore le point d’entrée à
l’intérieur d’un super-état.
Pour aller plus loin :
• Les événements extérieurs :
◦ ils sont pris en compte en entrant dans le chart par le dessus

Le chronomètre 11/16
 ◦ plusieurs événements peuvent être pris en compte dans le chart en les faisant
« entrer » à l’aide d’un objet de type « multiplexeur » (« mux »)
• La jonction :
◦ c’est un pseudo-état permettant par exemple de factoriser des expressions
booléennes associées à des conditions ;
◦ elle permet également de réaliser des structures algorithmiques. Par exemple,
la structure suivante :

correspond à un si-alors-sinon (l’ordre d’évaluation des transitions est

primordial)
si (A==1) alors on va dans l’état E11 sinon, on bascule dans l’état E12
◦ Pour aller plus loin, elle permet de réaliser des flow chart (diagrammes de flux).
Le diagramme de flux, contrairement aux diagrammes d’état (« State Chart »)
ne comporte pas d’état mais uniquement des transitions et des jonctions. Il se
termine obligatoirement par un jonction.

équivalent à la structure alternative :

Le chronomètre 12/16
 Si u>0 alors S=1000 sinon S=0

• Les opérateurs temporels : at, every, before, temporalCount et surtout after qui
permet de réaliser une transition après un certain temps (exprimé en secondes =
sec, en millisecondes = msec, en microsecondes = usec ou en nombre de ticks).

• Les super-états contenant des états pouvant s’exécuter simultanément (parallèles),

auquel cas ils apparaissent avec les bords en pointillés, ou non (exclusive)

Le choix du type de super-état s’effectue dans l’onglet « Modeling » →

« Décomposition »

Le chronomètre 13/16
ANNEXE 3 - Correspondance entre le diagramme d’état
SysML et StateFlow (d’après Philippe Hautcoeur)

Le chronomètre 14/16
Le chronomètre 15/16
ANNEXE 4 – Conception de base du fichier chronobase
1. Ouvrir Matlab, lancer Simulink puis créer un nouveau fichier (new blank model)

2. Sur ce nouveau modèle, en les recherchant par mot-clé dans la bibliothèque

Simulink, ajouter :
◦ deux boutons (push button) et deux blocs constantes à 0 (Constant)
◦ un afficheur (display)
Et les disposer comme ci-dessous :

3. Double-cliquer sur le premier bouton pour ouvrir la fenêtre de ses paramètres puis
cliquer sur la constante à côté et enfin, dans la fenêtre, connecter le bouton à la
constante. Ceci permettra de faire passer la valeur du bloc constante (qui portera
mal son nom dans ce cas...) de 0 à 1 lorsqu’on cliquera sur le bouton puis de 1 à 0
lorsqu’on le relâchera.

4. Modifier le texte du bouton pour l’appeler « A »

5. Reprendre les étapes 3 et 4 pour configurer le bouton « B »

Le chronomètre 16/16