Réserver une Démo
Pré. Proc.

Exemple : Fourche et Joindre

Les pseudo-états de fourche divisent une transition entrante en deux ou plusieurs transitions, se terminant par des sommets dans des régions orthogonales d'un State composite. Les transitions sortant d'un pseudo-état de fourche ne peuvent pas avoir de garde ou de déclencheur , et les comportements d'effet des transitions sortantes individuelles sont, au moins conceptuellement, exécutés simultanément.

Les pseudo-états de jointure sont un sommet cible commun pour deux ou plusieurs transitions provenant de sommets dans différentes régions orthogonales. Les pseudo-états de jointure exécutent une fonction de synchronisation, selon laquelle toutes les transitions entrantes doivent être terminées avant que l'exécution puisse se poursuivre via une transition sortante.

Dans cet exemple, nous démontrons le comportement d'une Statemachine avec des pseudo-états Fourche et Joindre .

Modélisation Statemachine

Example StateMachine diagram with Fork/Joins in Sparx Systems Enterprise Architect

Contexte de Statemachine

  • Créez un élément de classe nommé MyClass , qui sert de contexte à une Statemachine
  • Cliquez-droit sur MyClass dans la fenêtre Navigateur et sélectionnez l'option 'Ajouter | Statemachine '

Statemachine

  • Ajoutez un nœud initial , une fourche , un State nommé State1 , une jointure et un final au diagramme
  • Agrandir l'état1 , cliquez-droit dessus sur le diagramme et sélectionnez l'option « Avancé | Définir les sous-états simultanés | Définir » et définissez la région A et la région B
  • Dans RegionA , définissez StateA1 , transition vers StateA2 , déclenchée par l'événement X
  • Dans la région B , définissez l'État B1 , transition vers l'État B2 , déclenchée par l'événement Y
  • Dessiner d'autres transitions : Initial vers Fork ; Fork vers StateA1 et StateB1 ; StateA2 et StateB2 vers Join ; Join vers Final

Simulation

Artefact

Enterprise Architect supporte C, C++, C# , Java et JavaScript ; nous utiliserons JavaScript dans cet exemple car nous n'avons pas besoin d'installer de compilateur (pour les autres langages, Visual Studio ou JDK sont requis).

  • Depuis la boîte à outils Diagramme sélectionnez la page « Simulation » et faites glisser l'icône Statemachine Exécutable sur le diagramme pour créer un artefact ; nommez-le ForkNJoinSimulation et définissez son champ « Langue » sur « JavaScript ».
  • Ctrl+Drag MyClass depuis la fenêtre Navigateur et déposez-le sur l'artefact ForkNJoinSimulation en tant que propriété ; donnez-lui le nom myClass
Executable StateMachine for SysML simulation in Sparx Systems Enterprise Architect

Génération de code

  • Cliquez sur ForkNJoinSimulation et sélectionnez l'option de ruban 'Simulate > States Exécutables > Statemachine > Générer , Build and Exécuter '
  • Spécifiez un répertoire pour le code source généré
Note : le contenu de ce répertoire sera effacé avant la génération ; assurez-vous de pointer vers un répertoire qui existe uniquement à des fins de simulation Statemachine .

Fork and Join during simulation of executable state machine

Exécuter Simulation

Lorsque la simulation démarre, State1 , StateA1 et StateB1 sont actifs et la Statemachine attend des événements.

Fork and Join during simulation of executable state machine

Sélectionnez l'option de ruban 'Simuler > Simulation Dynamique > Événements ' pour afficher la fenêtre Simulation Événements .

Lors de l'événement Déclencheur X , StateA1 va sortir et entrer dans StateA2 ; après que les comportements entry et doActivity ont été exécuter , les événements d'achèvement de StateA2 sont envoyés et rappelés. Ensuite, la transition de StateA2 vers le pseudo-état Join est activée et parcourue.

Note : Join doit attendre que toutes les transitions entrantes soient terminées avant que l'exécution puisse se poursuivre via une transition sortante. Étant donné que la branche de RegionB n'est pas terminée (car StateB1 est toujours actif et en attente de déclencheurs ), la transition de Join à Final ne sera pas exécutée à ce stade. ce moment.

Fork and Join during simulation of executable state machine

Lors de l'événement Déclencheur Y , StateB1 va sortir et entrer dans StateB2 ; après que le comportement entry et doActivity a été exécuter , les événements d'achèvement de StateB2 sont envoyés et rappelés. Ensuite, la transition de StateB2 vers le pseudo-état Join est activée et parcourue. Cela satisfait les critères de tous les transitions entrantes de Join étant terminées, la transition de Join à Final est exécutée. Simulation est terminée.

Conseils : Vous pouvez visualiser la séquence de trace d'exécution depuis la fenêtre Simulation (option du ruban 'Simuler > Simulation Dynamique > Simulateur > Ouvrir la fenêtre Simulation ').

myClass[MyClass].Initial_82285__TO__fork_82286_82286_61745 Effet

maClasse[MaClasse].StateMachine_State1 ENTRÉE

maClasse[MaClasse].StateMachine_State1 FAIRE

myClass[MyClass].fork_82286_82286__TO__StateA1_57125 Effet

maClasse[MaClasse].StateMachine_State1_StateA1 ENTRÉE

maClasse[MaClasse].StateMachine_State1_StateA1 FAIRE

myClass[MyClass].fork_82286_82286__TO__StateB1_57126 Effet

maClasse[MaClasse].StateMachine_State1_StateB1 ENTRÉE

maClasse[MaClasse].StateMachine_State1_StateB1 FAIRE

Déclencheur X

maClasse[MaClasse].StateMachine_State1_StateA1 SORTIE

myClass[MyClass].StateA1__TO__StateA2_57135 Effet

maClasse[MaClasse].StateMachine_State1_StateA2 ENTRÉE

maClasse[MaClasse].StateMachine_State1_StateA2 FAIRE

maClasse[MaClasse].StateMachine_State1_StateA2 SORTIE

myClass[MyClass].StateA2__TO__join_82287_82287_57134 Effet

Déclencheur Y

maClasse[MaClasse].StateMachine_State1_StateB1 SORTIE

myClass[MyClass].StateB1__TO__StateB2_57133 Effet

maClasse[MaClasse].StateMachine_State1_StateB2 ENTRÉE

maClasse[MaClasse].StateMachine_State1_StateB2 FAIRE

maClasse[MaClasse].StateMachine_State1_StateB2 SORTIE

myClass[MyClass].StateB2__TO__join_82287_82287_57132 Effet

maClasse[MaClasse].StateMachine_State1 SORTIE

maClasse[MaClasse].join_82287_82287__TO__Final_105754_57130 Effet

Pré. Proc.