Cibles d'intégration
Un firmware vit au milieu d'autres outils : outils de protocole, systèmes de
build, outils de flashage et bancs de test. archec gen --target <t> peut
écrire ce que lisent ces outils, à partir du même modèle que le code. Chaque
cible écrit un type de fichier, et ses notes indiquent ce que le modèle ne lui a
pas fourni.
Une première cible#
examples/can-bench comporte trois cartes sur un même bus CAN. La cible bench
écrit la configuration de la baie de test pour son déploiement :
cd examples/can-bench
archec gen main.arche --target bench -o gen
note: platform BenchHw: no power link — the rack's supplies are not in the model (link a supply's `out v: power` to each board's `in pwr`)
gen/bench/OnBench.yaml
gen/bench/setup_can_bus.sh
gen/bench/bench_can_bus.py
Le début de gen/bench/OnBench.yaml :
deployment: OnBench
buses:
- id: can_bus
name: "CAN bus"
type: can
bitrate: 500000
interface: can0 # the rack's adapter on it
nodes:
- part: pi
port: can0
binaries: [gw]
…
frames:
- id: 0x100
message: FAN_CMD
length: 1
sender: gw
receiver: fan_fw
- id: 0x200
message: ROOM_TEMP
length: 2
sender: gw
receiver: ui_fw
period_ms: 500
…
La note indique ce qui manque au modèle : ici, l'alimentation des cartes. Les autres cibles fonctionnent de la même façon.
Fonctionnement des cibles#
Chaque cible est un générateur, comme les autres qu'affiche archec gen --list.
C'est une fonction pure du modèle et du déploiement : le même modèle donne
toujours les mêmes fichiers. Le déploiement est celui que nomme --deployment,
ou à défaut le déploiement actif.
Chaque cible n'écrit que ce que dit le modèle. Certains protocoles ont besoin
d'une valeur pour laquelle le langage n'a pas de mot : un SPN J1939, un
identifiant MAVLink ou un identifiant de fabricant CANopen. La cible lit cette
valeur dans un attr posé sur la déclaration concernée. Quand l'attr manque,
les notes le signalent. Une valeur n'est jamais inventée en silence.
| Cible | Écrit | À partir de |
|---|---|---|
canopen |
canopen/<bus>/<binary>.eds : un EDS CiA 306 par binaire sur un bus CAN |
les routes sur le bus, la disposition des messages |
j1939 |
j1939/<bus>.json, .md : les groupes de paramètres et les SPN |
les routes avec un id sur 29 bits |
mavlink |
mavlink/<project>.xml : un dialecte MAVLink 2 |
le catalogue de messages |
someip |
someip/<deployment>.json : services, méthodes, événements et instances SOME/IP |
les interfaces et les ports Ethernet |
openapi |
openapi/<Component>.json : OpenAPI 3.1 |
les handler HTTP des ports |
asyncapi |
asyncapi/<system>.json : AsyncAPI 3.0 |
les liens qui transportent des messages, leurs topics |
cmake |
cmake/ : un projet CMake par binaire C, une chaîne de compilation par microcontrôleur |
les binaires, les cœurs de leurs processeurs |
west |
west/<binary>/ : une application Zephyr avec son manifeste west |
les binaires sur des cartes Zephyr |
platformio |
platformio/<binary>/platformio.ini |
les binaires sur des cartes que PlatformIO connaît |
ci |
ci/.github/workflows/archec.yml, ci/.gitlab-ci.yml |
les cibles qu'utilise le déploiement |
flash |
flash/<binary>/flash.sh, monitor.sh |
la puce et la carte de chaque binaire de microcontrôleur |
bench |
bench/<deployment>.yaml, setup_<bus>.sh, bench_<bus>.py |
la plateforme : bus, cartes, liens d'alimentation et d'E/S |
Il y a une cible par format, plutôt qu'une seule cible avec des sous-types.
Chaque format a ainsi son propre --check, ses propres notes et sa propre ligne
dans archec gen --list. Une tâche de CI ne régénère que les formats qu'elle
utilise.
Chaque section ci-dessous se termine par la façon dont la sortie est vérifiée
dans les tests d'archec (test/integration.test.js).
Descriptions de protocoles#
CANopen (--target canopen)#
Elle écrit une fiche de données électronique (EDS, CiA 306, version 4.0) pour
chaque binaire qui émet ou reçoit sur un bus CAN du déploiement :
canopen/<bus>/<binary>.eds. L'EDS contient :
- les objets obligatoires : type d'équipement (0x1000), registre d'erreur (0x1001) et identité (0x1018) ;
- un PDO d'émission pour chaque trame que le binaire émet sur le bus (0x1800 + n, avec son mapping en 0x1A00 + n) ;
- un PDO de réception pour chaque trame qu'il reçoit (0x1400 + n, et 0x1600 + n) ;
- un objet par message, dans la zone fabricant (à partir de 0x2000). L'index
est le même dans l'EDS de chaque nœud. Chaque signal est un sous-index, nommé
comme dans le modèle (
TEMPERATURE.value), avec son type CANopen.
Pour chaque PDO :
- Le COB-ID est l'
idde la route, avec le bit 29 positionné pour un identifiant sur 29 bits. - Un message avec une
periodest émis sur la minuterie d'événement : type de transmission 0xFE, avec la période en ms. - Les autres messages sont émis quand l'application les envoie.
Les signaux suivent la disposition qu'utilisent le DBC et le code C et Rust générés : le PDO transporte donc les mêmes octets. Un message avec un format filaire place ses champs sur leurs bits, avec des entrées factices pour combler les trous.
Ce qu'un PDO classique ne peut pas transporter est omis, et les notes le signalent :
- une trame de plus de 8 octets (CANopen FD, CiA 1301, n'est pas écrit) ;
- un champ big-endian ;
- un champ dont aucun type CANopen n'a le nombre de bits, comme un champ de 4 bits (il n'existe pas d'UNSIGNED4).
Le modèle n'a pas d'identité CANopen. Indiquez-la sur le binaire ou sur son processeur :
binary pump_fw "pump-fw" on pumpb {
attr canopen_node_id = 5 // [DeviceComissioning] NodeID
attr vendor_id = 0x1234 // 0x1018 sub 1, VendorNumber
attr product_code = 42 // 0x1018 sub 2
attr revision = 1 // 0x1018 sub 3
…
}
Sans ces attributs, l'EDS indique 0, et les notes nomment ce qui manque. Par
exemple, sur examples/can-bench :
note: can_bus/gw: no vendor_id, product_code, canopen_node_id in the model — the EDS says 0; write `attr vendor_id = …` on binary gw
Un débit qui ne fait pas partie de ceux de CANopen est aussi signalé. Les débits CANopen sont 10, 20, 50, 125, 250, 500, 800 et 1000 kbit/s.
Vérification : chaque fichier est lu avec le paquet Python canopen, à la fois
son dictionnaire d'objets et les mappings de PDO qu'il en déduit.
J1939 (--target j1939)#
Pour chaque bus CAN qui transporte des trames à identifiant sur 29 bits, elle
écrit j1939/<bus>.json, et le même contenu sous forme de tableaux Markdown dans
j1939/<bus>.md.
En J1939-21, l'identifiant contient tout ce qui concerne un groupe de
paramètres. La cible le lit donc dans l'id de la route :
- la priorité ;
- le PGN, avec la page de données et la page de données étendue ;
- le format PDU : PDU 1 avec son adresse de destination, ou PDU 2 avec son extension de groupe ;
- l'adresse source.
Elle ajoute ensuite la longueur du groupe, sa cadence (la period du message),
le binaire qui l'émet et celui qui le reçoit.
Chaque signal est un SPN, avec les colonnes de J1939-71 :
- sa position de départ, sous la forme
byte.bit, toutes deux comptées à partir de 1 ; - sa longueur en bits ;
- sa résolution et son décalage (le
scaleet l'offsetd'un format de transmission) ; - son unité et sa plage.
Le numéro de SPN ne figure pas dans l'identifiant : vous l'écrivez donc sur le champ :
message EEC1 "Electronic engine controller 1" {
attr pgn = 61444 // checked against the route's id
period 10ms
size 8
torque_mode: uint8 bits 4 range 0..15 { attr spn = 899 }
speed: float32 unit rpm range 0..8031 at 24 bits 16 scale 0.125 { attr spn = 190 }
}
…
route pump.engine -> gateway.engine over can_bus { id 0x0CF00405 }
Un signal sans attr spn est listé avec "spn": null, et les notes le
nomment. Les notes nomment aussi :
- une trame de plus de 8 octets (elle passe par le protocole de transport, TP.BAM ou TP.CMDT) ;
- un champ big-endian ;
- un binaire qui émet depuis plusieurs adresses source, ou depuis une autre
adresse que son
attr j1939_address; - un PGN émis par deux binaires ;
- les trames à identifiant sur 11 bits présentes sur le bus, qui sont omises.
Vérification avec cantools.j1939 : il lit la même priorité, le même PGN et la
même adresse source à partir du même identifiant.
MAVLink (--target mavlink)#
Elle écrit le catalogue de messages sous forme de fichier de définition de
messages MAVLink, le format que lit mavgen : mavlink/<project>.xml. Le
fichier est un dialecte à part entière. Il n'inclut rien : le HEARTBEAT du
modèle n'entre donc pas en conflit avec celui de common.xml.
- Chaque message à disposition fixe est un
<message>. Chaque signal de cette disposition est un<field>:- une structure est aplatie (
header_seq) ; - un tableau de scalaires est un seul champ tableau (
float[4]) ; - une énumération est un
uint8_tavecenum="MODE".
- une structure est aplatie (
- Chaque énumération qu'utilisent les messages est un
<enum>, avec des entrées commeMODE_RUN. - L'unité d'un champ est écrite quand le schéma MAVLink la connaît :
m/s,degC,rad,%. Les°,°/setm/s²du modèle deviennentdeg,deg/setm/s/s. Toute autre unité va dans la description du champ. - La description du message contient son nom ou sa description, et sa
period.
L'identifiant MAVLink ne figure pas dans le modèle. Indiquez-le avec
attr mavlink_id = 30 sur le message. Les messages qui n'en ont pas sont
numérotés à partir de 65536, dans l'ordre du catalogue. Ces numéros sont
au-dessus de toutes les plages que le registre MAVLink attribue aux dialectes :
ils n'entrent donc en conflit avec aucune. Les notes les listent : donnez-leur
leurs vrais identifiants avant que deux systèmes en dépendent.
Une charge utile de plus de 255 octets, ou de plus de 64 champs, est omise, et les notes le signalent.
Vérification avec mavgen --strict-units, qui contrôle le schéma et les
unités. Ses en-têtes C sont compilés et un message est empaqueté. Son code
Python fait l'aller-retour d'un message.
SOME/IP (--target someip)#
Elle écrit une description de services en JSON : someip/<deployment>.json.
On y trouve ce que contiennent FIBEX et ARXML : les services, leurs méthodes,
leurs événements et groupes d'événements, et l'endroit où s'exécute chaque
instance. On y trouve aussi les types de données qu'utilisent les charges
utiles.
- Un service par interface qu'un port
provides:- Chaque opération est une méthode. Elle est de type requête/réponse quand elle renvoie quelque chose, et de type fire-and-forget sinon.
- Les messages de l'interface qu'émet le fournisseur sont des
événements, regroupés dans un groupe d'événements. Un événement est
cyclique à la
perioddu message, ou sinon émis sur changement. - Les messages que le fournisseur ne fait que recevoir sont des méthodes fire-and-forget.
- Un service par port
outsur un lien Ethernet qui émet des messages et ne participe à aucune interface. Ses messages sont des événements. - Les instances, pour chaque service : la part qui le fournit, le binaire et le processeur sur lesquels elle s'exécute, et les parts à l'autre bout de ses liens.
dataTypes: les structures, énumérations et unions qu'utilisent les charges utiles. Les scalaires portent les noms de SOME/IP (sint16,float32,boolean).
Les identifiants ne figurent pas dans le modèle. Indiquez-les avec :
attr |
sur |
|---|---|
someip_service_id |
l'interface (ou le port) |
someip_instance_id |
le port fournisseur |
someip_method_id |
une opération |
someip_event_id |
un message |
someip_major_version, someip_minor_version |
l'interface |
Sans eux, les services sont numérotés à partir de 0x1000, les méthodes à partir de 0x0001 et les événements à partir de 0x8001, dans l'ordre du modèle. Les notes listent chacun d'eux. Une interface fournie sur un port qui n'est pas sur IP (un port CAN) est signalée.
SOME/IP sérialise en big-endian. Les codecs qu'archec génère pour CAN sont en little-endian : ils ne correspondent donc pas à ce format de transmission.
OpenAPI (--target openapi)#
Elle écrit un document OpenAPI 3.1 pour chaque définition de composant dont les
ports ont des handlers HTTP, comme
handler GET "/api/v1/readings/{node}" -> reading. Le fichier est
openapi/<Component>.json.
- Chaque handler est une opération :
- son
operationIdest le nom de la fonction ; - son résumé est le nom de la fonction entre guillemets ;
- sa description est celle du handler, ou à défaut celle de la fonction ;
- elle porte l'étiquette du port.
- son
{node}dans le chemin est un paramètre de chemin, typé par le paramètre de même nom de la fonction.- Les autres paramètres forment la requête (GET, DELETE, HEAD), ou un corps
JSON (POST, PUT, PATCH). Ils sont obligatoires sauf s'ils sont
optional. - Le type de retour de la fonction est la réponse 200, en JSON. Sans type de retour, la réponse est 204.
serversliste chaque part de cette définition qui aprop hostname = "…"(ouattr url = "…").
Les schémas sont en JSON Schema, partagés avec AsyncAPI :
- Une structure est un objet dont les champs sont obligatoires (sauf ceux qui
sont
optional), sans autre champ. - Une énumération est la liste de ses noms littéraux.
x-valuesdonne leurs valeurs numériques. - Un tableau de taille fixe a sa taille comme nombre minimal et maximal d'éléments.
- Un entier a les bornes de son type, ou sa
range. Un flottant a sarange. - Une unité est donnée par
x-unit. - Un type alias (
type Speed = float32 unit m/s range 0..70) est son scalaire, avec son unité et sa plage. - Une union est un
oneOfde{case, value}.
Vérification avec openapi-spec-validator.
AsyncAPI (--target asyncapi)#
Elle écrit un document AsyncAPI 3.0 pour chaque système, ou pour le système du
déploiement s'il y en a un : asyncapi/<system>.json.
- Un canal par port qui émet sur un lien. Son adresse est le
topicdu lien ou du port. À défaut, c'est<part>/<port>, comme le nomment les nœuds ROS 2. Ses messages sont ceux que transportent les liens. - Une opération d'émission pour la part qui publie, et une opération de réception pour chaque part à l'autre bout.
- Un serveur par bus qu'emprunte une route, quand il y a un déploiement.
Son protocole vient du type de port (
can,serial,udp,mqtt…), avec son débit dans la description. Le canal est rattaché à ce serveur. - Les messages sont dans
components.messages, et leurs charges utiles dans les schémas partagés.
Vérification avec le schéma JSON officiel d'AsyncAPI 3.0.0 (@asyncapi/specs
avec ajv), quand ARCHE_NODE_TOOLS désigne un dossier où ils sont installés.
Systèmes de build#
Les cibles de build enveloppent le C qu'écrit --target c, là où il se trouve.
Elles renvoient vers ../../c depuis leur propre dossier : écrivez donc les deux
dans le même dossier de sortie :
archec gen main.arche --target c -o gen
archec gen main.arche --target cmake -o gen
cmake -S gen/cmake -B build && cmake --build build # every C binary, on this host
Un binaire en Rust (--target embassy) ou en Go (--target go) a son propre
build, avec cargo ou go. Ces cibles le signalent et l'omettent.
CMake (--target cmake)#
cmake/<binary>/CMakeLists.txtconstruit deux choses :- le modèle du binaire, sous forme de bibliothèque statique
<binary>_model: les types, ses parts, son câblage et ses pilotes ; - l'exécutable, avec son
main.cet son environnement d'exécution. Celui-ci est POSIX sur un hôte, et FreeRTOS en compilation croisée.ARCHE_RTdécide.
- le modèle du binaire, sous forme de bibliothèque statique
cmake/<binary>/toolchain.cmake, pour un binaire sur un microcontrôleur :- GCC, par son préfixe (
arm-none-eabi-,riscv32-esp-elf-,xtensa-esp32-elf-) ; - les options du cœur, d'après son
core-type. Par exemple,Cortex-M4Fdonne-mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=hard.
- GCC, par son préfixe (
cmake/<binary>/port.cmakeest écrit une seule fois, puis il vous appartient. Il désigne :- le noyau FreeRTOS (
FREERTOS_KERNEL_PATH), et son portage pour le cœur (GCC_ARM_CM4F…) ; - le code de démarrage et le script d'édition de liens de la puce.
Sans noyau, seule la bibliothèque du modèle est construite, avec un avertissement.
- le noyau FreeRTOS (
cmake/CMakeLists.txtconstruit tous les binaires C pour cet hôte. Les binaires des microcontrôleurs sont inclus aussi : leur logique s'exécute sur l'environnement POSIX, comme leur Makefile la construit. C'est ce que la CI construit et exécute.
Certains cœurs n'ont pas de portage FreeRTOS officiel, comme Xtensa (celui de
l'ESP32). C'est signalé. ESP-IDF apporte son propre portage, qu'utilise
--target platformio.
Vérification :
- les trois binaires C du banc sont configurés, construits et exécutés avec CMake sur l'hôte ;
- la bibliothèque du modèle du nœud capteur est compilée en croisé pour son
STM32G4 avec le fichier de chaîne de compilation, quand un
arm-none-eabi-gccavec newlib est installé.
Zephyr (--target west)#
Pour chaque binaire C sur une carte que Zephyr connaît, elle écrit une
application Zephyr dans west/<binary>/. Les cartes sont les cartes Nucleo,
nRF52840 DK, Pico et ESP32 du store.
CMakeLists.txtajoute le C du binaire à l'appde Zephyr, sur l'API POSIX de Zephyr (arche_rt_posix.c).prj.confest écrit une seule fois, puis il vous appartient. Il activeCONFIG_POSIX_APIet les pilotes dont ont besoin les nœuds de l'overlay (CONFIG_CAN,CONFIG_SERIAL…).boards/<board>.overlayest ce qu'écrit--target devicetreepour cette carte : les CAN, UART, I2C et SPI reliés, sur leurs broches, et un alias par bus qu'ouvre le C.west.ymlest un manifeste. Il fige la version de Zephyr (v4.1.0) et n'autorise que les modules dont a besoin la HAL de la carte (cmsis,hal_stm32…).
west init -l gen/west/node_fw && west update && west build -b nucleo_g474re gen/west/node_fw
Vérification : le paquet Python de west valide et charge le manifeste.
PlatformIO (--target platformio)#
Pour chaque binaire C sur une carte que PlatformIO connaît, elle écrit
platformio/<binary>/platformio.ini. Le fichier indique :
- la plateforme et la carte :
ststm32/nucleo_g474re,espressif32/esp32dev,nordicnrf52/nrf52840_dk,raspberrypi/pico; - un framework avec des threads sous l'environnement d'exécution :
- Zephyr sur STM32 et nRF52, avec
zephyr/CMakeLists.txt,prj.confetapp.overlay; - le FreeRTOS d'ESP-IDF sur ESP32 ;
- le FreeRTOS du cœur Arduino d'Earle Philhower sur le RP2040 ;
- Zephyr sur STM32 et nRF52, avec
- le C généré comme sources :
src_dir = ../../c, et unbuild_src_filterlimité aux fichiers du binaire.
Les notes indiquent ce qui reste à faire à la main. Par exemple, ESP-IDF démarre
app_main, pas main.
Vérification : pio project config lit chaque fichier. Les fichiers ne sont pas
compilés, car cela téléchargerait la chaîne de compilation de chaque
plateforme.
CI (--target ci)#
Elle écrit un pipeline pour GitHub Actions (ci/.github/workflows/archec.yml),
et son équivalent pour GitLab CI (ci/.gitlab-ci.yml). Copiez ci/ à la racine
du dépôt. Les tâches :
model:archec check, puisarchec ciavec son rapport JUnit. Le rapport est téléversé sur GitHub, et sert de rapport de tests sur GitLab.generated:archec gen --checkpour chaque cible qu'utilise le déploiement, dans une matrice. Soitcetcmakepour les binaires C,embassypour les binaires Rust,go, etdbcpour ses bus CAN. Cette tâche montre que le code généré versionné est bien celui que donne le modèle.build-c: le projet CMake de--target cmake, construit sur l'hôte. Chaque binaire s'exécute pendant une seconde.build-<binary>, pour chaque binaire Rust :cargo build --releasepour la cible de sa puce (thumbv7em-none-eabihf…, ou la chaîne de compilation Espressif pour un ESP32 Xtensa).
Trois variables en tête de fichier indiquent où se trouvent les choses. Modifiez-les quand le projet n'est pas à la racine du dépôt :
ARCHE_MAIN: le fichier principal du modèle, depuis la racine du dépôt ;ARCHE_GEN: le dossier dans lequel le code généré est versionné (generated) ;- le déploiement.
Vérification : les deux fichiers sont du YAML valide, et valides selon les
schémas de SchemaStore pour les workflows GitHub et GitLab CI
(check-jsonschema).
Le laboratoire#
Flashage et surveillance (--target flash)#
Pour chaque binaire sur un microcontrôleur, elle écrit deux scripts exécutables
dans flash/<binary>/.
flash.sh [image] flashe le binaire. Il utilise le premier outil installé
parmi ceux de sa puce, ou celui que nomme TOOL= :
| Puce | Outils, dans l'ordre |
|---|---|
| STM32 | probe-rs (--chip STM32G474RETx), OpenOCD via le ST-LINK (target/stm32g4x.cfg) |
| nRF52 | probe-rs (nRF52840_xxAA), nrfjprog (l'ELF converti en HEX), OpenOCD via un J-Link |
| RP2040 | picotool (load -x), probe-rs, OpenOCD via une sonde CMSIS-DAP |
| ESP32 | espflash, esptool (l'ELF converti en image, écrite à 0x10000) |
L'image est $1. Sans argument, le script prend l'image là où le build la
place :
- pour Rust, le
embassy/<binary>/target/<triple>/release/<crate>de cargo ; - pour C,
build-<binary>/<binary>.elf: le build croisé de--target cmake, depuis le dossier où archec gen a écrit.
monitor.sh lit la trace du binaire pendant ARCHE_DURATION secondes (10 par
défaut) dans ARCHE_TRACE (<binary>.trace). Il lance ensuite
archec timing et archec live --replay sur la trace, avec le déploiement.
- La trace d'un binaire C vient de l'UART de la carte : son port COM virtuel
quand elle en a un.
ARCHE_PORTle désigne (/dev/ttyACM0par défaut). Elle est lue avec pyserial, au débit du lien qui s'y trouve (ou sinon à 115200). - La trace d'un binaire Rust est du defmt sur RTT, via
probe-rs attach. - Le modèle est
ARCHE_MAIN: le nom du fichier principal, depuis l'endroit où s'exécute le script.
La trace est ce que archec gen --trace fait écrire au firmware :
- le C, compilé avec
-DARCHE_TRACE_LIVE, avec sonc/arche_trace_port.cqui écrit sur cette UART ; - le Rust, compilé avec
--features trace.
archec timing ignore tout ce qui précède arche-trace sur une ligne : un
préfixe de journal ne pose donc aucun problème.
Un binaire sous Linux n'est pas flashé, et c'est signalé : copiez-le sur la cible.
Vérification :
- chaque script est analysé sans erreur (
sh -n) ; flash.sh, lancé avec un faux probe-rs, reçoit la bonne puce et la bonne image ;- OpenOCD lit l'interface, le transport et la cible de chaque ligne OpenOCD ;
monitor.shlit des lignes arche-trace écrites dans un pseudo-terminal, etarchec timingetarchec liveen mesurent le thread.
Rien n'a encore été exécuté sur une carte ici.
Le banc (--target bench)#
Elle écrit la configuration de la baie de test matérielle du déploiement, à
partir de sa plateforme. Une première cible la montre sur
examples/can-bench.
bench/<deployment>.yaml contient :
buses: chaque bus, avec :- son type (
can,can-fd,uart,ethernet) ; - son débit, et son
data_bitratetiré deattr data_bitratesur un bus CAN FD (le langage n'a pas de mot pour la phase de données) ; - l'interface de la baie sur ce bus :
can0,can1… dans l'ordre, ou/dev/ttyUSB0… pour un bus série ; - les nœuds qui s'y trouvent, avec leurs binaires ;
- pour un bus CAN, chaque trame qu'il transporte : identifiant, message, longueur, émetteur, récepteur et période.
- son type (
duts(équipements sous test) : chaque binaire sur un microcontrôleur, avec sa carte, sa puce, ses scripts de flashage et de surveillance (--target flash) et son UART de console.hosts: les binaires sous Linux.power: chaque alimentation (un portout … : power) et ce qu'elle alimente.io: les liens GPIO, PWM et analogiques.
Ce que le modèle ne peut pas dire vaut null, comme les voies des
alimentations et les E/S de votre baie. Les notes indiquent ce qui manque
d'autre, comme un débit ou un lien d'alimentation.
bench/setup_<bus>.sh, pour chaque bus CAN, configure son interface SocketCAN
au débit du bus (restart-ms 100, et dbitrate … fd on pour CAN FD). Quand
l'interface donnée s'appelle vcan…, il crée à la place un bus virtuel.
bench/bench_<bus>.py, pour chaque bus CAN, utilise python-can :
- Il liste les trames qui passent, nommées d'après le modèle.
- Il échoue (code de sortie 1) quand une trame périodique manque, ou s'écarte de sa période de plus de la moitié.
--as <binary>remplace un binaire absent de la baie : il émet les trames de ce binaire à leur période.--send <MESSAGE>envoie un message.--interface virtualexécute le tout dans un seul processus, sans matériel.
sh gen/bench/setup_can_bus.sh can0
python3 gen/bench/bench_can_bus.py --channel can0 --duration 10 --as gw_app
Vérification :
- le YAML se charge, et le script de configuration est analysé sans erreur ;
- le script python-can, sur son bus virtuel, voit les trames du capteur et de la pompe à leurs périodes quand il les simule ;
- il échoue en signalant la trame manquante de la pompe quand il ne la simule pas.
Limites#
- Chaque cible n'écrit que ce que dit le modèle. Une valeur pour laquelle le langage n'a pas de mot (un SPN J1939, un identifiant MAVLink, une identité CANopen, des identifiants SOME/IP) vient d'un
attr. Sans lui, la cible écrit 0,nullou une valeur numérotée provisoire, et les notes le signalent. - CANopen : pas de CANopen FD (CiA 1301). Une trame de plus de 8 octets, un champ big-endian ou un champ dont aucun type CANopen n'a le nombre de bits sont omis des PDO.
- J1939 : les trames à identifiant sur 11 bits sont omises. Une trame de plus de 8 octets nécessite le protocole de transport, qui est signalé mais pas écrit.
- MAVLink : une charge utile de plus de 255 octets ou de plus de 64 champs est omise.
- SOME/IP : les codecs CAN qu'archec génère sont en little-endian : ils ne correspondent donc pas au format de transmission de SOME/IP.
- Les cibles de build ne construisent que du C. Un binaire Rust ou Go est omis, avec une note. Un cœur sans portage FreeRTOS officiel (Xtensa) est signalé.
- Les fichiers PlatformIO sont lus par
pio project configdans les tests, mais pas compilés. ESP-IDF démarreapp_main, pasmain: c'est à faire à la main. - Les scripts de flashage et de surveillance n'ont pas été exécutés sur une carte dans les tests d'archec. Un binaire sous Linux n'est pas flashé.
- Le fichier du banc ne peut pas indiquer les voies des alimentations et des E/S de votre baie : elles valent
null.