Référence › Cibles de génération de code

Référence

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

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.rs et Cargo.toml.
  • Le code que vous placez dans une région USER CODE est 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 Channel par lien, avec son depth et son overflow, ou un Signal pour buffer sample ;
  • pour chaque part, un handle Out et un trait de comportement ;
  • une tâche par thread : un Ticker pour period + step, et un select sur les entrées ;
  • pour chaque message routé, l’encodage, le décodage et un BusFrame. L’identifiant CAN est l’id de 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.h et .c : du C99, sans tas ni libm ;
  • wire/rust/ : une crate no_std ;
  • wire/go/ : le package archewire ;
  • 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 data avec les propriétés Data_Model, par message et par type ;
  • un processor par processeur, avec un virtual processor par cœur et une memory pour sa ram ;
  • un bus, avec un Transmission_Time déduit de bitrate ;
  • un virtual processor par conteneur, lié aux cœurs de son cpuset. Ses processus lui sont liés ;
  • un process par processus (ou par binaire s’il n’y en a pas) ;
  • un thread par thread, avec Dispatch_Protocol, Period, Deadline, Compute_Execution_Time, Priority et Stack_Size. Compute_Execution_Time vaut 0 ms .. wcet, sinon le coût du step ;
  • des event data ports. Un port avec buffer sample est un data port. Queue_Size vient de depth ;
  • un device par 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 + step du 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 arxml les é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 out qui 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.csv a 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 un budget est écrit. Viennent ensuite les totaux, global et par système.
  • bom/bom.md reprend 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 de c/<binary> et le Rust de embassy/<binary> : générez-les dans le même répertoire, qui sert de contexte de build. Quand le conteneur exécute plusieurs binaires, un entrypoint.sh les démarre ;
  • containers/<processor>/compose.yaml, pour nerdctl compose up. Il fixe l’image, la platform (d’après l’isa ou le core-type du processeur), cpuset, mem_limit, network_mode, devices, cap_add, privileged, un ulimit rtprio à la plus haute priorité temps réel, et environment ;
  • containers/deploy.sh : il construit chaque image (PUSH=1 la 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 nodeSelector kubernetes.io/hostname est le nom du processeur (avec - à la place de _), et kubernetes.io/arch vient de son isa ;
  • des resources dont les requests égalent les limits, d’après la taille de son cpuset et memory-limit. C’est la classe Guaranteed : elle obtient des cœurs exclusifs avec le CPU manager statique du kubelet ;
  • hostNetwork pour network host ;
  • privileged pour capabilities all, sinon capabilities.add ;
  • chaque device monté 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), et ros2_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 de mass, shape et joint des 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 --plant exé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_pa2 de hal_stm32, NRF_PSEL, les macros pinmux du RP2040 et de l’ESP32. Les pins propres à 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>.repl pour chaque processeur qui porte un binaire. Il utilise la plateforme fournie par Renode pour sa chip (using "platforms/cpus/stm32h743.repl"). Une puce pour laquelle Renode n’a pas de plateforme donne lieu à une note, voir les cartes ;
  • machines.resc charge l’ELF de chaque binaire. Le chemin est celui où cargo build --release place 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>.resc le démarre ;
  • <deployment>.robot, pour renode-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 within reç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 MODULE par machine à états, avec state, une entrée libre event et une relation TRANS issue 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 EF par é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. Sans within, la réponse est attendue juste après le traitement du déclencheur.
  • Un never, always ou implies formal doit être vrai à chaque vérification.
  • eventually C within 30ms doit être vrai au plus tard 30 ms après le démarrage du binaire.
  • A leads to B within 20ms doit être vrai chaque fois que A est vrai. Pour X 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.h les 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, dans monitor_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_LOCK et ARCHE_MONITOR_UNLOCK comme une section critique.
  • Avec --trace en 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-receive du 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>_kick et <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 compare elapsed() à l’échéance. En cas de retard, elle appelle on_deadline_<port> ou on_deadline(t) à la place.
  • En Rust, les watchdogs d’une part forment un champ <Part>Watchdogs (self.wd.kick(…)). Le select de la tâche attend aussi sur un embassy_time::Timer jusqu’à l’expiration du prochain watchdog, puis appelle on_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. difftest la 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 via hw::with. Un pilote qui ne répond pas donne la valeur par défaut, et avec --trace une ligne fault.
  • En Go, c’est Call, et en C++ un membre std::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 un InterruptExecutor sur 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. P0 est laissé à la HAL. Si votre firmware utilise l’une de ces interruptions, changez-la dans main.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, et gen le signale.

  • 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 demande CAP_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 isr sans 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 optional est un octet de présence, suivi de sa valeur ;
  • une union est 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#

  • arxml laisse 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-adaptive laisse 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-adaptive laisse de côté un binaire sur microcontrôleur : c’est une ECU Classic, pour arxml.
  • uppaal et nusmv abandonnent les morceaux d’une garde qu’ils ne savent pas traduire : le modèle vérifié autorise donc plus de comportements que le vrai.
  • renode laisse de côté les processeurs Linux.
  • k8s ne sait pas exprimer les cœurs exacts ni la latency d’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.