Générer
Les commandes qui écrivent, à partir du modèle, du code et des fichiers pour d’autres outils.
Commandes : archec gen · archec generator · archec plugin · archec fmi · archec kicad · archec sysml · archec export · archec api · archec capella
Sur cette page : Pour aller plus loin
| Commande | Ce qu’elle fait |
|---|---|
archec gen <main.arche> --target <t> [-o generated] [--deployment D] [--check] [--trace] [--monitors] |
Du code source à partir du modèle. embassy : une crate Rust par binaire (canaux, codec CAN, machines à états, tâches ; votre app.rs est conservé). sbom : une nomenclature CycloneDX 1.5 (sbom/bom.cdx.json) avec le matériel, son fabricant et sa référence, les bibliothèques à la version que nomme arche.lock, et un firmware par binaire sur son processeur. proto, ros2, dds : les messages, structs, enums et unions (et les opérations d’une interface sous forme de service) pour protobuf (proto3), ROS 2 (.msg, .srv, dans le paquet ament <project>_msgs) et DDS (OMG IDL 4). Avec un déploiement qui indique packaging ros2 (celui que nomme --deployment, sinon le premier), ros2 écrit aussi ros2_nodes/ : un paquet ament_cmake par binaire sur un processeur Linux, avec un exécutable rclcpp par processus et un nœud par part autour de son module C (publishers, subscriptions, services, un timer par thread périodique, des paramètres tirés de ses prop, la QoS tirée des liens), plus <deployment>_bringup avec son fichier de lancement. colcon build dans le dossier de sortie les construit. gazebo : l’environnement physique de ce déploiement dans Gazebo (gz sim Harmonic), sous forme du paquet gazebo/. Il contient un monde SDF avec un link par capteur, par actionneur ou par part dotée d’une mass (des capteurs gpu_lidar, camera, imu ou navsat là où la part en est un), la configuration de ros_gz_bridge, sim_adapter.py (les messages standard de Gazebo traduits en messages du modèle, les commandes des nœuds traduites en topics gz) et un fichier de lancement qui démarre le tout avec les nœuds en temps simulé. Une fois écrits, le monde et l’adaptateur vous appartiennent. mujoco : l’environnement physique dans MuJoCo (mujoco/<system>.xml, en MJCF). Il contient un corps par part dotée d’une mass ou d’une shape, imbriqué comme les parts et placé par leur joint … at, avec sa géométrie tirée de sa shape et sa masse, et son articulation hinge, slide, ball ou free. Il contient aussi un capteur par part kind sensor (jointpos, jointvel, accelerometer, gyro, force, torque, touch, rangefinder, framepos, framequat, d’après son nom ou l’unité de ce qu’il envoie), un actionneur par part kind actuator sur l’articulation du corps où elle se trouve (motor, position ou velocity d’après l’unité du champ qui le commande ; sur un corps libre, un propulseur sur un site), le pas de temps tiré du pas du solver, et une keyframe tirée des = value des articulations. S’y ajoute mujoco/plant_bridge.py, qui envoie les commandes dans data.ctrl et transforme data.sensordata en messages des capteurs à leur period : --stdio pour archec sim --plant, --csv out.csv [--control seq.csv] pour une séquence de commandes fixée, --viewer, et --ros2 pour un nœud ROS 2 sur les topics de gen --target ros2 (voir MuJoCo). tests : un cas de test par transition déclenchée par un message (le chemin le plus court jusqu’à son état source, puis son déclencheur et l’état qui suit) et par message reçu, à ses limites. Les cas qui contiennent un TODO sont listés dans tests/generated.allow pour archec test --allow. ears-tests : un cas de test par exigence EARS (le déclencheur envoyé par la part câblée pour l’envoyer, la réponse attendue dans le délai). go : un programme Go par binaire qui indique language go, sur une carte Linux du hardware store. Il contient l’adaptateur de la carte et un driver par équipement qui lui est relié (bus et adresse, ou broches, tirés des liens), les parts qu’il exécute (variables, corps arche traduits, machines à états, messages sur des canaux) et une goroutine par thread. Un lien vers une part qu’exécute un autre binaire Go passe en JSON sur HTTP (`net.go`, chaque binaire sur son port à partir de 9001, `ARCHE_LISTEN`/`ARCHE_PEER_<BINARY>` pour les déplacer ; testé dans `net_test.go`). `user.go` vous appartient. Le code Go du store qu’il utilise est copié, si bien qu’il se construit sans rien d’autre que Go. Sur un hôte (un processeur avec `compute { os linux }` et sans carte), c’est la même chose, sans le matériel. Les handlers HTTP des parts (`handler GET "/items/{id}" -> item`) deviennent un serveur (`http.go` : les routes que décrit `--target openapi`, chaque appel exécuté sur le thread de sa part, sur `ADDR` ou le port de l’`attr url` de la part, sinon :8080) et `http_test.go`, un test de chaque route pour `go test`. `ui-web` : les écrans du produit (chaque `ui`) sous forme d’application web autonome, avec `ui-web/index.html`, `ui.js`, `ui.css`, `ui.json`. Par défaut, le modèle est simulé dans la page (un appui envoie son message dans la simulation) ; avec `?ws=ws://host:port`, les valeurs viennent plutôt d’un WebSocket (voir [ui](../ui.md#the-web-target-gen---target-ui-web)). `c` : du C99, avec les types et leurs codecs (les mêmes octets que le DBC et le Rust), un module par composant (ses variables et son état, ses fonctions avec les corps arche traduits, goto, fire pour ses transitions, ses timers after, ses échéances et ses watchdogs, dans l’ordre que donne la spécification), les fonctions d’envoi à câbler vous-même et, avec un déploiement, une tâche FreeRTOS par thread. --monitors : les exigences sous forme de moniteurs d’exécution dans chaque binaire (réponses EARS dans leur délai, invariants formal, eventually … within et … leads to … within, avec un indicateur et une échéance chacun), soit les vérifications qu’archec replay fait sur un journal. Une violation appelle arche_monitor_violation, que vous écrivez dans monitor_hook.c. Aucune allocation sur le tas. Avec --trace, chaque verdict est aussi une ligne de trace, `arche-trace |
archec gen <main.arche> --target c|embassy --build [--lint] [--sarif f] |
Construit ce qui vient d’être écrit (qualité du code généré) : c avec le Makefile de chaque binaire (ou chaque module seul, sans déploiement) et -std=c99 -Wall -Wextra -Werror -pedantic, embassy avec cargo build. --lint ajoute l’addon MISRA C:2012 de cppcheck et clang-tidy pour le C, cargo clippy pour le Rust, chacun seulement s’il est installé ; un outil absent est signalé. Chaque constat est affiché sur l’élément du modèle d’où vient sa ligne générée (main.arche:57 error [cc-unused-variable] … — c/controller_ports.c:6 in controller_send_cmd (port cmd of Controller)). --sarif les écrit en SARIF 2.1.0 sur ces éléments. Sortie 1 quand le build échoue. |
archec gen <main.arche> --target c-tests [-o generated] [--run] [--coverage] |
Les plans de test du modèle sous forme de tests unitaires C du C généré (qualité du code généré). Sous c-tests/ : les modules des composants, arche_tests.c (le harnais de difftest, avec les parts sur une horloge virtuelle et la latence des liens, plus une fonction par cas) et un Makefile (make test, make coverage). Le send(...) d’un cas, l’affectation d’une variable de part, part.state == "S", sent("MSG") et les expressions sont traduits ; un cas qui contient autre chose devient un SKIP qui dit pourquoi. --run les construit et les exécute (PASS/FAIL/SKIP par cas, sortie 1 quand l’un échoue) et écrit c-tests/results.json comme archec test écrit ses résultats. --coverage relit avec gcov les lignes exécutées et les traduit en états, transitions et fonctions couverts, présentés comme le fait archec test --coverage. |
archec gen <main.arche> --target c --defensive [-o generated] |
Du C défensif à partir du modèle (qualité du code généré) : les range de chaque message sous forme de <msg>_in_range() et, avec un déploiement, chaque entrée d’un binaire vérifiée au moment où elle est distribuée. Une valeur hors plage est rejetée (et non bornée). Une entrée silencieuse plus longtemps que le stale-after de son port (sinon la period de son message × 1,5) est marquée périmée (<binary>_input_stale()). Un mauvais checksum d’un format sur le fil, un counter répété (rejeté) ou qui saute (messages perdus, comptés) sont traités comme le fait AUTOSAR E2E. Chaque erreur est comptée dans arche_errors et journalisée une fois, jusqu’à ce que l’entrée redevienne bonne. À activer explicitement : cela change ce que voient les parts. |
archec gen <main.arche> --target trace-matrix [-o generated] [--results r.json]… |
La matrice de traçabilité (qualité du code généré), trace-matrix/matrix.md et matrix.csv : chaque exigence, les éléments du modèle qui la satisfont, le C généré pour chacun (fichier, ligne, fonction), les cas qui la vérifient et leur dernier résultat. Les résultats viennent des fichiers --results, sinon de arche-out/.archec/test-results.json (le simulateur d’Arche) et de <out>/c-tests/results.json (le C). Viennent ensuite les manques (aucun élément, aucun code, aucun cas, un cas en échec ou non exécuté). |
archec gen <main.arche> --target modelica [-o generated] |
Les systèmes dont les parts ont des équations ou des ports physiques, sous forme de package Modelica (modelica/<project>.mo) et d’un script OpenModelica par système (simulate_<System>.mos, résultats en CSV). Une part de std/physics devient le composant de la Modelica Standard Library 4.0 qu’elle représente (Resistor → Modelica.Electrical.Analog.Basic.Resistor, HeatCapacitor → Modelica.Thermal.HeatTransfer.Components.HeatCapacitor…). Les autres composants deviennent des modèles avec leurs équations, les ports physiques des connecteurs MSL, les signaux des RealInput/RealOutput, les liens des connect, et une fn main qui attend et affecte des clauses when. Chaque système reçoit une expérience tirée de ses plans de test et du pas de son solver. Le tableau complet, et ce qui est laissé de côté, se trouve dans physique. |
archec gen <main.arche> --target ui-lvgl|ui-slint [-o generated] [--deployment D] |
Chaque ui { } sous forme de code pour un équipement (ui). ui-lvgl : ui-lvgl/ui_<id>.c/.h pour LVGL 9, avec ses écrans, ses widgets, son thème, les liaisons lues dans la struct de la part de --target c (chaque message qu’elle lit est conservé par la part, les parts voisines sont copiées par le câblage) et les événements qui appellent les fonctions d’envoi de la part. S’y ajoute ui_<id>_task.c (écrit une seule fois : lv_init, votre écran, la boucle). Un binaire construit avec -DARCHE_UI le démarre. ui-slint : une crate par ui sous ui-slint/<id>/, avec le fichier .slint, le code de liaison Rust (Received, Sent, les événements) et un main.rs hôte en std (écrit une seule fois). Un élément qu’une cible ne produit qu’en partie fait l’objet d’une note ; aucun n’est abandonné. |
archec gen <main.arche> --list |
Les cibles : les cibles intégrées et les générateurs propres au projet (generator … { templates | script | command }), avec leur genre et l’endroit où ils écrivent. |
archec gen <main.arche> --target <generator> [-o generated] [--deployment D] [--option k=v]… [--check] |
Exécute un générateur à vous (générateurs) : le modèle du générateur en entrée, ses fichiers dans <out>/<output>/ (son identifiant par défaut), jamais en dehors, et jamais par-dessus un fichier existant qu’il marque keep. --option fixe l’une de ses options pour cette exécution (en JSON quand la valeur se lit comme du JSON). Ses problèmes sont affichés aux lignes des éléments ; sortie 1 en cas d’erreur. |
archec generator new <id> --templates|--script|--command [--label "…"] [--into main.arche] |
Un générateur qui fonctionne, comme point de départ : ses fichiers dans generators/<id>/, sa déclaration ajoutée au fichier. |
archec gen <main.arche> --target canopen|j1939|mavlink|someip|openapi|asyncapi [-o generated] [--deployment D] |
Des descriptions de protocoles (cibles d’intégration). canopen : un EDS CiA 306 par binaire sur un bus CAN, avec un PDO d’émission par trame qu’il envoie et un PDO de réception par trame qu’il reçoit (l’id de la route sert de COB-ID, la period de timer d’événement), et les messages en objets à partir de 0x2000, mappés à leurs bits. L’identifiant de nœud et l’identité viennent de attr canopen_node_id, vendor_id, product_code. j1939 : par bus avec des routes sur 29 bits, les groupes de paramètres (PGN, priorité, format PDU, destination ou extension de groupe, adresse source lue dans l’identifiant) avec un SPN par signal à sa position J1939, sa longueur, sa résolution et son décalage (attr spn sur le champ donne son numéro). mavlink : le catalogue sous forme de dialecte MAVLink 2 pour mavgen, avec un message par message et un champ par signal (les tableaux de scalaires en tableaux, les enums avec leurs entrées, les unités que MAVLink connaît). Les identifiants viennent de attr mavlink_id, sinon ils sont numérotés à partir de 65536 et listés. someip : les services SOME/IP en JSON, soit une interface que fournit un port (ses opérations en méthodes, les messages que son fournisseur envoie en événements), un port Ethernet qui publie, chaque instance avec son binaire et ses consommateurs, et les types de données. Les identifiants viennent de attr someip_service_id, someip_method_id, someip_event_id, sinon ils sont numérotés et listés. openapi : un document OpenAPI 3.1 par composant doté de handlers HTTP, avec une opération par handler, les paramètres de chemin, de requête et de corps tirés de sa fonction, et le type de retour comme réponse. asyncapi : un document AsyncAPI 3.0 par système, avec un canal par port émetteur sur son topic, des opérations d’envoi et de réception, et un serveur par bus. Ce que le modèle ne dit pas figure dans les notes. |
archec gen <main.arche> --target cmake|west|platformio|ci [-o generated] [--deployment D] |
Des systèmes de build autour du C de --target c, écrits dans le même dossier (cibles d’intégration). cmake : un projet par binaire C (son modèle en bibliothèque, son runtime POSIX sur un hôte, FreeRTOS en compilation croisée), un fichier de toolchain tiré du cœur de chaque microcontrôleur, port.cmake à vous pour le noyau, le démarrage et le script de liens, et cmake/CMakeLists.txt, qui construit tous les binaires C sur l’hôte. west : une application Zephyr par binaire sur une carte Zephyr, avec son CMake, prj.conf, l’overlay devicetree et un west.yml qui fixe les versions de Zephyr et de la HAL de la carte. platformio : un platformio.ini par binaire sur une carte que PlatformIO connaît, avec sa plateforme, sa carte et son framework, et le C comme sources. ci : un workflow GitHub Actions et un pipeline GitLab, avec archec check et archec ci, archec gen --check pour chaque cible qu’utilise le déploiement, le C construit avec CMake et exécuté, et chaque binaire Rust construit avec cargo. |
archec gen <main.arche> --target flash [-o generated] [--deployment D] |
Pour chaque binaire sur un microcontrôleur (le labo) : flash/<binary>/flash.sh [image], qui le flashe avec le premier outil installé de sa puce (STM32 : probe-rs, OpenOCD ; nRF52 : probe-rs, nrfjprog, OpenOCD ; RP2040 : picotool, probe-rs, OpenOCD ; ESP32 : espflash, esptool ; TOOL= permet de choisir), l’image venant du dossier target de cargo ou de build-<binary>/. Et flash/<binary>/monitor.sh, qui lit sa sortie --trace pendant ARCHE_DURATION secondes (pour un binaire C, depuis l’UART de la carte au débit du lien ; pour un binaire Rust, en defmt sur RTT avec probe-rs), puis lance dessus archec timing et archec live --replay. |
archec gen <main.arche> --target bench [-o generated] [--deployment D] |
Le banc de test matériel d’un déploiement (le banc) : bench/<deployment>.yaml, avec chaque bus (son type, son débit, l’interface du banc, les nœuds qui s’y trouvent et les trames qu’il transporte), les équipements sous test (leur carte, leur puce, leurs scripts de flash et de suivi), les alimentations et ce qu’elles alimentent, et les liens d’E/S. S’y ajoutent, par bus CAN, setup_<bus>.sh (SocketCAN à son débit, CAN FD, ou un vcan) et bench_<bus>.py (python-can : les trames nommées d’après le modèle et vérifiées par rapport à leurs périodes, --as <binary> pour remplacer un nœud absent, --interface virtual sans matériel). |
archec gen <main.arche> --target regmap [-o generated] |
La carte de registres de chaque part dotée de blocs memory adressés, dans regmap/<part>/ : un en-tête C (offsets, masques et décalages de champs, macros d’accès sur une base, static asserts sur la disposition), un banc de registres AXI4-Lite en VHDL et en SystemVerilog (registres rw/w en sortie, valeurs r en entrée, un strobe d’écriture par élément, les gros blocs en ports de RAM, valeurs de reset, SLVERR ailleurs), de l’IP-XACT (IEEE 1685-2014), du SystemRDL 2.0 et une carte mémoire en Markdown (cartes de registres). |
archec gen <main.arche> --target vhdl [-o generated] [--deployment D] |
Les composants FPGA du modèle (composants FPGA) en VHDL-2008, dans vhdl/ : un paquetage des données du modèle, une entité par composant avec une horloge (ses signaux et messages en ports, un processus cadencé, la machine à états en case, les corps en langage d’actions traduits avec leurs largeurs), la banque AXI4-Lite d’un composant aux blocs memory adressés, le top du système, un banc de test GHDL par cas de test, et sources.txt. Les régions USER CODE sont conservées. Extension : fpga. |
archec gen <main.arche> --target cpp [-o generated] [--deployment D] |
Du C++17 dans cpp/ : les constantes en inline constexpr, les enums en enum class, les unions en std::variant, les champs optionnels en std::optional, les messages en structs avec encode/decode sur la disposition binaire du C (les mêmes octets). Une classe par composant, avec ses variables, ses fonctions (corps ```arche et Python exprimable dans le langage d’action, traduits), sa machine à états sous forme d’enum class State et d’un switch (go_to, fire, sortie et entrée d’état, timers after, watchdogs, échéances), et ce qu’elle envoie en membres std::function. Avec un déploiement, un main.cpp par binaire qui indique language cpp (chaque binaire si aucun ne l’indique), avec un std::thread par thread du modèle, les liens internes au binaire câblés et les autres passant par hooks.cpp (à vous) ; et un CMakeLists.txt (C++). |
archec gen <main.arche> --list |
Les cibles : les cibles intégrées et les générateurs propres au projet (generator … { templates | script | command }), avec leur genre, les cibles après lesquelles ils s’exécutent (after) ou qu’ils lisent (builtins), l’endroit où ils écrivent et leurs options déclarées (type, valeur par défaut, valeurs possibles, rôle de chacune, valeur fixée quand ce n’est pas la valeur par défaut). |
archec gen <main.arche> --target <t> [--no-hooks] |
Les fichiers d’une cible passent par les hooks que le projet définit sur elle, c’est-à-dire les générateurs qui indiquent after <t> (une cible intégrée ou une cible du projet), dans l’ordre où ils sont écrits, avant d’être écrits ou vérifiés par --check. Chacun reçoit les fichiers et renvoie ce qu’il modifie (générateurs). --no-hooks : les fichiers de la cible tels quels. |
archec gen <main.arche> --target <generator> [-o generated] [--deployment D] [--option k=v]… [--check] |
Exécute un générateur à vous (générateurs) : le modèle du générateur en entrée, ses fichiers dans <out>/<output>/ (son identifiant par défaut), jamais en dehors, et jamais par-dessus un fichier existant qu’il marque keep. --option fixe l’une de ses options pour cette exécution (en JSON quand la valeur se lit comme du JSON ; selon le type de l’option quand elle en déclare un, et contrôlée par rapport à lui). Ses problèmes sont affichés aux lignes des éléments ; sortie 1 en cas d’erreur. |
archec generator new <id> --templates|--script [--ts]|--command [--label "…"] [--into main.arche] |
Un générateur qui fonctionne, comme point de départ : ses fichiers dans generators/<id>/, sa déclaration ajoutée au fichier. --ts : le script en TypeScript (generate.ts), typé par generator-model.v1.d.ts écrit à côté. |
archec generator types [-o generator-model.v1.d.ts] |
Le modèle du générateur et le ctx d’un script sous forme de déclarations TypeScript (schemas/generator-model.v1.d.ts), pour un script "gen.ts". |
archec gen <main.arche> --target <t> [--move <old>=<new>]… [--orphans ok] |
Si votre code se trouve dans une région que le nouveau code n’a plus, l’écriture s’arrête : rien n’est écrit, sortie 1, et chaque région orpheline est affichée avec les nouvelles régions auxquelles elle pourrait appartenir. --move place le code d’une région dans une autre ; --orphans ok le laisse partir dans <file>.orphans. Un renommage fait avec la commande Rename de l’éditeur ou avec archec refactor rename emporte le code de lui-même (arche.renames.json), et un renommage évident fait à la main est reconnu (régénération). |
archec refactor rename <main.arche> <element> <new-name> [--dry-run] |
L’élément renommé partout (sa déclaration, chaque référence, ses usages dans le code de son composant), comme le fait la commande Rename de l’éditeur, et enregistré dans arche.renames.json pour qu’archec gen reporte votre code sous le nouveau nom. |
archec gen <main.arche> --target <t> --diff |
Ce qu’une écriture changerait, sous forme de diff unifié (vos régions USER CODE reportées, comme lors d’une écriture). Rien n’est écrit ; sortie 1 quand quelque chose changerait. --check liste plutôt les fichiers. Le C, le Rust et le Go générés conservent le code placé entre les marqueurs USER CODE BEGIN <id> / END <id> à chaque nouvelle écriture. Une région que le modèle ne donne plus part dans <file>.orphans (régénération). |
archec generator model <main.arche> [--deployment D] [-o model.json] |
Le modèle du générateur, version 1 : ce que lit un générateur (schemas/generator-model.v1.json). |
archec generator test <main.arche> <id> [--update] [--expected dir] |
La sortie du générateur comparée aux fichiers que vous avez approuvés (expected/<id>/ à côté de sa déclaration) : chaque fichier manquant, modifié (à sa première ligne différente) ou nouveau. Sortie 1 en cas de différence. --update approuve la sortie telle qu’elle est. |
archec plugin list [main.arche] [--json] |
Les plugins trouvés : les plugins/<name>/plugin.arche du projet, les bibliothèques de kind plugin qu’il utilise (dont celles du Store), ARCHE_PLUGINS et les plugins intégrés à archec (lib/plugins). Pour chacun : sa provenance, les générateurs, importeurs et exporteurs qu’il apporte, leurs options et ce qui demande une approbation. Les erreurs dans les déclarations d’un plugin sont signalées (sortie 1). Sans projet : les plugins intégrés et ./plugins (plugins). |
archec plugin approve <main.arche> <plugin> [--revoke] |
Chaque script et chaque commande qu’apporte le plugin d’une bibliothèque, listés avec leur code, puis enregistrés un à un dans arche.lock à l’empreinte de la bibliothèque (acme/importer:kv, acme/exporter:x, acme/gen). Toute modification de la bibliothèque redemande l’approbation. |
archec fmi <main.arche> <System|Def> [-o dir] [--build] |
Une FMU de co-simulation FMI 2.0 des équations (les sources ; --build la compile et la zippe). Un réseau physique y entre trié et résolu, une boucle non linéaire par la méthode de Newton en C. Ses états, les variables des parts et les signaux out sont des sorties ; un signal in relié à rien est une entrée. |
archec kicad <main.arche> [System] [-o file.net] |
Le câblage d’un système sous forme de netlist KiCad (.net, le format s-expression que lit pcbnew). Chaque part qui a des signaux devient un symbole sans empreinte (une carte A1, les autres U1), avec pour broches celles de ses ports (uart2.TX/PA2, les wire d’un type de port, CAN_H/CAN_L, SDA/SCL, V+/GND). Il y a un net par signal : TX croisé avec RX, le même signal sinon, tout ce qui est sur un kind bus regroupé par signal (chassis_can_CAN_H), et toutes les masses GND sur un seul net. Le système est celui qui est nommé, sinon la plateforme du déploiement. Voir cartes. |
archec sysml <main.arche> [-o model.sysml] |
L’architecture en notation textuelle SysML v2. |
archec export <main.arche> [--json] [-o model.json] [--compact] |
Le modèle résolu sous forme d’un seul document JSON, pour les scripts. Chaque déclaration est un élément avec son identifiant (son chemin, Vehicle.ctrl ; pour une exigence, son propre identifiant ; pour un élément sans nom, l’identifiant et le genre de son parent, Vehicle/link1), son genre, son fichier et sa ligne, son parent et ses enfants, son type, sa définition, sa direction, son unité et ses propriétés. Une quantité s’écrit {"value": 10, "unit": "ms"}, un nom {"ref": "REQ-1", "id": "REQ-1"} avec ce qu’il désigne. Les extrémités de chaque lien et de chaque transition sont résolues. Les traces apparaissent une seule fois chacune, quelle que soit la façon dont elles ont été écrites (satisfies, verifies, derives, une trace, une exigence à l’intérieur d’un composant, et l’ancien satisfied-by). Les diagnostics sont inclus. Le document est écrit même en cas d’erreurs (sortie 1). Le paquet Python lib/python/archelang le lit : archelang.load("main.arche").requirements.untraced() (Python). |
archec export <main.arche> --format <exporter> [-o out.x] [--option k=v]… [--deployment D] |
Le modèle sous forme de fichier d’un autre outil, produit par l’exporter d’un plugin (le modèle du générateur en entrée, ses fichiers en sortie) : un seul fichier dans -o (ou sur stdout), plusieurs dans le dossier -o. Sans --format, l’extension de -o choisit l’exporteur dont c’est l’extension ; -o model.json reste le JSON. Ses problèmes sont affichés aux lignes des éléments. Le script d’une bibliothèque ne s’exécute qu’une fois approuvé (plugins). |
archec api serve <main.arche> [--port 9000] [--host 127.0.0.1] |
Le modèle servi par l’OMG Systems Modeling API (SysML v2 REST/HTTP), en lecture seule, pour un outil SysML v2 ou un script : /projects, sa branche, /commits (l’historique git du dossier du projet, du plus récent au plus ancien, avec les fichiers tels qu’ils sont quand ils diffèrent ; un modèle hors de git forme un seul commit), /tags (chaque baseline, au commit qui l’a ajoutée), /commits/{c}/elements[/{e}], /roots, /elements/{e}/relationships?direction=in|out|both, et POST /query-results avec une Query (PrimitiveConstraint : property, operator = < <= > >= instanceOf, value, inverse ; CompositeConstraint and/or ; select, scope). Les listes sont paginées par page[size], page[after], page[before], avec un en-tête Link. L’@id d’un élément est le même dans chaque commit. Les éléments sont typés comme les écrit archec sysml (une définition en PartDefinition, une part en PartUsage, un port en PortUsage, un lien en ConnectionUsage, une exigence en RequirementUsage, une trace en Dependency), avec sous arche ce qu’archec sait de chacun (son identifiant, son genre, son fichier, sa ligne, ses propriétés). ?kind= et ?type= filtrent /elements (ce sont des ajouts d’archec). Les appartenances entre éléments ne sont pas des éléments : owner et ownedElement expriment directement la possession. |
archec capella <main.arche> [-o dir|project.zip] |
Un projet Capella 6.1 (un niveau Arcadia par layer), vérifié par rapport au métamodèle de Capella. Ce que Capella ne peut pas contenir est listé. |
archec capella <model.capella|folder|project.zip> [-o dir] [--prefix p] [--layers oa,sa,la,pa,epbs] [--no-diagrams] [--project dir] |
Un modèle Capella en arche-lang, en passant par le projet Arche que produit l’import Capella de l’application. |
Pour aller plus loin#
Python#
lib/python/archelang lit un modèle dans un script ou un notebook, via archec export --json
(bibliothèque standard uniquement ; pandas pour les tableaux, s’il est installé) :
import archelang # pip install -e lib/python, or PYTHONPATH=lib/python
m = archelang.load("examples/autonomous-car/main.arche")
m.requirements.unverified() # [<requirement REQ-SAF-001 …>, …]
m["REQ-BRK-001"].satisfied_by # [<component Adcu …>]
m["Car.brakes"].ports # a part's ports, its definition's
m.find(kind="port", direction="in")
m["REACTION_TIME"].value # Quantity(value=150, unit='ms')
m.requirements.to_dataframe() # with pandas
m["REQ-BRK-001"].set("priority", "high") # archec edit: written only if it adds no error
Chaque élément a son identifiant, son genre, son label, son fichier et sa ligne, son parent et ses
enfants, ses propriétés (el.period, el.prop("stale-after")) et ses traces (satisfies,
verified_by, derives…). Les liens et les transitions ont leur source, leur target et les parts
sur lesquelles ils se trouvent. archelang trouve archec dans le PATH, ou bien ARCHEC le nomme.
examples/brake-by-wire/model.ipynb est un court notebook.
L’API SysML v2#
archec api serve main.arche sert le modèle par l’OMG Systems Modeling API (l’API REST de SysML v2),
en lecture seule : le projet, ses commits (l’historique git du dossier du modèle, avec les fichiers tels
qu’ils sont), ses baselines sous forme de tags, les éléments à chaque commit, leurs relations, et des
requêtes.
archec api serve examples/autonomous-car/main.arche --port 9000
curl -s localhost:9000/projects
curl -s -X POST localhost:9000/projects/<id>/query-results \
-d '{"@type":"Query","where":{"@type":"PrimitiveConstraint","property":"@type","operator":"=","value":"RequirementUsage"}}'