Exemple : Commandes de Simulation

Cet exemple montre comment utiliser la fenêtre Simulation pour observer les messages Trace ou envoyer des commandes pour contrôler une Statemachine . Grâce à cet exemple, vous pouvez examiner :

• Un attribut d'un contexte - la variable membre définie dans la classe, qui est le contexte de la Statemachine ; ces attributs portent des valeurs dans la portée du contexte pour tous les comportements State et les effets de transition, pour accéder et modifier
• Chaque attribut d'un signal - la variable membre définie dans le signal, qui est référencée par un événement et peut servir de paramètre d'événement ; chaque occurrence d'événement de signal peut avoir différentes instances d'un signal
• L'utilisation de la commande « Eval » pour interroger la valeur d'exécution d'un attribut de contexte
• L'utilisation de la commande « Dump » permet de vider le nombre d'événements actifs de l'état actuel ; elle peut également vider l'événement actuel différé dans le pool

Cet exemple est tiré du modèle EAExample :

Exemple Modèle . Simulation de Modèle . Statemachine Exécutable . Commandes de Simulation

Accéder

Créer un contexte et Statemachine

Dans cette section, nous allons créer une classe appelée TransactionServer, qui définit un Statemachine comme son comportement. Nous créons ensuite un Statemachine Exécutable Artifact comme environnement de simulation.

Créer le contexte de la Statemachine

1. Créez un élément de classe appelé TransactionServer.
2. Dans cette classe, créez un attribut appelé authorizeCnt avec valeur initiale 0.
3. Dans la fenêtre Navigateur , cliquez-droit sur TransactionServer et sélectionnez l'option 'Ajouter | Statemachine '.

Créer la Statemachine

1. Créez un pseudo-état initial appelé Initial .
2. Transition vers un State appelé inactif .
3. Transition vers un State appelé busy , avec le déclencheur NEW_REQUEST.
4. Transition:
   - Vers un pseudo-état Final appelé Final , avec le déclencheur QUIT
   - Retour au repos , avec le déclencheur AUTORISÉ, avec l'Effet 'this.authorizeCnt++;'

Créer un événement différé pour l' State occupé

1. Dessinez une auto-transition pour être occupé.
2. Modifiez le « type » de transition en « interne ».
3. Spécifiez le Déclencheur comme étant l'événement que vous souhaitez différer.
4. Dans le champ « Effet », saisissez « defer(); ».

Créer un signal et Attributes

1. Créez un élément Signal appelé RequestSignal.
2. Créez un attribut appelé requestType avec le type ' int '.
3. Configurez l'événement NEW_REQUEST pour référencer RequestSignal.

Créer l'artefact Statemachine Exécutable

1. Depuis la page « Simulation » de la boîte à outils Diagramme , faites glisser une icône « Statemachine Exécutable » sur le diagramme et appelez l'élément Simulation avec événement différé.
2. Ctrl+Glissez l'élément TransactionServer depuis la fenêtre Navigateur et déposez-le sur l'Artefact en tant que propriété, avec le serveur de noms.
3. Définissez la langue de l'Artefact sur JavaScript , qui ne nécessite pas de compilateur (pour l'exemple ; en production, vous pouvez également utiliser C, C++, C# ou Java, qui support Statemachines Exécutables ).
4. Cliquez sur l'artefact et sélectionnez l'option de ruban 'Simulate > States Exécutables > Statemachine > Générer , Build and Exécuter '.

Fenêtre Simulation et commandes

Lorsque la simulation démarre, l'état actuel est inactif .

La fenêtre Simulation montre que l'effet de transition, l'entrée et le comportement Do sont terminés pour l'état inactif et que la Statemachine attend un déclencheur .

Données d'événement via des valeurs pour Attributes de signal

Pour l'événement de signal de Déclencheur NEW_REQUEST, la dialogue « Entrée du paramètre Déclencheur » s'affiche pour prompt des valeurs pour les attributs répertoriés définis dans le signal RequestSignal , référencé par NEW_REQUEST.

Type la valeur '2' et cliquez sur le bouton OK . Les valeurs de l'attribut Signal sont ensuite transmises aux méthodes invoquées telles que les comportements de State et les effets de la Transition.

Ces messages sont affichés dans la fenêtre Simulation :

[03612562] En attente du Déclencheur

[03611358] Commande : diffusion NEW_REQUEST.RequestSignal(2)

[03611362] [serveur : TransactionServer] Événement mis en file d'attente : NEW_REQUEST.RequestSignal(requestType : 2)

[03611367] [serveur : TransactionServer] Événement envoyé : NEW_REQUEST.RequestSignal(requestType : 2)

[03611371] [serveur : TransactionServer] Comportement de sortie : ServerStateMachine_idle

[03611381] [serveur : TransactionServer] Effet de transition : idle__TO__busy_61772

[03611390] [serveur : TransactionServer] Comportement de l'entrée : ServerStateMachine_busy

[03611398] [serveur : TransactionServer] Comportement : ServerStateMachine_busy

[03612544] [serveur : TransactionServer] Achèvement : TransactionServer_ServerStateMachine_busy

[03612562] En attente du Déclencheur

Nous pouvons diffuser des événements en double-cliquant sur l'élément listé dans la fenêtre Simulation Événements . Alternativement, nous pouvons saisir une string de commande dans le champ texte de la fenêtre Simulation (sous la barre d'outils).

[03612562] En attente du Déclencheur

[04460226] Commande : diffusion NEW_REQUEST.RequestSignal(3)

[04460233] [serveur : TransactionServer] Événement mis en file d'attente : NEW_REQUEST.RequestSignal(requestType : 3)

[04461081] En attente du Déclencheur

Le message Simulation indique que l'occurrence de l'événement est différée (événement mis en file d'attente, mais non envoyé). Nous pouvons exécuter d'autres commandes à l'aide du champ de texte :

[04655441] En attente du Déclencheur

[04664057] Commande : diffusion NEW_REQUEST.RequestSignal(6)

[04664066] [serveur : TransactionServer] Événement mis en file d'attente : NEW_REQUEST.RequestSignal(requestType : 6)

[04664803] En attente du Déclencheur

[04669659] Commande : diffusion NEW_REQUEST.RequestSignal(5)

[04669667] [serveur : TransactionServer] Événement mis en file d'attente : NEW_REQUEST.RequestSignal(requestType : 5)

[04670312] En attente du Déclencheur

[04674196] Commande : diffusion NEW_REQUEST.RequestSignal(8)

[04674204] [serveur : TransactionServer] Événement mis en file d'attente : NEW_REQUEST.RequestSignal(requestType : 8)

[04674838] En attente du Déclencheur

dump : Query « nombre actif » pour un pool State et d'événements

Type dump dans le champ de texte ; ces résultats s'affichent :

Dans la section « nombre actif », nous pouvons voir que occupé est l'état actif (le nombre actif est 1).

Conseils : Pour un State Composite, le nombre actif est de 1 (pour lui-même) plus le nombre de régions actives.

Dans la section « Pool d'événements », nous pouvons voir qu'il existe quatre occurrences d'événements dans la file d'attente des événements. Chaque instance du signal contient des données différentes.

L'ordre des événements dans le pool est l'ordre dans lequel ils sont diffusés.

eval : Query Exécuter Time Valeur du Contexte

Déclencheur AUTORISÉ,

[04817341] En attente du Déclencheur

[05494672] Commande : diffusion AUTORISÉE

[05494678] [serveur : TransactionServer] Événement mis en file d'attente : AUTORISÉ

[05494680] [serveur : TransactionServer] Événement envoyé : AUTHORIZED

[05494686] [serveur : TransactionServer] Comportement de sortie : ServerStateMachine_busy

[05494686] [serveur : TransactionServer] Effet de transition : busy__TO__idle_61769

[05494687] [serveur : TransactionServer] Comportement de l'entrée : ServerStateMachine_idle

[05494688] [serveur : TransactionServer] Comportement : ServerStateMachine_idle

[05495835] [serveur : TransactionServer] Achèvement : TransactionServer_ServerStateMachine_idle

[05495842] [serveur : TransactionServer] Événement envoyé : NEW_REQUEST.RequestSignal(requestType : 3)

[05495844] [serveur : TransactionServer] Comportement de sortie : ServerStateMachine_idle

[05495846] [serveur : TransactionServer] Effet de transition : idle__TO__busy_61772

[05495847] [serveur : TransactionServer] Comportement de l'entrée : ServerStateMachine_busy

[05495850] [serveur : TransactionServer] Comportement : ServerStateMachine_busy

[05496349] [serveur : TransactionServer] Achèvement : TransactionServer_ServerStateMachine_busy

[05496367] En attente du Déclencheur

• La transition de l'état occupé à l'état inactif est effectuée, nous nous attendons donc à ce que l'effet soit exécuté
• Un événement est rappelé du pool et envoyé lorsque l'inactivité est terminée, ce qui fait que l' état occupé devient l'état actif
• Type dump et remarquez qu'il reste trois événements dans le pool ; le premier est rappelé et envoyé

[05693348] Pool d'événements : [

[05693349] NEW_REQUEST.RequestSignal(requestType:6),

[05693351] NEW_REQUEST.RequestSignal(requestType:5),

[05693352] NEW_REQUEST.RequestSignal(requestType:8),

[05693354] ]

Type eval server.authorizeCnt dans le champ de texte. Ce chiffre indique que la valeur du temps exécuter de 'server.authorizeCnt' est 1.

Déclencheur AUTHORIZED à nouveau. Lorsque le Statemachine est stable à busy , il restera deux événements dans le pool. Exécuter eval server.suthorizeCnt à nouveau ; la valeur sera 2.

Accéder à la variable membre du contexte à partir du comportement State et de l'effet de transition

Statemachine Exécutable d' Enterprise Architect supporte la simulation pour C, C++, C# , Java et JavaScript .

Pour C et C++, la syntaxe diffère de C# , Java et JavaScript pour accéder aux variables membres du contexte. C et C++ utilisent le pointeur '->' tandis que les autres utilisent simplement '.'; cependant, vous pouvez toujours utiliser this.variableName pour accéder aux variables. Enterprise Architect le traduira en this->variableName pour C et C++.

Donc, pour toutes les langues, utilisez simplement ce format pour la simulation :

cette.variableName

Exemples :

Dans l'effet de la transition :

ceci.autoriserCnt++;

Dans le comportement d'entrée, de sortie ou de sortie de certains États :

ceci.foo += ceci.bar;

Note : par défaut, Enterprise Architect remplace uniquement « this-> » par « this » pour C et C++ ; par exemple :

this.foo = this.bar + monObjet.iCount + monPointeur->iCount;

sera traduit par :

ceci->foo = ceci->bar + monObjet.iCount + monPointeur->iCount;

Une liste complète des commandes prises en charge

Étant donné que l'artefact Statemachine Exécutable peut simuler plusieurs contextes ensemble, certaines commandes peuvent spécifier un nom d'instance.

exécuter Statemachine :

Comme chaque contexte peut avoir plusieurs Statemachines , la commande ' exécuter ' peut spécifier une Statemachine avec laquelle démarrer.

• exécuter instance. statemachine
• exécuter tout.tout
• exécuter une instance
• exécuter tous
• exécuter

Par exemple:

exécuter

exécuter tous

exécuter le serveur

exécuter server.myMainStatemachine

diffuser et envoyer l'événement :

• chaîne d'événement de diffusion
• envoyer EventString à l'instance
• envoyer EventString (équivalent à diffuser EventString)

Par exemple:

diffusion Événement1

envoyer l'événement 1 au client

Commande dump :

• décharge
• vidage d'instance

Par exemple:

décharge

serveur de vidage

vider le client

Commande eval :

• évaluer l'instance.variableName

Par exemple:

évaluer client.requestCnt

évaluer le serveur.responseCnt

Commande de sortie :

• sortie

Format de l'EventString :

• EventName.SignalName(liste d'arguments)

Note : la liste des arguments doit correspondre aux attributs définis dans le signal par ordre .

Par exemple, si le signal définit deux attributs :

• foo

• bar

Alors ces EventStrings sont valides :

• Événement1.Signal1(10, 5) --------- foo = 10; bar = 5
• Event1.Signal1(10,) --------- foo = 10; bar n'est pas défini
• Event1.Signal1(,5) --------- bar = 10; foo n'est pas défini
• Event1.Signal1(,) --------- foo et bar ne sont pas définis

Si le signal ne contient aucun attribut, nous pouvons simplifier l'EventString comme suit :

• Nom de l'événement