Exemple : Commandes de Simulation

Cet exemple montre comment nous pouvons utiliser la fenêtre Simulation pour observer les messages Trace ou envoyer des commandes pour contrôler une Statemachine . À travers l'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 le cadre du contexte pour tous les comportements d' State et 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' pour vider le compte actif de l'état actuel ; il peut également vider l'événement en cours 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 une 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 Class appelé TransactionServer.
2. Dans cette classe, créez un attribut appelé allowCnt avec la 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. Passage à un State dit inactif .
3. Transition vers un State appelé occupé , avec le déclencheur NEW_REQUEST.
4. Transition:
   - Vers un pseudo-état Final appelé Final , avec le trigger QUIT
   - Retour au ralenti , 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 occupé.
2. Changez le 'type' de la transition en 'interne'.
3. Spécifiez le déclencheur comme étant l'événement que vous souhaitez différer.
4. Dans le champ 'Effet', tapez '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 with Deferred Event.
2. Ctrl+Faites glisser l'élément TransactionServer depuis la fenêtre du Navigateur et déposez-le sur l'Artefact en tant que propriété, avec le nom du serveur.
3. Définissez le langage 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 prennent également en support Statemachines Exécutables ).
4. Cliquez sur l'Artefact et sélectionnez l'option de ruban 'Simuler > États Statemachine États Exécutables Générer , Build et Exécuter '.

Fenêtre de Simulation et commandes

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

La fenêtre Simulation indique que le comportement Transition Effect, Entry et Do est terminé pour l'état idle et que la Statemachine attend un déclenchement.

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

Pour l'événement de signal déclencheur NEW_REQUEST, la boîte de dialogue 'Trigger Parameter Entry' s'affiche pour prompt des valeurs pour les attributs répertoriés définis dans 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 appelées telles que les comportements de State et les effets de Transition.

Ces messages sont sortis dans la fenêtre Simulation :

[03612562] Attente de déclenchement

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

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

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

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

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

[03611390] [server:TransactionServer] Comportement d'entrée : ServerStateMachine_busy

[03611398] [server:TransactionServer] Faire Comportement : ServerStateMachine_busy

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

[03612562] Attente de déclenchement

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

[03612562] Attente de déclenchement

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

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

[04461081] Attente de déclenchement

Le message Simulation indique que l'occurrence de l'événement est différée (Event Queued, but not dispatched). Nous pouvons exécuter d'autres commandes en utilisant le champ de texte :

[04655441] En attente de déclenchement

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

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

[04664803] En attente de déclenchement

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

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

[04670312] En attente de déclenchement

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

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

[04674838] En attente de déclenchement

dump : Query "nombre d'actifs" pour un pool d' State et d'événements

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

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

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

Dans la section 'Event Pool', nous pouvons voir qu'il y a quatre occurrences d'événements dans la file d'attente d'événements. Chaque instance du signal transporte des données différentes.

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

eval : valeur temporelle de l' Exécuter de Query du contexte

Gâchette AUTORISÉE,

[04817341] En attente de déclenchement

[05494672] Commande : diffusion AUTORISÉE

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

[05494680] [server:TransactionServer] Événement envoyé : AUTORISÉ

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

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

[05494687] [server:TransactionServer] Comportement d'entrée : ServerStateMachine_idle

[05494688] [server:TransactionServer] Faire Comportement : ServerStateMachine_idle

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

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

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

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

[05495847] [server:TransactionServer] Comportement d'entrée : ServerStateMachine_busy

[05495850] [server:TransactionServer] Faire Comportement : ServerStateMachine_busy

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

[05496367] En attente de déclenchement

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

[05693348] Groupe 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 temporelle exécutée de ' exécuter ' est 1.

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

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

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

Pour C et C++, la syntaxe diffère de C# , Java et JavaScript dans l'accès 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 :

this.variableName

Exemples:

Dans l'effet de transition :

this.authorizeCnt++;

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

this.foo += this.bar;

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

this.foo = this.bar + myObject.iCount + myPointer->iCount ;

sera traduit en :

this->foo = this->bar + myObject.iCount + myPointer->iCount ;

Une liste complète des commandes prises en charge

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

exécuter d'état Statemachine :

Comme chaque contexte peut avoir plusieurs Statemachines , la commande ' exécuter ' peut spécifier une Statemachine pour commencer.

• exécuter exemple. statemachine
• exécuter
• exécuter exemple
• tout exécuter
• exécuter

Par exemple:

exécuter

tout exécuter

serveur exécuter

exécuter

diffuser et envoyer l'événement :

• diffuser EventString
• envoyer EventString à l'instance
• envoyer EventString (équivalent à diffuser EventString)

Par exemple:

diffuser l'événement1

envoyer Event1 au client

commande de vidage :

• décharger
• instance de vidage

Par exemple:

décharger

serveur de vidage

vider le client

Commande eval :

• eval instance.variableName

Par exemple:

eval client.requestCnt

eval server.responseCnt

Commande de sortie :

• sortir

Le format de l'EventString :

• EventName.SignalName(liste d'arguments)

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

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

• fou

• bar

Alors ces EventStrings sont valides :

• Event1.Signal1(10, 5) --------- foo = 10 ; barre = 5
• Event1.Signal1(10,) --------- foo = 10 ; la barre n'est pas définie
• Event1.Signal1(,5) --------- barre = 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 EventString en :

• Nom de l'événement