Correspondance entre arche-lang et Arche
Arche est l'outil de modélisation visuelle vers lequel arche-lang compile.
archec build transforme vos fichiers .arche en projet Arche : un dossier de
fichiers YAML qu'Arche sait ouvrir. Cette page indique ce que devient chaque
déclaration dans ce dossier.
Une première compilation#
Enregistrez ceci sous main.arche :
message PING "Ping" { field seq: uint8 }
component Sensor "Sensor" {
out data: data sends PING
}
component Logger "Logger" {
in data: data receives PING
}
system Bench "Bench" {
part sensor: Sensor
part logger: Logger
sensor.data -> logger.data
}Compilez-le :
archec build main.arche
✓ 9 files → arche-out (bench.yaml, models.yaml, templates.yaml, messages.yaml, types.yaml, colors.yaml, simulation.yaml, menu.yaml, layout.yaml)
open with: arche --project /path/to/arche-out
Le système Bench est devenu le fichier de modèle bench.yaml. Il contient les
deux parts sous forme de composants, avec leurs ports, et le lien qui les
relie :
components:
- id: sensor
template: box
name: Sensor
ports:
- id: data
type: data
direction: out
messages:
- PING
…
links:
- id: sensor-data-logger-data
from: sensor.data
to: logger.data
Les composants Sensor et Logger sont devenus des templates dans
templates.yaml, et le message est parti dans messages.yaml.
Ce que devient chaque déclaration#
| arche-lang | Projet Arche |
|---|---|
system X { … } |
fichier de modèle x.yaml (listé dans models.yaml) ; ses enfants sont les composants racines du canevas |
component D de premier niveau |
un template dans templates.yaml, copié dans chaque part x: D (les valeurs de l'instance l'emportent, les listes fusionnent par id) |
port, fn, var, memory, states, requirement imbriqué |
ports, functions, variables, memory, stateMachine, requirements sur le composant |
a.p -> b.q { carries M; latency 1ms } |
links avec icd.messages et timing |
canvas X { part at x, y; part size w, h } (ou at sur une part) |
la position et la size de chaque composant |
purpose "…" |
les mainFunctions du composant |
message, type/enum/struct, const |
messages.yaml, data-types.yaml, variables.yaml |
requirement, actor, mission |
requirements.yaml, actors.yaml, missions.yaml |
satisfies, verifies, derives, allocated-to, trace … |
traces.yaml, avec les adresses des éléments Arche (car.yaml#adcu:fn/plan) |
test-plan, scenario, simulation |
testplans.yaml, scenarios.yaml, simulation.yaml |
cores N, core id, os, ram, isa, freq sur un composant |
nature: hardware, cores: [{id, name, type}], hardware: {os, ram, …}. Le composant devient une cible sur laquelle tournent des threads. |
deployment → binary … on cpu → process → thread / isr |
processes.yaml et threads.yaml (tasks.yaml sur un processeur RTOS ou bare-metal). Chaque part qu'un thread runs reçoit thread:. |
period + step fn d'un thread |
un rt.timer à côté de la part. Il émet un top sur un port tick-<thread>, qui appelle fn. |
route a.p -> b.q over bus { priority 3 } |
le timing.bus et la priority du lien, et le bitrate du bus. En simulation, le bus est un support partagé. |
buffer queue + depth N + overflow, buffer sample sur un port ou un lien |
timing.queue / drop du lien. Un échantillon est une file d'un seul élément qui garde la valeur la plus récente. |
kind, layer, tag, color, port-type |
kinds.yaml, layers.yaml, tags.yaml/tag-types.yaml, colors.yaml, types.yaml. Les entrées utilisées sans être déclarées sont ajoutées pour vous. |
package p { … } |
rien en propre. Les noms sont qualifiés dans la source (p.X) ; les id restent globaux dans Arche. |
interface I { messages …; fn op() }, port provides I / requires I |
un type de port dans types.yaml, avec messages, operations et extends ; les provides / requires des ports |
part w: Wheel[4], component D(n: int32 = 8) |
quatre composants w_0 … w_3 ; les valeurs des paramètres de chaque instance, sous forme de variables |
parameter, variant (+ variants a, b), study, viewpoint |
parameters.yaml, variants.yaml (+ variants: sur les composants et les liens), studies.yaml, viewpoints.yaml |
budget power 150W |
un budget Arche : une variable avec rollup: sum (ou max), et en dessous les consommations, sous forme de variables du même nom |
hazard, safety-goal |
safety.yaml (hazards, safetyGoals). failure-mode et gate sont vérifiés et mis en page, mais pas écrits. |
decision |
une exigence de catégorie decision, avec des traces derives / satisfies |
process … { lanes …; a: act; a -> b : x } |
un scénario à une seule séquence |
equation der(x) = …, solver 1ms |
les equations et le solver du composant. Le simulateur d'Arche les intègre (RK4). |
raw "file.yaml" ```yaml …``` |
ce fichier, tel quel. Utilisez-le pour tout ce que le langage ne modélise pas encore. |
Les vérifications de chaque compilation#
Chaque compilation valide le YAML généré avec
schemas/arche-project.schema.json avant d'écrire quoi que ce soit.
L'exemple de la voiture et l'exemple des patterns se chargent tous deux dans
Arche avec 0 erreur selon le vérificateur d'Arche (arche-cli check). Leurs
plans de test passent dans le simulateur d'Arche (arche-cli test) : 3/3 pour
la voiture, 1/1 pour les patterns.
Corps de comportement#
Arche exécute le comportement en Python. Un corps peut s'écrire de deux façons :
Un corps
```archeest vérifié par archec. Il est écrit dans le projet sous la forme du Python qu'il représente :arche-lang Python wait 10msawait wait(ms(10))send p MSG { … }send(self.p, MSG(...))f()await self.f()goto Stateawait goto("State")Un corps
```pythonest écrit tel quel. Le linter ne vérifie que ce qu'il voit depuis le modèle : les appels à des fonctions sans corps et lesawaitmanquants.