Surveiller l’activité des diagrammes en utilisant les données de l’état actif

Étape 6 sur 7 dans Modéliser des machines à états finis

Si votre diagramme Stateflow^® comprend des données fortement corrélées à la hiérarchie du diagramme, vous pouvez simplifier votre design en utilisant les données de l’état actif. L’activation des données de l’état actif vous permet de :

Éviter les mises à jour manuelles des données reflétant l’activité du diagramme.
Enregistrer et surveiller l’activité du diagramme dans le Simulation Data Inspector.
Utiliser les données d’activité du diagramme pour contrôler d’autres sous-systèmes.
Exporter les données d’activité du diagramme vers d’autres blocs Simulink^®.

Pour plus d’informations, veuillez consulter Créer une hiérarchie pour gérer la complexité du système.

Données de l’état actif

L’utilisation de la sortie des données de l’état actif peut simplifier le design de certains diagrammes Stateflow. Par exemple, dans ce modèle de feu de circulation, l’état actif détermine la valeur du symbole color. Lorsque vous activez les données de l’état actif, Stateflow peut fournir la couleur du feu de circulation en suivant l’activité de l’état. La mise à jour explicite de color n’étant plus nécessaire, vous pouvez supprimer ce symbole et simplifier le design du diagramme.

Chart modeling a traffic signal, with states called Red, Yellow, and Green. The value of the symbol color indicates which state is active.

Stateflow fournit des données sur l’état actif via un port de sortie vers Simulink ou sous forme de données locales sur votre diagramme. Ce tableau répertorie les différents modes de données de l’état actif disponibles.

Mode d’activité	Type de données	Description
Activité autonome	Booléen	L’état est-il actif ?
Activité enfant	Énumération	L’état enfant est-il actif ?
Activité d’état feuille	Énumération	L’état feuille est-il actif ?

Pour activer les données de l’état actif, sélectionnez un état à surveiller. Puis, dans Property Inspector :

Cochez la case Create output for monitoring.
Sélectionnez un mode d’activité dans la liste déroulante.
Saisissez le Data name du symbole de données de l’état actif.
(Facultatif) Pour l’activité de l’état enfant ou feuille, saisissez le Enum name du type de données de l’état actif.

Par défaut, Stateflow rapporte l’activité de l’état sous la forme de données de sortie. Pour modifier la portée d’un symbole de données de l’état actif en données locales, utilisez le volet Symbols.

Exemple de données de l’état actif

Cet exemple utilise :

Ouvrir le modèle

Cet exemple utilise les données de l’état actif pour modéliser le système de contrôle de deux feux de circulation.

Dans le diagramme Traffic Controller, deux sous-diagrammes parallèles gèrent la logique de contrôle des feux de circulation. Les sous-diagrammes possèdent une hiérarchie identique composée de trois états enfant : Red, Yellow et Green. Les données de sortie Light1 et Light2 correspondent aux états enfant actifs dans les sous-diagrammes. Ces signaux :

Déterminent la phase des feux de circulation animés.
Contribuent au nombre de voitures qui attendent à chaque feu.
Dirigent un sous-système d’assertion de sécurité qui vérifie que les deux feux de circulation ne sont jamais verts simultanément.

Pour afficher les sous-diagrammes dans le diagramme Traffic Controller, cliquez sur la flèche située dans le coin inférieur gauche du diagramme.

Comportement des sous-diagrammes du Traffic Controller

Chaque contrôleur de trafic alterne par les états enfant, de Red vers Green, puis vers Yellow avant de revenir à Red. Chaque état correspond à une phase du cycle des feux de circulation. Les signaux de sortie Light1 et Light2 indiquent l’état actif à n'importe quel moment donné.

Chart modeling a traffic signal. The chart uses active state data to indicate which state is active.

Feu rouge

Lorsque l’état Red devient actif, le cycle des feux de circulation commence. Après un bref délai, le contrôleur vérifie si des véhicules attendent au carrefour. S’il détecte au moins un véhicule ou passé une durée déterminée, le contrôleur demande un feu vert en définissant greenLightRequest à true. Une fois la demande passée, le contrôleur reste dans l’état Red pendant un bref laps de temps jusqu’à ce qu’il détecte que l’autre feu de circulation est rouge. Le contrôleur bascule ensuite sur Green.

Feu vert

Lorsque l’état Green devient actif, le contrôleur annule la demande de feu vert en définissant greenLightRequest à false. Le contrôleur définit greenLightLocked à true, ce qui empêche l’autre feu de passer au vert. Au bout d’un certain temps, le contrôleur vérifie si l’autre contrôleur a demandé un feu vert. S’il reçoit une demande ou passé un délai donné, le contrôleur bascule sur l’état Yellow.

Feu orange

Avant de basculer sur l’état Red, le contrôleur maintient l’état Yellow pendant une durée déterminée. Lorsque l’état Yellow devient inactif, le contrôleur définit greenLightLocked à false, ce qui indique que l’autre feu de circulation peut passer au vert en toute sécurité. Le cycle des feux de circulation recommence.

Temporisation des feux de circulation

Plusieurs paramètres définissent la temporisation du cycle des feux de circulation. Pour modifier les valeurs de ces paramètres, double-cliquez sur le diagramme Traffic Controller et saisissez les nouvelles valeurs dans la boîte de dialogue Block Parameters.

Paramètre	Valeur prédéfinie	Description
`REDDELAY`	6 secondes	Délai avant que le contrôleur ne vérifie la présence de véhicules au carrefour. Il s’agit également du délai minimal avant que le feu de circulation ne puisse passer au vert après la demande de feu vert du contrôleur.
`MAXREDDELAY`	360 secondes	Délai maximal passé lequel le contrôleur vérifie la présence de véhicules avant la demande de feu vert.
`GREENDELAY`	180 secondes	Délai maximal pendant lequel le feu de circulation reste vert.
`MINGREENDELAY`	120 secondes	Délai minimal pendant lequel le feu de circulation reste vert.
`YELLOWDELAY`	15 secondes	Délai pendant lequel le feu de circulation reste orange.

Explorer l’exemple

Activez l'activité de log pour greenLightRequested, greenLightLocked, Light1 et Light2. Dans le volet Symbols, sélectionnez chaque symbole. Puis, dans le Property Inspector sous Logging, sélectionnez ensuite Log signal data.
Dans l’onglet Simulation, cliquez sur Run .
Dans l’onglet Simulation, sous Review Results, cliquez sur Data Inspector .
Dans le Simulation Data Inspector, affichez les signaux enregistrés sur des axes séparés. Les signaux booléens greenLightRequested et greenLightLocked apparaissent sous forme de valeurs numériques de zéro ou un. Les signaux d’activité de l’état Light1 et Light2 sont représentés sous forme de données énumérées avec les valeurs Green, Yellow, Red et None.

Simulation Data Inspector showing the output of the chart.

Pour suivre l’activité du diagramme pendant la simulation, vous pouvez utiliser les boutons de zoom et les curseurs dans le Simulation Data Inspector. Par exemple, ce tableau détaille l’activité pendant les 300 premières secondes de la simulation.

Durée	Description	`Light 1`	`Light2`	`greenLightRequested`	`greenLightLocked`
t = 0	Au début de la simulation, les deux feux de circulation sont rouges.	`Red`	`Red`	`false`	`false`
t = 6	Après 6 secondes (`REDDELAY`), des véhicules attendent dans les deux rues. Les deux feux de circulation demandent un feu vert en définissant `greenLightRequested` = `true`.	`Red`	`Red`	`true`	`false`
t = 12	Après 6 secondes supplémentaires (`REDDELAY`) : Le feu 1 passe au vert en définissant `greenLightLocked` = `true` et `greenLightRequested` = `false`. Le feu 2 demande un passage au vert en définissant `greenLightRequested` = `true`.	`Green`	`Red`	`false`, puis `true`	`true`
t = 132	Après 120 secondes (`MINGREENDELAY`), le feu 1 passe à l’orange.	`Yellow`	`Red`	`true`	`true`
t = 147	Après 15 secondes (`YELLOWDELAY`) : Le feu 1 passe au rouge en définissant `greenLightLocked` = `false`. Le feu 2 passe au vert en définissant `greenLightLocked` = `true` et `greenLightRequested` = `false`.	`Red`	`Green`	`false`	`false`, puis `true`
t = 153	Après 6 secondes (`REDDELAY`), le feu 1 demande un passage au vert en définissant `greenLightRequested` = `true`.	`Red`	`Green`	`true`	`true`
t = 267	Le feu 2 passe à l’orange 120 secondes (`MINGREENDELAY`) après son passage au vert.	`Red`	`Yellow`	`true`	`true`
t = 282	Après 15 secondes (`YELLOWDELAY`) : Le feu 2 passe au rouge en définissant `greenLightLocked` = `false`. Le feu 1 passe au vert en définissant `greenLightLocked` = `true` et `greenLightRequested` = `false`.	`Green`	`Red`	`false`	`false`, puis `true`
t = 288	Après 6 secondes (`REDDELAY`), le feu 2 demande un passage au vert en définissant `greenLightRequested` = `true`.	`Green`	`Red`	`true`	`true`

Le cycle se répète jusqu’à la fin de la simulation au bout de t = 1000 secondes.

Sujets associés

Modéliser des machines à états finis