Méta-modèle du Diagramme d’Etats

Diagramme de classes du diagramme d’Etats

Si vous maitrisez le diagramme de classes, vous allez mieux comprendre comment est construit un diagramme d’Etats avec les éléments qui le composent et les relations entre eux.

Explications

Rôles de chaque élément

• StateMachine : racine du comportement; contient ≥ 1 Region (le conteneur racine (diagramme lui-même).
• Region : partition d’états (utile pour les états orthogonaux). Possède des Vertex (nœuds) et des Transitions.
• Vertex (abstrait) : super-type de State, Pseudostate.
• State : peut avoir entry/do/exit (Behavior), des Transitions entrantes/sortantes, des subregions (si composite) ou référencer une submachine (réutilisation).
• FinalState : état terminal (spécialisation de State).
• Pseudostate : nœuds techniques : initial, choice, junction, fork, join, history (deep/shallow), entryPoint, exitPoint, terminate.
• Transition : lien source –> target avec éventuellement Trigger(s), Guard (condition booléenne) et Effect (Behavior exécutée pendant la transition). Types : external, internal, local.
• Trigger : déclencheur; référence un Event.
• Event (abstrait) : SignalEvent (message), CallEvent (appel d’opération), TimeEvent (après / à t), ChangeEvent (quand condition devient vraie).
• Guard/Constraint : expression booléenne conditionnant la prise d’une transition.
• Behavior : action/activité exécutable (entry, doActivity, exit, effect).

Quelques explications complémentaires

1. Qu’est-ce qu’un Vertex ?

Définition UML : Un Vertex est un nœud d’un graphe d’états. Il représente un point de passage ou un point de décision dans la machine à états.

C’est un point du diagramme où le flux peut arriver ou repartir.

Un Vertex peut être :

• un State (État) : ex. Allumé, Éteint, Verrouillé
• un Pseudostate : ex. Initial, Choice, Fork, Join, History
• un FinalState : l’état terminal.

Pour mieux comprendre, imaginez un plan de métro : Chaque station est un Vertex, et les lignes entre elles sont des Transitions.

2. Qu’est-ce qu’une Region ?

Définition UML : Une Region est un conteneur logique d’états et de transitions.

C’est une sous-partie d’une machine à états (ou d’un état composite) où l’on place les nœuds (Vertex) et transitions associées.

• Une StateMachine peut contenir plusieurs Regions (Utile pour représenter des comportements parallèles orthogonaux).
• Un État composite (un état qui contient d’autres états) peut aussi avoir ses propres Regions internes.

Pour illustrer ces notions, prenons un ascenseur qui a deux régions simultanées :

• Mouvement (en haut, en bas, arrêté)
• Porte (ouverte, fermée, en mouvement)

Les deux régions vivent en parallèle dans la même machine !

3. Qu’est-ce qu’un Guard ?

Définition UML : Un Guard est une condition booléenne attachée à une transition. La transition n’est franchie que si le Guard est vrai au moment du déclenchement.

C’est un filtre logique sur une transition.

Exemple de transition :

[etat1] --[boutonAppuyé && !batterieFaible]--> [etat2]

Précisions :

• Trigger = ce qui déclenche la transition (ex. un événement ou un signal)
• Guard = ce qui autorise la transition (ex. condition vraie ou fausse)
• Effect = ce qui s’exécute pendant la transition, ce que cela produit.

Contraintes clés

• Une StateMachine possède au moins une Région.
• Une Région possède des Vertex (States/Pseudostates) et des Transitions.
• Une Transition a exactement 1 source et 1 target (Vertex).
• Un State composite possède ≥ 1 sous-region (orthogonalité possible si >1).
• Un PseudoState initial n’a pas d’entrantes, et exactement 1 sortante (non gardée, donc sans condition).
• Un FinalState n’a pas de sortantes puisque c’est l’état final !
• Un Trigger engendre un Event (1:1), Guard –> booléen, Effect –> Behavior optionnelle (comportement).

Lire un diagramme d’états via le méta-modèle

1. Repérer la StateMachine –> ses Regions.
2. Dans chaque Région, lister les Vertex (States & PseudoStates).
3. Pour chaque Transition : source –> target + [Guard] + /effect + trigger.
4. Pour chaque State : entry / do / exit et subregions (si composite).
5. Vérifier les contraintes (initial/final, cardinalités, cohérence).

Exemple simple (instanciation du méta-modèle)

Visseuse électronique : Éteint –> [bouton appuyé] –> Allumé –> [timer 5s/erreur] –> Éteint

• StateMachine: Visseuse SM(State Machine)
  • Region: Main
    • Pseudostate(initial): Init
    • State: Éteint (entry: couperAlim())
    • State: Allumé (do: tourner(), exit: ralentir())
    • FinalState: Fin (optionnel)
    • Transitions:
      • Init –> Éteint
      • Éteint –[onPress]–> Allumé / bip() (Trigger=SignalEvent)
      • Allumé –[after 5s]–> Éteint (Trigger=TimeEvent)

Exercice

À partir du texte ci-dessous :

Une porte automatique est Fermée.
Elle s’Ouvre quand on approche un badge valide.
Elle reste Ouverte 3 secondes puis se Referme.
Si un obstacle est détecté pendant la fermeture, elle retourne à Ouverte.

1. Listez les States (états), Pseudostates, Events (Signal/Time/Change), Transitions
2. Dessinez le diagramme (ou au moins alignez les triplets source –[Trigger/Guard]/Effect –> Target)
3. Vérifiez les contraintes du méta-modèle (initial, final, cardinalités)

Conclusion

Un diagramme d’états est une machine composée de Régions, elles-mêmes peuplées de sommets reliés par des Transitions, chacune conditionnée par une Garde (condition) et déclenchée par un événement.

Bonus : Code PlantUML du diagramme de classes

@startuml
' ============================================================
'  Méta-modèle UML — Diagramme d'États (version française)
' ============================================================

hide empty methods
hide empty fields
skinparam classAttributeIconSize 0
skinparam wrapWidth 240
skinparam maxMessageSize 120

title Méta-modèle UML — Diagramme d'états (version FR)

' ======================
' Éléments principaux
' ======================

class MachineDEtats {
  + nom : Chaîne
}

class Région {
  + nom : Chaîne
}

abstract class Sommet {
  + nom : Chaîne
}

class État {
  + estComposite : Booléen
  + estSousMachine : Booléen
  + déclencheursDifférables : Déclencheur[*]
  + entrée : Comportement [0..1]
  + activité : Comportement [0..1]
  + sortie : Comportement [0..1]
}

class ÉtatFinal

class PseudoÉtat {
  + type : TypePseudoÉtat
}

enum TypePseudoÉtat {
  initial
  historiqueProfonde
  historiqueSuperficielle
  choix
  jonction
  fourche
  jonctionParallèle
  pointEntrée
  pointSortie
  terminer
}

class Transition {
  + type : TypeTransition
  + effet : Comportement [0..1]
}

enum TypeTransition {
  externe
  interne
  locale
}

class Déclencheur
abstract class Événement
class SignalÉvénement
class AppelÉvénement
class ÉvénementTemporel {
  + quand : ExpressionTemporelle
}
class ÉvénementConditionnel {
  + condition : ExpressionBooléenne
}

class Garde {
  + expression : ExpressionBooléenne
}

class Comportement {
  + corps : Chaîne
}

' ======================
' Relations hiérarchiques
' ======================

Sommet <|-- État
Sommet <|-- PseudoÉtat
État <|-- ÉtatFinal

Événement <|-- SignalÉvénement
Événement <|-- AppelÉvénement
Événement <|-- ÉvénementTemporel
Événement <|-- ÉvénementConditionnel

MachineDEtats "1" *-- "1..*" Région : contient >
Région "1" *-- "1..*" Sommet : possède >
Région "0..*" o-- "0..*" Transition : relie >

Transition "1" --> "1" Sommet : source >
Transition "1" --> "1" Sommet : cible >
Transition "0..1" --> "0..1" Garde : condition >
Transition "0..*" o-- "0..*" Déclencheur : déclenche >
Déclencheur "0..*" --> "1" Événement : événement >
Transition "0..1" --> "0..1" Comportement : effet >

État "0..*" *-- "0..*" Région : sousRégions >

' ======================
' Notes pédagogiques
' ======================

note top of MachineDEtats
  Racine du comportement dynamique.
  Contient une ou plusieurs régions.
end note

note right of Région
  Conteneur d'états et de transitions.
  Sert à séparer ou paralléliser les comportements.
end note

note bottom of Transition
  Liée à un Sommet source et un Sommet cible.
  Peut comporter :
  - un Déclencheur (Trigger)
  - une Garde (condition)
  - un Effet (Comportement)
end note

note right of Garde
  Expression booléenne qui doit être vraie
  pour que la transition soit franchie.
end note

@enduml