Guides pratiques › Simuler dans le navigateur

Guides pratiques

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
}
Diagramme : Desk
Ce qu’archec dessine depuis ce code : Desk
Essayer

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. --system en 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 la latency des 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-enter de 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 *. Puis on-exit s’exécute, puis l’action, puis la machine entre dans le nouvel état et exécute son on-enter.
    • Un état composite entre dans son enfant initial.
    • Un pseudo choice prend 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. wait suspend le corps. goto fait 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 sur range, 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. self est la part et msg le 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), et rand() 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 main s’exécute dès l’instant 0, dans son propre thread.
    • Le thread d’un déploiement qui a une period et un step appelle cette fonction une fois par période. Le premier appel a lieu au bout d’une période.
    • Le on-receive d’un port et ses handlers s’exécutent à l’arrivée d’un message. Un handler s’écrit handler 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 à la range du champ et l’arrondit à sa resolution.
    • Le port d’entrée d’un actionneur borne sa commande à la range du champ. Sa sortie suit la commande à travers son gain, son lag et sa force-range. La trace montre une ligne drive à chaque commande, et la page affiche une courbe.
    • La latency d’un port s’ajoute à celle de ses liens.
    • Le bruit est tiré d’une graine : --seed, sinon simulation { 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).
  • 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 raised démarre depuis la keyframe raised : 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.random et Date l’arrêtent aussi, car une exécution doit se rejouer à l’identique.
  • Un déclencheur qui n’est ni un message ni "after …", comme on boot_done ou on "self test passed". Rien dans la simulation ne le déclenche. Dans Arche, une étape de test ou le goto d’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 : ses at, within, never et always, 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 forme trigger: 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 sim lance un seul python3 pour 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
}
Diagramme : Desk
Ce qu’archec dessine depuis ce code : Desk
Essayer
$ 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. self est la part : ses variables, ses ports (self.tx), ses fonctions (await self.fib(10)), son state.
  • L’API d’Arche : await wait(…), await goto("S"), send(port, MSG(f=v)), log(…), now(), rand(), ms(…) et le reste de from arche import *. print donne 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 sans self est 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, sinon simulation { seed }, sinon 1).
  • L’horloge est l’horloge simulée : time.time(), time.monotonic(), time.perf_counter() et datetime.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 error dans 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à, python3 est arrêté et l’appel échoue. L’appel suivant lance un nouveau python3, 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 :

  1. --python <path>, ou ARCHE_PYTHON (--no-python : aucun) ;
  2. .venv/bin/python dans le dossier du modèle (ou un dossier au-dessus) ;
  3. python3, ou un python3.N plus 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 :

  1. 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.
  2. Le modèle exécute une période.
  3. 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 receives et 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 forme you → part.port.
  • Pousser. Un réseau physique est fait de ports qui ont un potential et un flow (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 son solver. 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 signaux in relié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.
  • --for fixe 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.