Le simulateur dans le navigateur
Le simulateur dans le navigateur vous montre votre modèle en marche avant d’installer quoi que ce soit d’autre. Il exécute le comportement d’un modèle sur une horloge virtuelle, en JavaScript pur. Ce comportement, ce sont les machines à états, les corps ```arche, les messages sur les liens et les threads périodiques d’un déploiement.
Une première exécution#
Enregistrez ce modèle sous main.arche. Un clignoteur passe d’un état à
l’autre toutes les 500 ms et envoie chaque fois un message à la LED.
message BLINK { on: bool }
component Blinker "Blinker" {
out led: data sends BLINK
var blinks: int32 = 0
states {
state Off {
on-enter ```arche
send led BLINK { on: false }
```
}
state On {
on-enter ```arche
blinks += 1
send led BLINK { on: true }
```
}
Off -> On on "after 500ms"
On -> Off on "after 500ms"
}
}
component Led "LED" {
in pin: data receives BLINK {
handler BLINK -> show
}
var lit: bool = false
fn show(on: bool) ```arche
lit = on
```
}
system Desk {
part blinker: Blinker
part led: Led
blinker.led -> led.pin
}Exécutez-le pendant une seconde :
$ archec sim main.arche --for 1s
Desk — system Desk, 1.000 s simulated
0.000 ms blinker: Off
0.000 ms blinker.led → led.pin BLINK {"on":false}
500.000 ms blinker: Off → On
500.000 ms blinker.led → led.pin BLINK {"on":true}
1.000 s blinker: On → Off
1.000 s blinker.led → led.pin BLINK {"on":false}
3 message(s), 3 state change(s)
at 1.000 s: blinker Off
Chaque ligne est un événement : son instant, puis ce qui s’est passé. Le même modèle donne toujours la même trace.
Pour le regarder plutôt dans un navigateur, écrivez une page et ouvrez-la :
$ archec sim main.arche --html sim.html
✓ sim.html — Desk: 2 part(s), opens in any browser, nothing to install
Ouvrez sim.html et appuyez sur Play.
Où il s’exécute#
Le simulateur s’exécute à quatre endroits. Tous les quatre utilisent le même code.
| Où | Comment |
|---|---|
| Un terminal | archec sim main.arche affiche la trace |
| N’importe quel navigateur | archec sim main.arche --html sim.html écrit une page qui l’exécute : ouvrez-la, appuyez sur Play |
| VS Code | le bouton ▶ Run du panneau de diagramme, ou Arche: Simulate in Diagram (arche.sim.run), ou ▶ Simulate au-dessus d’un system |
| L’Arche Store | un paquet dont le modèle fait quelque chose a un lien Try it : il s’exécute dans le navigateur du visiteur |
Arche a son propre simulateur (archec test, archec run). C’est la
référence. Il exécute le Python du modèle et compte pour chaque corps son
wcet (son temps d’exécution au pire cas). Il modélise les processeurs, les
bus et les pannes, et il vérifie les plans de test. Le simulateur dans le
navigateur sert à jeter un coup d’œil rapide. Il n’y a rien à installer, et
vous voyez chaque étape.
La trace sous forme de données#
--json donne la même trace sous forme de données. Chaque événement a son
instant t en nanosecondes et son kind :
kind |
Ce que c’est | Ses champs |
|---|---|---|
send |
un message envoyé | from et to sous la forme part.port, msg, payload, arrive |
state |
un changement d’état | part, from, to |
ignored |
un message dont la part n’avait que faire dans son état courant | |
drop |
un message envoyé sur un port relié à rien | |
log |
une ligne de log | |
note |
quelque chose qui n’est pas simulé (signalé une fois) | |
error |
une division par zéro, ou une boucle qui n’attend jamais |
Pour demander pourquoi une chose s’est produite pendant une exécution, ou pourquoi elle ne s’est jamais produite, voir why.md. Ses commandes exécutent le simulateur dans un mode qui garde davantage : ce qui a causé chaque événement, la transition prise à chaque changement d’état, les valeurs lues par chaque garde et chaque changement d’une variable. Une exécution ordinaire n’en garde rien, et sa trace reste comme ci-dessus.
Ce qu’il simule#
- Les parts et les liens. Il exécute chaque part du système. C’est le
système du déploiement actif, ou à défaut le premier système qui fait
quelque chose.
--systemen désigne un autre. Un message envoyé sur un port atteint chaque port qui y est relié. Il traverse les composites et les ports délégués (port out = mcu.i2c). Il arrive après lalatencydes liens. - Une seule chose à la fois par part. Une part peut être occupée, par
exemple dans un
wait. Un message qui arrive à ce moment attend son tour, comme dans Arche. - Les machines à états. Une machine démarre dans son état initial, et le
on-enterde cet état s’exécute à l’instant 0. Un message déclenche la première transition dont la garde est vraie. Cette transition peut partir de l’état courant, d’un état qui l’englobe, ou de*. Puison-exits’exécute, puis l’action, puis la machine entre dans le nouvel état et exécute sonon-enter.- Un état composite entre dans son enfant initial.
- Un
pseudo choiceprend sa première transition dont la garde est vraie. on "after 500ms"se déclenche quand l’état a duré ce temps-là.- Une garde peut lire les champs du message qui l’a déclenchée :
Answered -> Waiting on PING [n > 2].
- Les corps dans le langage d’action. Tout le langage d’action est traduit
en JavaScript.
waitsuspend le corps.gotofait changer d’état la machine. Un entier divisé par un entier donne un entier. - Les corps en Python. Le Python qui ne dit que ce que le langage d’action
peut dire est traduit en JavaScript :
self.x = …,await wait(ms(2)),send(self.p, M(k=v)),await goto("S"). C’est la même traduction que celle d’archec gen, et elle s’exécute aussi dans le navigateur. Les listes de taille fixe, les compréhensions surrange,sum/min/max,a if c else b,//et%sont traduits aussi (spec.md). - Le Python que le langage d’action ne sait pas dire s’exécute comme du vrai Python : une liste qui grandit, un dict, un grand entier, un appel de bibliothèque, une exception, une classe. Voir Les corps en Python plus bas.
- Les corps en TypeScript. Tout le TypeScript s’exécute, comme Arche
l’exécute (handlers.md). Ses types sont retirés.
selfest la part etmsgle message qui a déclenché le corps. L’API d’Arche est disponible :await wait(ms(2)),send(self.p, M({ k: v })),reply(…),await goto("S"),await self.f(x), etrand()avec sa graine. Dans un composant TypeScript, une garde peut elle aussi être en TypeScript :[msg.force > 0 && !self.open]. - Ce qui déclenche les choses.
fn mains’exécute dès l’instant 0, dans son propre thread.- Le thread d’un déploiement qui a une
periodet unstepappelle cette fonction une fois par période. Le premier appel a lieu au bout d’une période. - Le
on-received’un port et ses handlers s’exécutent à l’arrivée d’un message. Un handler s’écrithandler MSG -> fn. Ses paramètres sont pris dans les champs du message par nom, ou à défaut dans l’ordre.
- Les capteurs et les actionneurs.
- Le port de sortie d’un capteur ajoute son
noiseà ce qu’il envoie. Ensuite, il sature la valeur à larangedu champ et l’arrondit à saresolution. - Le port d’entrée d’un actionneur borne sa commande à la
rangedu champ. Sa sortie suit la commande à travers songain, sonlaget saforce-range. La trace montre une lignedriveà chaque commande, et la page affiche une courbe. - La
latencyd’un port s’ajoute à celle de ses liens. - Le bruit est tiré d’une graine :
--seed, sinonsimulation { seed }, sinon 1. Chaque exécution est donc identique, et le Reset et le curseur de temps de la page rejouent les mêmes tirages (spécification).
- Le port de sortie d’un capteur ajoute son
- Les appareils du store. Un appareil qui n’a pas de code à lui fait ce
que fait son interface : un BME280 lit une température qui dérive autour de
21 °C avec son bruit, un servo tourne à sa vitesse, un relais se ferme et le
dit dans la trace.
part.op(…)sur un lien vers un appareil l’exécute (voir Les capteurs selon ce qu’ils font). Le monde autour d’un appareil est une variable de la part :air.temperature,door.pressed. - Les keyframes. Une keyframe est un point de départ enregistré du
système.
--keyframe raiseddémarre depuis la keyframeraised: les variables de ses parts et les commandes de ses actionneurs. La position et la vitesse d’une articulation, d’une balle ou d’un corps libre relèvent de la plant.
Ce qu’il ne simule pas#
Le simulateur le dit au lieu de deviner. Chaque point ci-dessous est listé
sous « not simulated » dans le terminal, dans la page et dans VS Code. C’est
aussi une note dans la trace au moment où il se serait exécuté.
- Les corps en Python, là où aucun Python n’est là pour les exécuter : dans le ▶ Run de VS Code, et dans une page qui n’a pas pu charger Pyodide. La fonction ne fait rien et renvoie le zéro de son type, et la trace le dit une fois.
- Le TypeScript qui appelle ce que seul le simulateur d’Arche exécute :
recv,select,call, les verrous, les bits, les flux, les temporisateurs,wait_until,clock. Le corps s’arrête avec une erreur qui le dit.Math.randometDatel’arrêtent aussi, car une exécution doit se rejouer à l’identique. - Un déclencheur qui n’est ni un message ni
"after …", commeon boot_doneouon "self test passed". Rien dans la simulation ne le déclenche. Dans Arche, une étape de test ou legotod’une autre part le ferait. - Le temps d’exécution (
wcet), les processeurs et leur ordonnancement, les bus et leur débit, les pannes, les plants et les FMU, la mémoire et les signaux. Le simulateur d’Arche s’en charge. Un plan de test ne s’exécute ici qu’avec--test: sesat,within,neveretalways, pas ses pannes.
À quel point il est proche du simulateur d’Arche#
- Sur
examples/live, les deux simulateurs donnent les mêmes messages avec les mêmes contenus, et les mêmes changements d’état dans le même ordre. Seuls les instants diffèrent, des temps d’exécution que compte Arche. test/websim.test.js le vérifie quand arche-cli se trouve à côté du dépôt. - Un modèle peut avoir son comportement en TypeScript ou en Python :
examples/ts-handlers, et chaque modèle de projet avec ses corps ```arche
réécrits dans chaque langage. Chaque version donne la même trace dans
archec sim, les mêmes verdicts face à sa plant MuJoCo, et les mêmes verdicts dans le simulateur d’Arche. test/tsreach.test.js les exécute tous. - Une transition temporisée comme
Braking -> Released on "after 25ms"est prise par les deux simulateurs, quel que soit le langage des handlers. Elle est écrite dans le projet Arche sous la formetrigger: after 25ms. Elle se déclenche une fois le délai écoulé dans son état. Le délai repart à zéro quand l’état est de nouveau atteint, et il est annulé quand on quitte l’état.
Les corps en Python#
Un corps en Python que le langage d’action ne sait pas dire s’exécute dans un vrai Python.
archec simlance un seulpython3pour l’exécution. Chaque appel est synchrone : le simulateur attend sa réponse, comme il attend un corps- La page (
--html) et le Try it du store chargent Pyodide 0.29.3 depuis cdn.jsdelivr.net, seulement quand le modèle a de tels corps. Pyodide charge aussi les paquets que le code importe, quand il les a (numpy, sympy, scipy, pandas…). S’il ne peut pas se charger, la page dit quelles fonctions ont besoin du terminal.
Ce modèle garde une liste dans une part et envoie sa somme :
project "Squares" {
handlers python
}
message TICK { n: int32 }
component Counter {
out tx: data sends TICK
var n: int32 = 0
fn main ```python
while self.n < 3:
await wait(ms(10))
self.n += 1
send(self.tx, TICK(n=self.n))
```
}
component Sink {
in rx: data receives TICK {
handler TICK -> got
}
var items: any = []
fn got(n: int32) ```python
self.items.append(n * n)
print("sum", sum(self.items), "big", 2 ** 70 + n)
```
}
system Desk {
part counter: Counter
part sink: Sink
counter.tx -> sink.rx
}$ archec sim main.arche --for 40ms
Squares — system Desk, 40.000 ms simulated
Run in Python (the action language can't say them):
sink.got (line 24: ** other than ** 2 and ** 0.5)
10.000 ms counter.tx → sink.rx TICK {"n":1}
10.000 ms sink: sum 1 big 1180591620717411303425
20.000 ms counter.tx → sink.rx TICK {"n":2}
20.000 ms sink: sum 5 big 1180591620717411303426
30.000 ms counter.tx → sink.rx TICK {"n":3}
30.000 ms sink: sum 14 big 1180591620717411303427
Ce qu’un corps en Python peut faire :
- Tout ce que fait Python.
selfest la part : ses variables, ses ports (self.tx), ses fonctions (await self.fib(10)), sonstate. - L’API d’Arche :
await wait(…),await goto("S"),send(port, MSG(f=v)),log(…),now(),rand(),ms(…)et le reste defrom arche import *.printdonne une ligne de log.reply(…)ne fait rien : ici, aucun appelant ne l’attend. - Un fichier
code "x.py"est chargé comme un module. Ses imports, ses fonctions d’aide et ses classes sont là, et un def s’exécute tel quel. Un def sansselfest une fonction ordinaire :def gcd(a, b)se lie àfn gcd(a: int64, b: int64). - Une garde ou l’action d’une transition en Python s’exécute de la même façon, dans un composant écrit en Python.
Chaque exécution est identique :
random(et celui de numpy, quand le code l’importe) reçoit la graine de l’exécution (--seed, sinonsimulation { seed }, sinon 1).- L’horloge est l’horloge simulée :
time.time(),time.monotonic(),time.perf_counter()etdatetime.now()lisent le temps simulé, depuis le 1970-01-01.time.sleep()ne fait rien.input()échoue.
Quand ça se passe mal :
- Une exception donne une ligne
errordans la trace, avec la ligne du corps :ZeroDivisionError: division by zero (b.f, line 6). - Chaque appel a un délai maximal : 5 s, ou
--py-timeout 10s. Au-delà,python3est arrêté et l’appel échoue. L’appel suivant lance un nouveaupython3, sans ce que l’ancien gardait. - Un module manquant donne la commande pip qui l’installe.
Ce que le langage d’action ne sait pas dire#
archec sim liste ces corps une fois, avant la trace : chaque fonction, hook,
garde ou état, avec sa ligne et ce qu’il contient que le langage d’action ne
sait pas dire. counter.main ci-dessus n’est pas dans la liste : son Python
se traduit.
Sans Python pour les exécuter, ils ne sont pas simulés : chacun renvoie la
valeur par défaut de son type (0, false, une liste vide), et la trace
continue. C’est le cas avec --no-python, et quand il n’y a pas de python3
(dit une fois, au début) :
$ archec sim main.arche --for 40ms --no-python
Squares — system Desk, 40.000 ms simulated
Not simulated (Python the action language can't say):
sink.got (line 24: ** other than ** 2 and ** 0.5)
10.000 ms counter.tx → sink.rx TICK {"n":1}
20.000 ms counter.tx → sink.rx TICK {"n":2}
30.000 ms counter.tx → sink.rx TICK {"n":3}
Un cas de test ne réussit jamais sur une telle valeur par défaut. Sur le
simulateur du navigateur (archec test --sim web, archec sim --test), un cas
dont l’exécution atteint un corps qu’aucun Python n’a exécuté est
inconclusive (non concluant), et l’exécution sort avec le code 1 :
INCONCLUSIVE TP-MED/TC-MED-01 The median of three
inconclusive: `ctrl.got` is Python the action language can't say, and no Python ran it (install python3, or say which with --python; or archec test without --sim web, in Arche)
1/2 passed on the browser simulator, 0 failing, 1 inconclusive, 0 known failure(s)
Un cas non concluant ne vérifie aucune de ses exigences, et n’en fait échouer
aucune (.archec/test-results.json dit inconclusive). Avec python3, le
même cas exécute son Python et réussit ou échoue selon ce qu’il calcule.
La trace --json a la liste sous gaps (where, why, line, et file
pour un fichier .py), python (s’ils se sont exécutés), et un événement
note avec gap là où un corps qui ne s’est pas exécuté a été atteint.
archec check le dit aussi, par une indication (not-simulated) sur chacun de
ces corps, dans un projet qui simule (un bloc simulation ou un plan de test).
Le ▶ Run de l’éditeur n’a pas de Python : là, ils ne sont pas simulés.
Les valeurs#
| Python | Dans le simulateur | Son type dans le modèle |
|---|---|---|
int jusqu’à 2^53 |
un nombre | int32, int64… |
un int plus grand |
{"$int": "1180591620717411303425"}, exact |
any |
float, nan, inf |
un nombre, {"$float": "nan"} |
float64 |
str, bool, None |
une chaîne, un booléen, null |
string, bool |
list, tuple |
un tableau (un tuple revient sous forme de liste) | T[] ou any |
dict à clés chaînes |
un objet | une struct, ou any |
un autre dict, un set, bytes, complex |
{"$dict": [[k, v], …]}, {"$set": […]}, {"$bytes": "hex"}, {"$complex": [re, im]} |
any |
| tout le reste : un objet, un générateur | une poignée, {"$ref": 3, "repr": "Node[1, 2]"} |
any |
Une poignée reste dans Python. Quand elle revient à Python, c’est le même
objet. Une var tree: any peut donc garder un arbre Python d’un appel au
suivant.
Python et ses paquets#
archec sim exécute, dans l’ordre :
--python <path>, ouARCHE_PYTHON(--no-python: aucun) ;.venv/bin/pythondans le dossier du modèle (ou un dossier au-dessus) ;python3, ou unpython3.Nplus récent dans le PATH quand le modèle en demande un (pip "python>=3.14").
Un composant dit ce dont son Python a besoin avec pip :
pip "numpy>=1.26", "sympy". Une fonction, le projet ou une bibliothèque
peuvent le dire aussi. archec sim le vérifie et affiche la commande pour ce
qui manque. Il n’installe rien :
note: the Python bodies need sympy>=1.12, which /usr/bin/python3 does not have. Install it:
/usr/bin/python3 -m pip install 'sympy>=1.12'
or in a venv beside the model, which archec sim then uses: /usr/bin/python3 -m venv .venv && .venv/bin/pip install 'sympy>=1.12'
Un Python plus ancien exécute aussi du code écrit pour 3.14 :
except A, B: est lu comme except (A, B):, et les annotations sont lues
tard, comme les lit 3.14.
Doctests#
archec sim main.arche --doctest exécute les doctests de chaque fichier .py
que nomme le modèle (code "x.py"), dans le même Python que la simulation :
avec la graine, sur l’horloge simulée, avec un délai maximal par fichier
(30 s, ou --py-timeout). --json donne les fonctions de chaque fichier avec
leurs exemples et leurs échecs.
$ archec sim main.arche --doctest
- counter.py: no doctest
✓ maths.py (2 function(s), 3 example(s))
2 of 2 file(s) pass, 3 of 3 example(s)
Simulation seulement#
Un composant dont le Python ne peut pas s’exécuter sur un microcontrôleur dit
simulation-only (une fonction peut le dire aussi). Il s’exécute dans
archec sim, dans le simulateur d’Arche et dans un processus hôte. Le
vérificateur avertit quand un déploiement le place sur un microcontrôleur
(simulation-only). archec gen --target c, cpp, embassy et go
n’écrivent alors rien :
note: --target c refuses deployment OnMcu: 'maths' runs on thread t, on mcu (os freertos), but it is `simulation-only`: its Python runs only in simulation and on a host. Run it in a process on a processor with `os linux`, or in the simulator (`archec sim`); or leave it out of this deployment
Sur un processeur avec os linux, linux-rt ou qnx (ou un runtime de
conteneurs), il est gardé.
Face à une plant#
Une plant est une simulation du monde physique que pilote le modèle.
archec sim main.arche --plant mujoco/plant_bridge.py exécute le modèle face
à une plant qui tourne dans un autre processus. Ce peut être la plant MuJoCo
qu’écrit archec gen --target mujoco (voir MuJoCo). Ce
peut aussi être n’importe quelle commande qui parle les mêmes lignes JSON.
Le modèle et la plant avancent en même temps, une période à la fois. La plant fixe la période. À chaque période :
- Les messages des capteurs de la plant arrivent, comme si leurs parts les
envoyaient le long de leurs liens. La trace les montre chacun comme un
input. - Le modèle exécute une période.
- Les messages que le modèle a envoyés aux actionneurs de la plant repartent. Chacun s’applique à partir de son instant d’arrivée.
La plant lit et agit comme le dit le modèle : noise, latency, la plage de
commande, lag, etc. MuJoCo et le pont le font, à partir de la même graine.
La plant démarre depuis --keyframe quand il est donné.
Plans de test sans plant#
archec sim main.arche --test exécute les cas des plans de test sur le
simulateur seul, par périodes de 10 ms, avec les mêmes at, within, never
et always que ci-dessous. Le Python que le langage d’action ne sait pas dire
s’exécute dans python3, un seul pour l’exécution, relancé pour chaque cas ;
un cas qui l’atteint sans Python est non concluant
(plus haut). C’est ainsi qu’un
scénario appuie sur un bouton ou réchauffe l’air autour d’un capteur du
store :
test-plan TP "The greenhouse" {
case TC-WARM "The air warms: the fan runs" {
at 2s do air.temperature = 30
at 3.5s expect fan.closed
}
}
Pour voir l’exécution d’un tel cas sous forme de chronologie, et expliquer n’importe lequel de ses événements, voir why.md.
Plans de test face à une plant#
--test exécute les plans de test du modèle face à la plant. Chaque cas est
une exécution à part, avec une nouvelle plant, aussi longue que sa
chronologie. Un cas lit les variables et les états des parts. Un contrôleur
doit donc garder ce qu’il a mesuré dans une variable, comme controller.q1 :
test-plan TP-ARM "The arm reaches its poses" {
case TC-ARM-STEP "A second pose" {
at 2s do controller.target_shoulder = -0.4
at 4s expect abs(controller.q1 + 0.4) < 0.02
at 4s expect never: controller.error > 1.5
}
}
| Moment | Ce qu’il fait |
|---|---|
at T do part.var = v |
fixe la variable à T |
at T do send(part.port, MSG(f=v)) |
envoie le message depuis ce port à T, le long de ses liens |
at T expect c |
c est vrai à T (après ce que la plant a envoyé à T) |
within D expect c |
c est vrai à un moment, jusqu’à D après le dernier at |
at T expect never: c |
c n’est jamais vrai entre le at précédent et T, à chaque période |
at T expect always: c |
c est vrai tout du long |
Une condition s’écrit en Python, comme l’écrit le plan de test. Elle peut
utiliser part.var, part.state, les constantes du modèle, des nombres et
des chaînes, and or not, et abs min max round. Une comparaison en chaîne
comme a < x < b est refusée.
Un cas qui échoue dit ce qui n’était pas vrai, quand, et les valeurs lues. Un
cas qui ne peut pas s’exécuter dit pourquoi, par exemple un nom qu’il ne sait
pas lire ou une fault. --json donne les cas avec chaque vérification. Les
plants sont testées de cette façon.
$ archec sim main.arche --plant out/mujoco/plant_bridge.py --test
Test cases against out/mujoco/plant_bridge.py
✓ TP-ARM TC-ARM-REACH Reach the first pose (2.000 s)
✓ TP-ARM TC-ARM-HOLD Hold it (3.000 s)
✓ TP-ARM TC-ARM-STEP A second pose (4.000 s)
3 of 3 case(s) passed
La page#
archec sim main.arche --html sim.html écrit un seul fichier qui contient
tout : le programme de simulation, les données de ses commandes (JSON), le
runtime, le simulateur en direct et le lecteur. Il ne télécharge rien, sauf si
le modèle a des corps en Python : il charge alors Pyodide. Il
marche donc depuis un fichier, hors ligne, ou sur n’importe quel hébergement
statique.
Le modèle s’exécute dans la page, en direct. Comme dans le visualiseur de MuJoCo, vous pouvez l’arrêter, avancer pas à pas, le ralentir et agir dessus :
- Play / Pause (espace).
- Step (→) passe à l’événement suivant.
- Step by (Maj+→) avance d’une durée fixe. ← recule d’autant.
- Reset (R) repart du début, sans rien d’envoyé.
- Speed va de 0,1× à 10× (+ et −). À 1×, la plus courte période ou le plus court délai du modèle dure une seconde. Un réseau physique seul avance d’une seconde par seconde. L’info-bulle du curseur indique ce que vaut 1×.
- Time est un curseur sur ce qui s’est exécuté. Début ramène à 0.
- Revenir en arrière rejoue l’exécution jusqu’à cet instant, avec ce que vous avez envoyé aux instants où vous l’avez envoyé. C’est donc la même exécution, et repartir en avant rejoue la même chose.
- Envoyer quelque chose alors que vous êtes revenu en arrière lance une nouvelle exécution à partir de là. Ce que vous aviez envoyé après cet instant est abandonné.
- Envoyer un message. Chaque port d’entrée d’une part qui fait quelque
chose a un formulaire. Il liste les messages que le port reçoit : ses
receiveset ses handlers, ou à défaut les déclencheurs de sa machine. Chaque champ est une commande : un nombre avec sa plage (celle écrite, ou celle de son type), une case à cocher, les valeurs d’une enum, ou les champs d’un enregistrement. La valeur est vérifiée avant l’envoi. Send now place le message sur le port à l’instant courant, comme l’apporterait un lien, après ce qui s’est passé à cet instant. La trace le montre sous la formeyou → part.port. - Pousser. Un réseau physique est fait de ports qui ont un
potentialet unflow(archec physics). Quand le système en contient un, la page l’intègre en même temps que les événements, avec RK4 au pas de sonsolver. Vous pouvez pousser ses sources : le paramètre d’une source de tension, de courant, de pression ou de chaleur, une force, un couple, ou une température fixée. Vous pouvez aussi pousser ses signauxinreliés à rien. Une poussée est un échelon (ajouté à partir de maintenant) ou une impulsion (ajoutée pendant la durée donnée). - Courbes. Vous pouvez tracer n’importe quel état (en marches d’escalier, avec ses états sur l’axe), n’importe quelle variable numérique, n’importe quel champ de message (la dernière valeur envoyée ou reçue) ou n’importe quelle grandeur physique. Chaque courbe avance en direct de 0 à maintenant. La page démarre avec les premiers états du réseau, ou à défaut la première machine à états et la première variable.
- Chaque message est un point qui se déplace le long de son lien. Chaque part affiche dans sa boîte son état et ses premières variables. La trace défile à droite.
--forfixe la durée de l’exécution. Par défaut, 10 s.
Dans la console de la page, le simulateur en direct est window.archeSim. Par
exemple : archeSim.inject('pong', 'rx', 'PING', { n: 7 }),
archeSim.stepBy(10e6), archeSim.series.
Dans VS Code#
Le bouton ▶ du panneau de diagramme, ou Arche: Simulate in Diagram, exécute en direct le système du modèle courant. Il s’exécute dans l’extension ; la webview n’évalue rien. Il se joue sur le diagramme que vous avez déjà : des points se déplacent le long des liens dessinés, chaque bloc affiche son état, et un diagramme de machine à états allume l’état courant.
À côté du diagramme se trouvent les mêmes commandes que dans la page :
- pause (espace), l’événement suivant (→), un pas d’une durée fixe (Maj+→ ; ← recule d’autant), la remise à zéro (R), la vitesse (+ / −) ;
- l’horloge, le curseur de temps (Début : retour à 0) et l’arrêt.
☰ ouvre les autres commandes : envoyer un message, pousser, les courbes et les touches. Il s’ouvre tout seul quand le modèle a un port d’entrée ou un réseau physique. La trace part dans la sortie Arche Simulation au fil de l’exécution. Modifiez le modèle et appuyez de nouveau sur ▶ pour exécuter le nouveau.
Dans le store#
archec store site donne un lien Try it à chaque paquet dont le modèle
fait quelque chose. Le lien est p/<owner>/<name>.sim.html. C’est la même
page, construite à partir du modèle du paquet. Un visiteur la voit
s’exécuter sans rien installer.