Génération de code
archec gen écrit du code source à partir du modèle : C, Rust, C++ et d’autres
langages, mais aussi des fichiers pour d’autres outils (bases de données CAN,
AUTOSAR, AADL, conteneurs, model checkers). Vous choisissez quoi écrire avec
--target. Quand le modèle change, vous relancez la commande, et le code que
vous avez écrit autour du code généré est conservé.
Toutes les options de archec gen sont dans commands.md.
Pour écrire vos propres générateurs, voyez generators.md.
Une première génération#
Une part qui compte les messages qu’elle reçoit :
message TICK "A tick" { n: uint32 }
component Counter "Counts the ticks" {
in tick: data receives TICK {
on-receive ```arche
count += 1
```
}
var count: uint32 = 0
}
system Demo {
part counter: Counter
}Générez-en du C :
archec gen main.arche --target c -o generated
generated/c/arche_rt.h
generated/c/arche_rt_posix.c
generated/c/arche_rt_freertos.c
generated/c/arche_types.h
generated/c/arche_types.c
generated/c/counter.h
generated/c/counter.c
counter.c contient le code de la part. Le corps du handler est traduit, et les
emplacements réservés à votre code sont balisés :
/* @arche Counter.init main.arche:3 init */
void counter_init(counter_t *self)
{
self->count = 0;
/* USER CODE BEGIN Counter.init */
/* USER CODE END Counter.init */
}
/* @arche Counter.tick.on-receive main.arche:4 on-receive */
void counter_on_receive_tick(counter_t *self)
{
self->count += 1;
}
Relancez la même commande : les fichiers qui vous appartiennent ne sont pas touchés.
kept (yours): c/arche_rt_posix.c, c/arche_rt_freertos.c
Ajoutez --build pour compiler ce qui vient d’être écrit :
── cc -std=c99 -Wall -Wextra -Werror -pedantic -O2
✓ built clean
Regénérer#
- Certains fichiers sont à vous : ils sont écrits une fois, puis jamais
écrasés. C’est le cas de
app.rs,main.rsetCargo.toml. - Le code que vous placez dans une région
USER CODEest remis en place à chaque fois. Voir regénérer le code. --checkéchoue quand un fichier généré n’est plus à jour. Utilisez-le en CI.- Dans VS Code, la commande s’appelle Arche: Generate code….
Pour vérifier que le code compile sans avertissement, le passer aux linters, le tester et le relier aux exigences, voyez la qualité du code généré.
Les cibles#
La colonne « À partir de » indique ce que le modèle doit contenir pour que la cible écrive quelque chose.
| Cible | Ce qu’elle écrit | À partir de |
|---|---|---|
c |
du C99 pour microcontrôleur, sans tas | composants ; déploiement |
cpp |
du C++17 pour une cible hébergée, voir C++ | composants ; déploiement |
embassy |
du Rust pour Embassy : une crate par binaire | déploiement |
dbc |
du CAN DBC : un fichier par bus | routes du déploiement |
wire |
les codecs des messages qui précisent leur format de trame, en C, Rust, Go et Python | messages |
regmap |
des cartes de registres, voir cartes de registres | blocs memory |
vhdl |
du VHDL-2008 pour un FPGA, avec un banc de test GHDL par cas de test, voir composants FPGA | composants avec une horloge |
aadl |
de l’AADL v2, pour OSATE | déploiement |
arxml |
de l’ARXML AUTOSAR Classic | déploiement |
arxml-adaptive |
de l’ARXML AUTOSAR Adaptive | déploiement |
bom |
une nomenclature | systèmes racines (sans déploiement) |
icd |
des documents de contrôle d’interface en Markdown | systèmes racines, routes du déploiement |
containerd |
des images de conteneurs et des fichiers compose pour containerd | conteneurs du déploiement |
k8s |
des manifestes Kubernetes | conteneurs du déploiement |
ros2 |
des interfaces et des nœuds ROS 2 | données ; déploiement |
gazebo |
le procédé physique dans Gazebo | système, déploiement |
mujoco |
le procédé physique dans MuJoCo | système |
devicetree |
des overlays devicetree Zephyr | déploiement sur des cartes |
renode |
les microcontrôleurs dans Renode | déploiement |
ui-web |
les écrans du produit, sous forme d’application web | blocs ui |
freertos, zephyr, posix |
le squelette RTOS de l’application Arche | threads / tâches |
uppaal |
des automates temporisés UPPAAL et leurs requêtes | machines à états, liens, contrats |
nusmv |
des modèles NuSMV / nuXmv | machines à états |
components |
les sources des composants de l’application Arche | composants |
c-tests, trace-matrix |
des tests unitaires en C, une matrice de traçabilité, voir qualité | plans de test, exigences |
Les cibles d’intégration sont décrites dans cibles d’intégration. Les sections suivantes détaillent ce qu’écrit chacune des autres.
embassy#
Du Rust pour Embassy, une crate par binaire.
arche.rs est regénéré à chaque fois. Il contient :
- les types et les messages du modèle ;
- un
Channelpar lien, avec sondepthet sonoverflow, ou unSignalpourbuffer sample; - pour chaque part, un handle
Outet un trait de comportement ; - une tâche par thread : un
Tickerpourperiod+step, et unselectsur les entrées ; - pour chaque message routé, l’encodage, le décodage et un
BusFrame. L’identifiant CAN est l’idde la route ; spawn_all.
hal std|stm32|rp|nrf|esp32 et chip "…" sur le processeur choisissent la
HAL. Avec hal rp et des threads sur deux cœurs, le cœur 1 est démarré.
Quand le binaire est sur une carte du store et que la plateforme a des périphériques avec un
pilote Rust (un BME280, une LED, un servo…), la crate reçoit aussi src/hw/ :
mod.rs (régénéré à chaque fois : le bus I²C de la carte partagé par ses périphériques,
leurs broches, un Hardware avec un champ par périphérique, le mutex HW et la
macro start!), peripherals.rs (std/peripherals sous forme de traits embedded-hal 1.0)
et un fichier par périphérique, copié depuis le store. main.rs appelle
hw::start!(spawner, _p) et Cargo.toml reçoit les crates des pilotes. Quels
périphériques, quelles broches, et comment en ajouter un : drivers.md.
La machine à états d’une part tourne telle que le modèle l’écrit quand ses gardes, ses actions,
son on-enter et son on-exit sont dans le langage d’action. Les gardes lisent les
champs du déclencheur par leur nom ([temperature > 28.0]), et les minuteries on "after 10s"
sont armées à l’entrée dans leur état. Ce sont des méthodes de la part dans
arche.rs (arche_start, arche_on_<message>, arche_timeouts). Une garde
écrite autrement (Python, self.speed) laisse la machine à app.rs, comme
avant : un trait <Part>Guards à implémenter, et on_transition.
Avec --trace, sur une carte STM32 dont l’UART est le port COM virtuel du ST-LINK
(l’USART2 de la NUCLEO-F446RE), les lignes de trace sortent sur cet UART en
texte à 115200 bauds. Un terminal, examples/greenhouse/board.sh ou Renode
les enregistre. Sur les autres cartes, c’est du defmt sur RTT.
dbc#
Un fichier CAN DBC par bus. Chaque message routé devient une trame, et chaque champ un signal. La disposition est la même que celle du codec Embassy.
Un message peut préciser son format de trame (at, bits, scale,
byte-order…, voir la spécification). Chaque signal
occupe alors ses bits, avec son bit de départ, son ordre des octets, son signe,
son facteur et son offset.
wire#
Les codecs des messages qui précisent leur format de trame, avec leurs types :
wire/c/arche_wire.het.c: du C99, sans tas ni libm ;wire/rust/: une crateno_std;wire/go/: le packagearchewire;wire/python/arche_wire.py: des dataclasses.
L’encodage place chaque champ sur ses bits. Le décodage échoue sur une trame
trop courte, une somme de contrôle fausse ou une valeur d’enum inconnue. Les
quatre écrivent exactement les mêmes octets. --target c, embassy et go
réutilisent ce même code pour ces messages.
aadl#
De l’AADL v2, un package pour OSATE, dans aadl/<deployment>.aadl :
- des
dataavec les propriétés Data_Model, par message et par type ; - un
processorpar processeur, avec unvirtual processorpar cœur et unememorypour saram; - un
bus, avec un Transmission_Time déduit debitrate; - un
virtual processorpar conteneur, lié aux cœurs de son cpuset. Ses processus lui sont liés ; - un
processpar processus (ou par binaire s’il n’y en a pas) ; - un
threadpar thread, avec Dispatch_Protocol, Period, Deadline, Compute_Execution_Time, Priority et Stack_Size. Compute_Execution_Time vaut0 ms .. wcet, sinon le coût du step ; - des event data ports. Un port avec
buffer sampleest un data port. Queue_Size vient dedepth; - un
devicepar part liée qui ne tourne sur aucun thread ; - une connexion de ports par lien, avec une Latency tirée de
latency; - Actual_Processor_Binding vers le cœur, et Actual_Connection_Binding vers le bus de la route.
Un port qui transporte plusieurs messages est typé par leur union.
arxml#
De l’ARXML AUTOSAR Classic (R4, AUTOSAR_00049), dans
arxml/<deployment>.arxml.
Types et interfaces :
- un IMPLEMENTATION-DATA-TYPE par type et par message. Un enum devient un uint8 avec une COMPU-METHOD TEXTTABLE ;
- une SENDER-RECEIVER-INTERFACE par message.
Composants logiciels :
- un APPLICATION-SW-COMPONENT-TYPE par part dotée d’un comportement. Capteurs et matériel deviennent des composants SENSOR-ACTUATOR ;
- un P-PORT-PROTOTYPE ou un R-PORT-PROTOTYPE par port et par message ;
- des RUNNABLE-ENTITY, déclenchées par un TIMING-EVENT (
period+stepdu thread), des DATA-RECEIVED-EVENT (handlers,receives) et un INIT-EVENT (fn main) ; - le système sous forme de COMPOSITION-SW-COMPONENT-TYPE, avec un ASSEMBLY-SW-CONNECTOR par lien et par message.
Le bus CAN, pour chaque message qui y est routé :
- des I-SIGNAL selon la disposition du DBC, une I-SIGNAL-I-PDU, une CAN-FRAME et un CAN-FRAME-TRIGGERING avec l’identifiant CAN de la route ;
- les triggerings de sa PDU et de ses signaux. Une structure a aussi un groupe de signaux.
Les ECU et le système :
- une ECU-INSTANCE par processeur sur lequel tourne un thread. Elle a un connecteur CAN par bus, et un port de trame, de PDU et de signal pour chaque trame qu’elle envoie ou reçoit ;
- le SYSTEM, avec sa composition racine et le SWC-TO-ECU-MAPPING de chaque part ;
- l’élément de données de chaque message routé, mappé sur ses signaux, champ par champ pour une structure.
Le fichier est valide au regard du schéma AUTOSAR_00049.xsd d’AUTOSAR. Les
déploiements des exemples sont vérifiés avec xmllint quand AUTOSAR_XSD désigne
le schéma.
arxml-adaptive#
De l’ARXML AUTOSAR Adaptive (R20-11, AUTOSAR_00049) : quatre fichiers dans
adaptive/<deployment>/.
Design.arxml :
- les types de données, tels que
arxmlles écrit ; - une SERVICE-INTERFACE par interface qu’un port fournit ou requiert :
- ce qu’envoie son fournisseur est un EVENT ;
- ses opérations sont des METHOD, avec leurs ARGUMENT. Un résultat est un argument OUT. Une méthode sans résultat est FIRE-AND-FORGET ;
- un message que le fournisseur ne fait que recevoir est une METHOD fire-and-forget ;
- un message qu’il envoie et reçoit à la fois est un FIELD, avec getter, setter et notifier ;
- une SERVICE-INTERFACE faite d’EVENT pour chaque port Ethernet
outqui envoie sans interface ; - par processus, un ADAPTIVE-APPLICATION-SW-COMPONENT-TYPE, avec un P-PORT- ou R-PORT-PROTOTYPE par service que ses parts fournissent ou requièrent. Pour un binaire sans processus, c’est par binaire ;
- un EXECUTABLE dont ce composant est le ROOT-SW-COMPONENT-PROTOTYPE.
MachineManifest.arxml :
- un MACHINE-DESIGN (avec un ETHERNET-COMMUNICATION-CONNECTOR) et une MACHINE (avec son PROCESSOR et ses cœurs) pour chaque processeur dont le système d’exploitation n’est ni un RTOS ni du bare metal ;
- le function group machine
MachineFG(Startup, Running, Shutdown) ; - un ETHERNET-CLUSTER avec un NETWORK-ENDPOINT par machine. L’adresse est
donnée par
attr ip = "10.0.0.2"sur le processeur ou sur un binaire qu’il porte. Sans elle, les adresses commencent à 192.168.0.10.
ExecutionManifest.arxml : un PROCESS par processus de son EXECUTABLE. Il est
démarré dans MachineFG.Running avec une STARTUP-CONFIG. Celle-ci porte la
politique d’ordonnancement (fifo, rr, sinon other) et la priorité de son
thread le plus prioritaire.
ServiceInstanceManifest.arxml :
- un SOMEIP-SERVICE-INTERFACE-DEPLOYMENT par service, avec les identifiants de
--target someip: service, version, méthodes, événements, groupe d’événements. Le getter et le setter d’un field sont numérotés après les méthodes. Son notifier reprend l’identifiant d’événement du message ; - un PROVIDED- ou REQUIRED-SOMEIP-SERVICE-INSTANCE par port ;
- son SERVICE-INSTANCE-TO-PORT-PROTOTYPE-MAPPING vers le processus ;
- un SOMEIP-SERVICE-INSTANCE-TO-MACHINE-MAPPING par machine.
Un binaire sur microcontrôleur est une ECU Classic (arxml) : il est laissé de
côté. Un service qu’il fournit n’a alors pas d’instance fournie ; les notes
indiquent lesquels.
Les déploiements des exemples sont vérifiés avec xmllint par rapport à
AUTOSAR_00049.xsd quand AUTOSAR_XSD le désigne.
bom#
Une nomenclature. Aucun déploiement n’est nécessaire.
bom/bom.csva une ligne par définition, et par part qui n’en a pas. Une ligne donne ses parts, sa nature et sa quantité (les copies[n]sont comptées). Elle donne aussi chaque grandeur qu’un budget additionne :mass,power,cost,ram, et chaque nom pour lequel unbudgetest écrit. Viennent ensuite les totaux, global et par système.bom/bom.mdreprend le même tableau, avec le cumul de chaque part et de tout ce qu’elle contient.
Une grandeur donnée dans deux unités a une colonne par unité. Rien n’est converti.
icd#
Des documents de contrôle d’interface en Markdown : icd/<port-type or interface>.md et icd/<bus>.md. Chacun donne :
- les champs de chaque message : type, unité, plage, valeur par défaut, description ;
- sa disposition en octets ;
- les liens qui le fournissent et le consomment : latence, tampon, route, temps de transport ;
- sur un bus, les trames, avec identifiant CAN, période et durée de trame ;
- les types utilisés ;
- les exigences tracées vers les parts, les messages et l’interface, ou qui les nomment.
icd/index.md les recense.
containerd#
Pour containerd, via nerdctl :
containers/<container>/Containerfile: un build multi-étapes par binaire, vers une image Debian slim. Le C vient dec/<binary>et le Rust deembassy/<binary>: générez-les dans le même répertoire, qui sert de contexte de build. Quand le conteneur exécute plusieurs binaires, unentrypoint.shles démarre ;containers/<processor>/compose.yaml, pournerdctl compose up. Il fixe l’image, laplatform(d’après l’isaou lecore-typedu processeur),cpuset,mem_limit,network_mode,devices,cap_add,privileged, un ulimitrtprioà la plus haute priorité temps réel, etenvironment;containers/deploy.sh: il construit chaque image (PUSH=1la pousse) et indique quoi démarrer sur chaque processeur.
k8s#
Pour Kubernetes ou k3s, avec les images que construit
containerd.
k8s/<container>.yaml est un Deployment à un seul réplica :
- épinglé sur le nœud de son processeur : le
nodeSelectorkubernetes.io/hostnameest le nom du processeur (avec-à la place de_), etkubernetes.io/archvient de sonisa; - des
resourcesdont les requests égalent les limits, d’après la taille de son cpuset etmemory-limit. C’est la classe Guaranteed : elle obtient des cœurs exclusifs avec le CPU manager statique du kubelet ; hostNetworkpournetwork host;privilegedpourcapabilities all, sinoncapabilities.add;- chaque
devicemonté depuis l’hôte (hostPath) ; - ses props en
env.
Un conteneur avec network none reçoit une NetworkPolicy qui refuse tout.
k8s/kustomization.yaml sert à kubectl apply -k k8s. Ce que Kubernetes ne
sait pas exprimer, comme les cœurs exacts ou la latency d’un pont, devient
une note.
ros2#
- les messages, sous forme de package d’interfaces ament
ros2/(.msg,.srv) ; - avec un déploiement qui indique
packaging ros2:ros2_nodes/<binary>/, des nœuds rclcpp autour des modules C des parts (voir ROS 2), etros2_nodes/<deployment>_bringup/launch/<deployment>.launch.py.
colcon build les construit.
gazebo#
Le procédé physique d’un déploiement packaging ros2 dans
Gazebo (gz sim Harmonic), voir
Gazebo :
gazebo/worlds/<system>.sdf: capteurs, actionneurs, masses ;gazebo/config/bridge.yaml, pour ros_gz_bridge ;gazebo/scripts/sim_adapter.py;gazebo/launch/<system>_sim.launch.py.
mujoco#
Le procédé physique dans MuJoCo, voir MuJoCo :
mujoco/<system>.xml: du MJCF, avec des corps tirés demass,shapeetjointdes parts, ainsi que les capteurs et les actionneurs ;mujoco/plant_bridge.py: il fait passer les messages du modèle vers le procédé et en retour.archec sim --plantexécute le modèle face à lui.
devicetree#
Un overlay devicetree Zephyr par binaire sur le
microcontrôleur d’une carte : devicetree/<binary>/boards/<zephyr board>.overlay.
Il active chaque connecteur CAN, UART, I2C et SPI de la carte que la plateforme relie :
- sur ses broches, avec pinctrl : les nœuds
usart2_tx_pa2de hal_stm32,NRF_PSEL, les macros pinmux du RP2040 et de l’ESP32. Lespinspropres à une part l’emportent sur celles de la carte ; - au débit du lien ou du bus (
bitrate,current-speed,clock-frequency) ; - un MCP2515 sous le SPI, pour un CAN sur SPI ;
- les périphériques I2C à leur
address.
Il écrit aussi un alias par bus (arche-chassis-can) et zephyr,canbus.
prj.conf active les pilotes ; il n’est écrit qu’une fois.
Sous Zephyr, le C de --target c ouvre chaque bus CAN ou UART par cet alias :
DEVICE_DT_GET(DT_ALIAS(arche_chassis_can)) dans drivers.c.
renode#
Les microcontrôleurs du déploiement dans Renode, sans les cartes :
renode/<deployment>/<machine>.replpour chaque processeur qui porte un binaire. Il utilise la plateforme fournie par Renode pour sachip(using "platforms/cpus/stm32h743.repl"). Une puce pour laquelle Renode n’a pas de plateforme donne lieu à une note, voir les cartes ;machines.resccharge l’ELF de chaque binaire. Le chemin est celui oùcargo build --releaseplace celui de la crate Embassy, dans une variable que vous pouvez modifier. Il ajoute un CANHub par bus CAN et un UARTHub par lien UART de la plateforme ;<deployment>.rescle démarre ;<deployment>.robot, pourrenode-test. Il vérifie que le firmware démarre ses contrôleurs CAN. Il rejoue les trames des cas de test : posées sur le bus pour une part que Renode n’exécute pas, comptées par identifiant CAN pour une part qu’il exécute.
Les processeurs Linux sont laissés de côté (un pont SocketCAN, en commentaire).
ui-web#
Les écrans du produit, sous forme d’application web : ui-web/index.html,
ui.js (le runtime UI, le moteur de rendu web, le simulateur dans le
navigateur), ui.css et ui.json (les modèles d’interface, des valeurs
d’exemple, le programme de simulation).
Elle fonctionne seule depuis le dossier. Par défaut, le modèle est simulé dans
la page. Avec ?ws=ws://host:port, elle affiche des valeurs en direct via un
WebSocket. Le protocole est décrit dans
ui.
freertos, zephyr, posix#
Le squelette RTOS de l’application Arche : objets, tâches, priorités, piles.
uppaal#
Des automates temporisés UPPAAL (model.xml) et des
requêtes (model.q).
- Il y a un template par part dotée d’une machine à états. Ses états sont des locations.
- Les états composites et les pseudo-états qu’on quitte aussitôt sont des locations committed.
- Un message apporté par un lien est un canal broadcast. Il est noté
?sur la transition qu’il déclenche, et!là où une action l’envoie. Un émetteur dont aucune transition ne fait l’envoi reçoit un template émetteur. - Chaque garantie
withinreçoit un observateur avec une horloge. - Chaque thread périodique du déploiement produit des ticks.
- Une garde sur les variables propres du composant devient une garde UPPAAL, voir les gardes dans UPPAAL et NuSMV. Le reste d’une garde devient un commentaire et est abandonné.
- Parmi les transitions d’un état sur un même déclencheur, la première qui peut être franchie l’emporte.
Les requêtes sont A[] not deadlock, E<> P.S pour chaque état, et A[] not Obs.late pour chaque échéance.
nusmv#
NuSMV ou nuXmv, sans le temps :
- un
MODULEpar machine à états, avecstate, une entrée libreeventet une relationTRANSissue des transitions. La première transition qui peut être franchie l’emporte. Une transition dont la garde n’est pas entièrement traduite peut être franchie ou non ; - un
CTLSPEC EFpar état.
components#
Les sources des composants de l’application Arche en Rust, C ou C++. Votre
code est conservé d’une génération à l’autre (arche-cli gen).
Les gardes dans UPPAAL et NuSMV#
Une variable du composant, comme var mode: Mode = MANUAL, est suivie quand
deux conditions sont réunies :
- elle démarre à une valeur écrite dans le modèle ;
- seules les transitions de la machine la modifient, chaque fois vers une
valeur elle aussi écrite dans le modèle (
/ self.mode = AUTO).
Elle devient alors un petit entier : l’indice de sa valeur dans la liste des
valeurs qu’elle peut prendre. L’export imprime cette liste en commentaire. Une
garde portant sur elle est traduite exactement, comme
[self.mode == MANUAL and not self.armed] ou [self.tries < LIMIT].
Certaines variables ne sont pas suivies, et l’export le signale pour chacune :
- une variable qu’aucune transition ne fixe : c’est une entrée ;
- une variable que d’autre code modifie aussi, comme un handler ou une fonction ;
- une variable qu’une transition fixe à une valeur calculée.
Il en va de même pour le reste d’une garde : un champ de message, un appel ou
un or. Ces morceaux sont abandonnés. Le modèle vérifié autorise donc plus de
comportements que le vrai, jamais moins. Une valeur qu’une étape de test ou la
physique écrit dans une variable suivie n’est pas vue.
Les moniteurs dans le firmware#
Un moniteur vérifie une exigence pendant que le firmware tourne. archec gen --target c --monitors compile les exigences dans chaque binaire du
déploiement. Ce sont les mêmes vérifications que celles que fait archec replay sur un journal.
Ce que vérifie chaque type d’exigence :
- Une exigence EARS guette son déclencheur : un message que la part reçoit, ou
un état dans lequel elle entre. Elle guette ensuite sa réponse dans le délai
de son
within. Sanswithin, la réponse est attendue juste après le traitement du déclencheur. - Un
never,alwaysouimpliesformaldoit être vrai à chaque vérification. eventually C within 30msdoit être vrai au plus tard 30 ms après le démarrage du binaire.A leads to B within 20msdoit être vrai chaque fois que A est vrai. PourX receives M, c’est chaque fois que M arrive.
C’est la réponse attendue la plus tôt qui compte. Chaque exigence ne prend donc
qu’un drapeau et une échéance : mémoire constante, et temps constant par
vérification. Sans within, eventually et leads to ne peuvent pas échouer
à l’exécution : ils sont laissés de côté.
Comment cela tourne dans le C :
- Un binaire vérifie les exigences dont il exécute les parts.
c/<binary>/monitors.hles recense. - Le câblage arme un moniteur quand le déclencheur arrive, avant que la part le traite. Il le désarme quand la part envoie le message ou atteint l’état. Il vérifie après chaque message, et depuis un thread de surveillance.
- Une violation appelle
arche_monitor_violation(req, at_ns). Cette fonction est à vous, dansmonitor_hook.c. Elle n’est écrite qu’une fois et, par défaut, journalise. - Il n’y a pas de tas : une petite struct par exigence.
- Quand les threads du binaire se préemptent, définissez
ARCHE_MONITOR_LOCKetARCHE_MONITOR_UNLOCKcomme une section critique. - Avec
--traceen plus, chaque verdict est aussi un enregistrement de trace :arche-trace <ns> monitor <REQ> <1|0>. Un échec est toujours enregistré. Un succès l’est quand une réponse arrive à temps.
--target embassy --monitors fait de même en Rust. Il écrit un enum
Requirement, une struct Monitors derrière un mutex bloquant, et une
monitor_task. La struct garde une copie de l’état de chaque part surveillée,
tenue à jour par la tâche de cette part. Le trait MonitorHook est implémenté
par Hook dans src/monitor_hook.rs (à vous, écrit une seule fois).
Un instant, des échéances et des watchdogs#
Ce qui se passe à un même instant se passe dans l’ordre que donne la spécification. Comme dans Lingua Franca, c’est le modèle qui fixe l’ordre, pas la machine :
- ce qui est dû en premier s’exécute en premier ;
- une part fait une seule chose à la fois ;
- un message déclenche d’abord la transition la plus interne, puis le
on-receivedu port, puis ses handlers.
Le simulateur (archec sim) et le C suivent cet ordre.
Une échéance se place sur un port ou une transition, avec un corps
on-deadline. Quand la part commence trop tard à traiter un déclencheur, c’est
ce corps qui s’exécute à la place.
Un watchdog expire, sauf si un corps le relance à temps :
watchdog w { timeout 50ms; on-timeout … }
Un corps le relance avec kick w.
Les deux sont simulés, et les deux sont générés :
- En C :
arche_item_t.sent,<part>_kicket<part>_timeouts. Les threads du câblage attendent le prochain timer. - En Rust (Embassy) : un channel vers une part qui a une échéance transporte
(Instant, message). La tâche compareelapsed()à l’échéance. En cas de retard, elle appelleon_deadline_<port>ouon_deadline(t)à la place. - En Rust, les watchdogs d’une part forment un champ
<Part>Watchdogs(self.wd.kick(…)). Leselectde la tâche attend aussi sur unembassy_time::Timerjusqu’à l’expiration du prochain watchdog, puis appelleon_timeout(w).
Avec --trace, chacun produit une ligne :
arche-trace <ns> deadline <part>.<port or From->To> <µs late>
arche-trace <ns> watchdog <part>.<name> 0
archec difftest main.arche --seed 3 compare le C au simulateur. Il injecte
les mêmes entrées aléatoires dans les deux. Le C est compilé avec un harnais
sur une horloge virtuelle. Les deux traces sont comparées, et la première
différence est affichée.
Les appels à une autre part#
Dans le langage d’action, port.op(…) appelle une opération d’une interface
que le port requiert (la spécification).
- En C, c’est
<part>_call_<port>_<op>(self, …). Le câblage fournit cette fonction. Elle appelle la part à l’autre bout du lien, choisie selon la part qui demande.difftestla vérifie par rapport au simulateur. - En Rust, c’est une méthode de
Out. Elle envoie une requête à la tâche du fournisseur (CALL_…, un channel) et attend sa réponse (REPLY_…, un signal). Quand l’autre bout est un périphérique de la carte (sampler.sensor -> sensor.temperature_sensor), la méthode fait tourner le pilote du périphérique viahw::with. Un pilote qui ne répond pas donne la valeur par défaut, et avec--traceune lignefault. - En Go, c’est
Call, et en C++ un membrestd::function. Le main du binaire renseigne les deux.
Les priorités des threads dans Embassy#
Les priorités des threads sont appliquées avec un exécuteur par niveau de priorité. Un niveau plus urgent préempte ceux qui sont en dessous. Un handler lent sur un thread peu prioritaire ne peut donc pas retarder la boucle à 1 ms.
Sur une puce (
hal stm32|nrf|rp|esp32), chaque niveau est unInterruptExecutorsur une interruption libre :- stm32 :
UART4,UART5… ; - nrf :
SWIn_EGUn; - rp :
SWI_IRQ_n; - esp32 : les interruptions logicielles 1 à 3 d’esp-hal.
Les priorités d’interruption suivent le même ordre : le niveau le plus urgent a le plus petit numéro.
P0est laissé à la HAL. Si votre firmware utilise l’une de ces interruptions, changez-la dansmain.rs. Quand il y a plus de niveaux que la puce n’a de bits de priorité (rp : 3), les moins urgents se partagent le dernier exécuteur, etgenle signale.- stm32 :
Sur un hôte (
hal std), chaque niveau est un exécuteur sur son propre thread système, à cette priorité (thread-priority). Sous Linux, SCHED_FIFO demandeCAP_SYS_NICE.Les tâches sans priorité tournent en mode thread, le niveau le plus bas. Ce sont les tâches de bus et les threads sans
priority. Quand toutes les tâches ont une priorité, le niveau le moins urgent prend le mode thread.Un
isrsans priorité passe avant tous les threads.
Au sein d’un même niveau, et sur un squelette cortex-m nu, les tâches sont
coopératives. Un handler de message va d’abord jusqu’au bout. C’est pourquoi
archec check avertit (handler-blocking) quand un handler sur un thread
périodique risque de faire dépasser l’échéance à son step.
main.rs est à vous une fois écrit. Une crate générée avant l’arrivée des
niveaux de priorité ne les démarre pas ; gen le signale.
Le CAN dans Embassy#
Sur un bus :
- un champ
optionalest un octet de présence, suivi de sa valeur ; - une
unionest un octet de cas, suivi de son plus grand cas. Le DBC multiplexe sur l’octet de cas, ou indique en commentaire quand un signal compte.
src/can.rs fait passer les trames entre les channels du bus et le matériel.
Il est à vous une fois écrit.
- Sur un hôte : SocketCAN sous Linux, et CAN FD quand le bus est en CAN FD.
hal stm32: bxCAN sur CAN1, trames classiques, jusqu’à 1 Mbit/s.hal esp32: le contrôleur TWAI (TWAI0), trames classiques, au plus proche de 125k, 250k, 500k ou 1M bit/s.
Vérifiez les broches dans main.rs. Les puces nRF, le RP2040 et l’ESP32-C2
n’ont pas de contrôleur CAN. Les channels sont alors laissés à votre pilote,
par exemple pour un MCP2515 externe sur SPI.
Limites#
arxmllaisse de côté les points d’envoi et de réception, les unités et les contraintes sur les données. Il laisse aussi de côté les tableaux, les champs optionnels et les unions dans le mapping champ par champ.arxml-adaptivelaisse de côté les ports UDP/TCP et les délais de service discovery, E2E, la sécurité, la persistance, la platform health management et les StdCppImplementationDataTypes.arxml-adaptivelaisse de côté un binaire sur microcontrôleur : c’est une ECU Classic, pourarxml.uppaaletnusmvabandonnent les morceaux d’une garde qu’ils ne savent pas traduire : le modèle vérifié autorise donc plus de comportements que le vrai.renodelaisse de côté les processeurs Linux.k8sne sait pas exprimer les cœurs exacts ni lalatencyd’un pont : ils deviennent des notes.- Sur les puces nRF, le RP2040 et l’ESP32-C2, les channels CAN d’Embassy sont laissés à votre pilote.