Guides pratiques › Utiliser VS Code

Guides pratiques

L’extension VS Code

L’extension fait de VS Code un éditeur de modèles arche-lang. Elle vérifie le modèle pendant la saisie, complète et explique les noms, dessine le système à côté du texte et exécute pas à pas un test simulé. Cette page liste ce qu’elle fait une fois installée. Le README explique comment l’installer.

Premier aperçu#

Installez l’extension depuis le dossier arche-lang :

npm install
npm run package          # → arche-lang.vsix
code --install-extension arche-lang.vsix

Pour la CAO (la CAO en code), installez plutôt la version faite pour votre machine. Elle embarque le moteur de CAO et marche sans réseau :

node tools/cad/package.mjs darwin-arm64   # → arche-lang-darwin-arm64.vsix (about 270 MB)
code --install-extension arche-lang-darwin-arm64.vsix

Les cibles sont darwin-arm64, darwin-x64, linux-x64, linux-arm64 et win32-x64. Le script télécharge un Python portable et les wheels du moteur. Chacun est vérifié contre une empreinte fixée. Aucun des deux n’est gardé dans git.

Ouvrez ensuite un dossier qui contient un main.arche, par exemple ce modèle, avec une faute de frappe à la dernière ligne :

message GO: bool

component Lamp "Lamp" {
  in cmd: can receives GO
}

component Button "Button" {
  out click: can sends GO
}

system Room "Room" {
  part lamp: Lamp
  part button: Button
  button.click -> lamp.cdm
}

lamp.cdm est souligné en rouge, avec le message qu’affiche archec check :

Cannot find 'lamp.cdm' in Room. Did you mean 'lamp'? [unresolved]

L’ampoule qui apparaît dessus (Ctrl+. ou Cmd+.) propose Change to 'cmd'. Appuyez sur ⌘K V pour voir le diagramme : deux blocs et le lien qui les relie.

Lire et écrire#

  • Coloration :

    • les mots-clés, les déclarations et les unités (50ms, 2Mbps) ;
    • le LaTeX entre $…$, le Python dans les blocs ```python, le YAML dans les blocs ```yaml ;
    • les blocs ```arche dans le Markdown aussi.

    Un corps ```arche est coloré comme le langage d'action : var, if/while/for, send port MSG { field: … }, goto State, les fonctions intégrées, les appels et les opérateurs. Il est aussi coloré selon le sens : les variables du composant, ses fonctions et ses ports, un message et ses champs, un paramètre, une variable locale. Le réglage arche.bodies.highlight ajoute un léger fond derrière chaque corps.

  • Diagnostics en direct : les erreurs de syntaxe et l’ensemble des vérifications du lint, à travers les include. Un fichier est vérifié dans le contexte du fichier qui l’inclut.

  • Correctifs rapides pour chaque « did you mean …? ». La page Correctifs les liste.

  • Un nom venu d’un fichier que vous n’avez pas inclus : part h: Heater, avec Heater déclaré dans lib.arche, le signale : 'Heater' is declared in lib.arche, which this model doesn't include. Le correctif rapide préféré est Include "lib.arche". Il ajoute la ligne après les autres includes du fichier. Un nom que le store possède, comme Pid ou Bme280, reçoit Use Pid from arche-algorithms : il ajoute le uses et l’include. Le projet est le dossier du fichier principal et ses sous-dossiers, sans node_modules, .arche, out, build, arche-out, dist ni les dossiers cachés. archec check dit la même chose, et archec fix ajoute l’include quand un seul fichier porte ce nom.

  • Ce qui prouve chaque exigence : une ligne au-dessus de chaque requirement dit ce qui la prouve aujourd’hui, comme archec status : proved by 3 tests · timing on board nucleo-f446re ✓ · 2 h ago, out of date: Thermostat.update changed ou nothing proves it. Elle lit les preuves qu’enregistrent archec test, verify, timing et replay, et suit le modèle pendant la saisie. Un clic affiche l’état complet de cette exigence dans la sortie Arche Status. Show Requirement Status les affiche toutes (status).

  • Complétion de ce qui convient à l’endroit où vous êtes :

    • les mots-clés et les propriétés du bloc courant ;
    • les membres après . : adcu. donne ses ports, ses fonctions et ses enfants, y compris ceux de sa définition ;
    • les messages après sends [, les types de port après port x:, les types après var x:, les états dans les transitions et les chemins d’include ;
    • après part x:, les cartes du store et de vos collections, avec le fabricant et la référence. Si vous choisissez une carte que le modèle n’inclut pas encore, son include et le uses du projet sont ajoutés aussi ;
    • après part x:, un type ou un type de port, aussi les noms des fichiers du projet que le modèle n’inclut pas encore, et les algorithmes du store. Chacun dit d’où il vient (lib.arche — adds include, store: arche-algorithms — adds uses + include). Ils viennent après ceux du modèle, seulement ceux qui commencent comme ce que vous avez tapé, quelques-uns au plus. En choisir un ajoute l’include, et le uses pour le store ;
    • dans pins { … }, les rôles, puis les broches de la carte et ce à quoi chacune est reliée ;
    • dans une part d’une carte, ses connecteurs avec leurs broches.
  • Survol : sur un nom, il affiche sa déclaration, sa documentation et ses ports, fonctions ou champs. Sur un mot-clé ou une propriété, il affiche la documentation et un exemple.

    • Sur une carte, ou sur une de ses parts : le fabricant, la référence, l’URL, ses processeurs (cœur, horloge, mémoire), ses connecteurs et les broches auxquelles ils sont reliés.
    • Sur une broche dans pins { … } : la puce qui la porte et ce que la carte y relie. Un nom de broche que la puce de la carte ne possède pas donne un avertissement (board-pin), avec le nom le plus proche en correctif rapide.
  • Aide à la signature dans les corps :

    • pendant que vous construisez un message, ses champs avec leurs types, unités et plages. Le champ en cours de saisie est mis en évidence. Cela marche pour BRAKE_CMD { force: … } dans un corps ```arche et pour BRAKE_CMD(force=…) en Python ;
    • sur send port MESSAGE (ou send(port, message)) : d’abord les ports qui envoient, puis les messages que porte le port.
  • Navigation : aller à la définition, trouver les références, renommer à travers les fichiers, plan du fichier, symboles de l’espace de travail (⌘T), mise en forme du document. Un fichier .arche est mis en forme quand vous l’enregistrez (seulement l’indentation et les espaces en fin de ligne) ; pour le désactiver, mettez "[arche]": { "editor.formatOnSave": false } dans vos réglages.

    Tout cela marche aussi dans un corps ```arche, selon la nature de chaque nom. Ctrl+clic sur got mène à la var got du composant ; sur bump(), à sa fn bump ; sur send o TRACK { id: … }, au port, au message et à son champ. Un paramètre mène à la signature de la fonction, et une variable locale à sa var.

    Renommer le champ d’un message le renomme aussi dans les enregistrements des corps. Un paramètre du même nom n’est pas touché. Renommer un paramètre ou une variable locale reste limité à son corps.

  • Move Definition to a File… : clic droit sur une définition de premier niveau (un composant, un message, une struct, une exigence, un système…) ou sur une de ses utilisations (part a: Pump), ou sur un bloc du diagramme ; aussi sous Refactor…. Choisissez New file… ou un fichier du projet : la déclaration y part avec ses lignes ///, le fichier est inclus s’il ne l’est pas encore, et rien n’est fait si le projet ne reste pas le même. Une seule annulation revient en arrière. La ligne de commande l’offre sous la forme archec refactor move-definition (commands/refactor.md).

  • Modèles en JavaScript et TypeScript : un test peut contenir un modèle sous la forme archeSrc`…` (de test/helpers.js, avec ses délimiteurs écrits \`\`\`). L’extension le colore comme de l’arche, et Ctrl+clic et le survol marchent sur ses noms. Chaque chaîne est compilée comme un modèle à part entière. Le réglage arche.embedded.problems affiche ses erreurs dans la vue Problems. Il est désactivé par défaut, car le modèle d’un test peut être faux exprès.

  • Indications en ligne (inlay hints) : ce qu’archec a calculé, affiché en fin de la ligne qui le donne. Par exemple :

    • 2 * TICK + 500us = 2.5ms, 2.5kHz = 400us period, period TICK = 1ms ;
    • component LidarFront extends Lidar inherits ports cloud, power ;
    • budget power 10W = 8.5W of 10W : le cumul calculé par le vérificateur, avec ⚠ en cas de dépassement ;
    • un thread de déploiement R=200us/D=1ms : l’analyse temporelle ;
    • part s: Sensor[N] = 4 parts.

    Une simple quantité n’a pas d’indication. Le réglage arche.inlayHints.enabled les désactive.

  • Indications d’étagère : une indication discrète (un léger soulignement, pas un avertissement) là où le modèle écrit à la main ce qu’une étagère du store a déjà : une fonction qui ressemble à un PID, à un anti-rebond ou à un CRC, un message dont les champs sont un Vec3 ou un GeoPoint, un composant nommé comme un appareil du store. L’indication dit à quoi cela ressemble et pourquoi. Son correctif rapide ajoute le uses et l’include. Pour un message ou une structure dont les champs ont exactement les mêmes noms et types, il le remplace aussi (message ACCEL: Vec3). Une fonction écrite à la main n’est jamais remplacée : l’indication dit quelle pièce ajouter et quoi appeler. Les indications sont actives au niveau débutant (le réglage arche.level, ou le level simple d’un projet) et inactives sinon. arche.suggestions (auto, on, off) décide. archec suggest liste les mêmes dans un terminal.

  • Coloration sémantique : chaque nom est coloré selon ce qu’il désigne. C’est une définition, une part, un port, un message ou un type, une exigence, un état, une fonction, une variable ou une constante, un déploiement, ou un thread. L’unité d’une quantité est colorée à part de son nombre. La grammaire colore toujours le reste.

  • arche-lang affiché comme texte est coloré aussi : les blocs ```arche d’un aperçu Markdown (une explication, les patterns, un README), le code d’une fiche d’étagère et la page d’une carte, l’inspecteur de l’aperçu d’ui et le code de la spécification (archec doc --html), dans les couleurs claires ou sombres du thème de l’éditeur. Les mots sont ceux de la grammaire, comme sur le site web.

Les fichiers de code : les noms d’Arche en Python et en TypeScript#

Les fichiers de code d’un modèle (code "ctrl.py", code "sensor.ts") utilisent des noms que leur donne Arche : ses fonctions d’aide (wait, send, goto…) et les messages, composants et constantes du modèle. Pylance et le TypeScript de VS Code doivent connaître ces noms. L’extension les leur donne, et n’écrit rien à côté de votre code : pas d’arche.py, pas d’arche.d.ts, pas de tsconfig.json.

Les noms sont rangés à un seul endroit par projet, .arche/typings dans le dossier du fichier principal :

Fichier Ce qu’il contient
.arche/typings/arche/__init__.pyi Les fonctions d’aide d’Arche, typées. Le même texte pour tous les modèles.
.arche/typings/arche/_model.pyi Les messages et les constantes de ce modèle.
.arche/typings/arche.d.ts La même chose pour TypeScript : l’API, un type par message et par composant.
.arche/typings/project.json Le fichier principal et les fichiers de code que nomme le modèle.
.arche/typings/.gitignore Fait ignorer le dossier par git. Aucun .gitignore à vous n’est modifié.

Les fichiers Python sont là quand le modèle a des fichiers .py, arche.d.ts quand il a des fichiers .ts. Un fichier n’est réécrit que si son texte change.

L’endroit ne dépend que du nom du fichier principal. Pour main.arche, c’est .arche/typings. Pour tout autre fichier principal, c’est .arche/typings/<name> : bench.arche a .arche/typings/bench/arche/… et .arche/typings/bench/arche.d.ts. Deux fichiers principaux d’un même dossier n’écrasent donc jamais les fichiers l’un de l’autre.

  • Python. L’extension fixe une valeur par défaut pour Pylance (et basedpyright) : python.analysis.extraPaths vaut [".arche/typings/_workspace", ".arche/typings"]. Vous n’écrivez aucun réglage. from arche import * se résout, et les noms sont complétés et vérifiés avec leurs types.

    Un serveur de langage Python lit un seul paquet arche par dossier de l’espace de travail. Quand ce dossier est celui d’un unique main.arche, c’est le paquet propre au projet. Dans tous les autres cas, l’extension écrit aussi .arche/typings/_workspace/arche/ à la racine du dossier de l’espace de travail. Ces cas sont un projet dans un sous-dossier, plusieurs projets, ou un fichier principal qui porte un autre nom. Ce paquet contient les noms de tous les modèles du dossier. Quand deux modèles déclarent le même nom, c’est la déclaration du premier modèle qui est retenue (les modèles sont triés par chemin). Si chaque projet ne doit voir que ses propres noms, ouvrez chaque projet comme son propre dossier d’espace de travail, ou utilisez arche.editorStubs: beside.

    La valeur par défaut ne s’applique pas quand vous fixez vous-même python.analysis.extraPaths, ni quand le dossier a un pyrightconfig.json ou une table [tool.pyright]. Ajoutez alors .arche/typings à votre propre extraPaths.

  • TypeScript. L’extension apporte un plugin pour le serveur TypeScript. Pour un fichier d’un projet Arche, le plugin ajoute l’arche.d.ts du modèle au projet TypeScript et y résout "arche" (et "./arche"). Un fichier lit l’arche.d.ts du modèle qui le nomme dans project.json. Un fichier qu’aucun modèle ne nomme encore lit le plus proche au-dessus de lui. Go to Definition sur send ouvre le fichier dans .arche/typings. Sans tsconfig.json à vous, les fichiers ne sont pas vérifiés en mode strict, comme avant. Avec un tsconfig.json, vos options sont conservées. La version de TypeScript propre à un espace de travail charge aussi le plugin.

  • Les stubs des versions précédentes. Les versions précédentes de l’extension écrivaient arche.py, arche.d.ts et un tsconfig.json à côté du code. Une fois par espace de travail, elle les supprime et dit combien. Elle ne supprime un arche.py ou un arche.d.ts que si le fichier commence par la ligne « Generated by archec » d’archec, et un tsconfig.json que s’il est exactement celui qu’archec a écrit. Elle ne regarde que dans les dossiers qui contiennent un fichier .arche, et dans les dossiers en dessous. Un fichier que vous avez écrit ou modifié n’est jamais supprimé.

  • Le réglage arche.editorStubs :

    • project est la valeur par défaut, décrite plus haut ;
    • beside écrit arche.py, arche.d.ts et tsconfig.json à côté du code, comme avant, et supprime .arche/typings ;
    • off n’écrit et ne supprime rien.
  • En ligne de commande, archec stubs main.arche écrit les mêmes fichiers au même endroit. Voir python.md pour pyright et mypy.

Le diagramme#

  • Diagramme sur le côté (⌘K V, ou le bouton de diagramme dans le titre de l’éditeur). Il est dessiné dans le thème du canevas d’Arche, clair ou sombre, selon VS Code. Le réglage arche.diagram.theme en impose un. Il montre :

    • les blocs du système, avec leurs ports en points colorés ;
    • les liens, avec des étiquettes en pastille ;
    • chaque machine à états et chaque scénario.

    Il reprend vos positions quand chaque part en a une : les lignes canvas, ou at sur une part. Sinon, il place les blocs lui-même ; Layout passe de l’un à l’autre. Il se met à jour pendant la saisie et suit le curseur.

  • Les actions d’Arche sur le dessin, comme sur le canevas d’Arche. Chacune modifie votre source .arche, en une seule étape que vous pouvez annuler.

    • Cliquez sur un bloc, un port, un lien ou un état. Il est sélectionné, ce qui n’y est pas relié s’estompe, et la source s’affiche. Le panneau des propriétés montre son identité : Rename… (partout, via le serveur de langage), nom, description, genre, couche, couleur, étiquettes. Pour un port : sa direction, son type, ce qu’il envoie et reçoit. Pour un lien : son nom, ses messages et Flip.
    • Faites glisser un bloc pour le déplacer. Cela écrit sa ligne dans le bloc canvas du système s’il existe, et sinon at x, y sur la part. Sur une disposition automatique, le premier déplacement garde chaque bloc à sa place.
    • Faites glisser d’un port à un port pour les relier. Dans une machine à états, faites glisser d’un état à un autre pour ajouter une transition.
    • Double-cliquez sur un bloc pour y entrer, ou sur un lien pour le nommer. Suppr efface la sélection. + ajoute une part, ou un état.
  • Étapes tirées du code : app -> core : init expand dessine, après l’étape, l’arbre des appels de init. expand 2 descend de deux appels.

    Une fonction dotée d’un corps ```arche dessine ce que fait son corps :

    • chacune de ses propres fonctions qu’elle appelle ;
    • chaque port.op(…), comme une étape vers la part à l’autre bout du lien, avec sa réponse en pointillés. Il n’y a pas de réponse pour une opération oneway ou qui ne rend rien ;
    • chaque send, comme un message ;
    • un if comme un alt, ou un opt s’il n’a pas de else ; un while ou un for comme un loop. Chacun porte son propre texte en étiquette ;
    • ce qui n’appelle rien est laissé de côté.

    Un clic sur une telle étape ouvre la ligne du corps d’où elle vient.

    Pour un corps en Python ou en TypeScript, et pour la fonction d’un enfant (qu’un corps ne peut pas appeler), le diagramme dessine les calls de chaque fonction. Une fonction marquée parallel dessine ses appels sous la forme d’un par.

    Deux vérifications l’accompagnent. Un calls g que le corps ```arche ne fait jamais donne une indication (calls-not-in-body). Une étape d’un composant vers un composant qu’il contient, qu’aucune de ses fonctions n’appelle via calls, donne un avertissement (seqstep-not-called).

  • Les longs scénarios, une page à la fois : un scénario de plusieurs séquences les montre toutes, ou une seule. Le sélecteur de séquence en montre une, avec seulement les lignes de vie qu’elle atteint.

    • Une étape ref other est une boîte posée sur les lignes de vie que couvre sa séquence. Un clic ouvre cette séquence seule ; ◂ Back revient en arrière.
    • Un clic sur la bande d’un composite replie ses enfants en une seule ligne de vie. fold Sys.comp sur une séquence, ou sur le scénario, la replie dès le départ.
    • Un clic sur l’onglet d’un fragment (▾ alt) le replie en une seule ligne : ▸ alt — 5 steps, folded. folded dans le fragment le fait démarrer fermé.
    • Survolez une constante qui liste ce dont chaque ligne a besoin (SERVICES, ou [SERVICES] dans un texte) pour voir sa matrice : une ligne par entrée, une colonne par élément dont elle peut avoir besoin.
  • La palette, à gauche du diagramme (‹ la masque). Elle contient :

    • les éléments de base : composant, part, port d’entrée et de sortie, fonction, lien, état ;
    • les cartes du store de cartes et de vos collections ;
    • les paquets de l’Arche Store configuré (arche.store) ;
    • un champ de recherche (esp32 can).

    Faites glisser un élément sur le canevas, ou cliquez dessus pour l’ajouter au milieu :

    • un composant ou une part se place là où il tombe ;
    • un port ou une fonction va sur le bloc sous le pointeur ;
    • une carte est ajoutée comme l’écrit archec board add : sa part, son include et le uses de sa collection. Si le diagramme ne montre aucun système matériel, elle va dans un nouveau ;
    • un paquet du store est ajouté une fois que vous avez accepté le code qu’il apporte. Il est installé dans .arche/store ; viennent ensuite son uses, son include et une part de son composant principal.

    La section User interface contient un Screen, un Dialog, un Overlay, les dispositions et les éléments d’un ui { }. Déposés sur un bloc, ils vont dans l’ui de sa définition.

    Chaque dépôt est une modification que vous pouvez annuler. L’info-bulle de chaque élément dit ce qu’il est et comment il s’écrit. Vous pouvez aussi faire glisser des cartes et des paquets depuis les vues Store Shelves et Store.

  • Formulaires de propriétés, sous le panneau des propriétés. Une part, un composant ou un port sélectionné a un champ pour chaque propriété que prend sa déclaration. Les champs viennent de la description du langage (src/spec.ts). Ils sont groupés comme le langage les groupe : calcul, temps, livraison, physique, produit, intégrité, traçabilité. Un champ est :

    • une liste déroulante pour un choix (os, pattern), ou pour les noms visibles (exigences de satisfies, variants) ;
    • une case à cocher pour oui ou non ;
    • un nombre et une unité pour une quantité (power 15W, latency 2ms).

    Chaque champ a pour aide la documentation de la propriété. Une valeur est vérifiée avant d’être écrite : un nombre, une unité de cette quantité, un nom déclaré. L’erreur s’affiche sous le champ.

Le débogueur de simulation#

Lancez-le avec Run › Start Debugging, ou avec Debug Test sur un cas dans la vue Testing. Un cas de test s’exécute en simulation avec arche-cli, et vous parcourez son exécution événement par événement.

  • La pile d’appels est l’événement, à la ligne qui le concerne :
    • un message, à la fonction qu’il a exécutée, à la transition qu’il déclenche, ou à la ligne du cas qui l’a envoyé ;
    • un changement d’état, à l’état ;
    • une attente, à sa ligne expect.
  • Variables contient le temps, l’événement (message, source, destination, fonction), l’état de chaque composant, les attentes vérifiées jusqu’ici et le nombre d’envois de chaque message. Survolez ou surveillez time, adcu.state ou sent("BRAKE_CMD").
  • Les points d’arrêt se posent sur les lignes .arche. Une attente qui échoue arrête l’exécution (Failed expectations and errors).
  • Le pas à pas : step over passe à l’événement suivant, et step out à l’instant suivant. Le retour arrière (step back, reverse continue) marche aussi, puisque l’exécution est enregistrée.

Une entrée de launch.json ressemble à ceci :

{ "type": "arche", "request": "launch", "program": "${workspaceFolder}/main.arche", "case": "TP-AEB/TC-AEB-01" }

Sans case, vous en choisissez un. Avec "trace", le débogueur rejoue de la même façon une trace exportée depuis l’application Arche.

Un arche-cli récent garde les enregistrements de la trace avec --trace (PLAN__CASE.trace.json, écritures de variables comprises). Une exécution a donc aussi une portée Variables : les variables de chaque composant telles qu’elles sont au moment de l’événement.

Pourquoi ? et Pourquoi pas ?#

Arrêté sur un événement, appuyez sur Why? (le point d’interrogation de la barre de débogage, ou le menu de la pile d’appels). Les causes de l’événement s’ouvrent en liste, jusqu’à leur point de départ : la transition et les valeurs de sa garde, le message et l’endroit du modèle qui l’envoie, le thread qui l’a envoyé. Chaque ligne a son temps, et en choisir une ouvre sa ligne dans le modèle (why.md).

Hors du débogueur, deux commandes demandent d’abord une exécution : un cas de test, exécuté sur le simulateur d’archec, ou un fichier de trace de la carte (archec gen --trace).

  • Arche: Why Did This Happen? liste ensuite la chronologie de l’exécution, pour y choisir un événement.
  • Arche: Why Did This Not Happen? (aussi dans le menu contextuel de l’éditeur) prend la transition sous le curseur, ou une que vous choisissez. Elle dit si son état n’a jamais été actif, si son déclencheur n’est jamais venu ou si sa garde n’a jamais été vraie, et à quel point les valeurs en ont été proches.

Les mêmes réponses vont dans la sortie Arche.

Bien démarrer#

  • Get started with arche-lang (Help › Welcome › Walkthroughs, ou Arche: Get Started with arche-lang). Ses étapes : comprendre les concepts, créer un projet, ajouter un composant, ajouter une carte depuis la palette, câbler un capteur, lancer la simulation, générer du C. Chaque étape se coche toute seule quand le modèle (ou l’espace de travail) montre qu’elle est faite. La première se coche dès que l’aide-mémoire est ouvert. arche-lang: Show Cheat Sheet ouvre l’aide-mémoire à tout moment.
  • Convert to arche body : un corps ```python qui ne dit que ce que dit le langage d’action reçoit une indication. Ce correctif rapide le réécrit en corps ```arche (correctifs).

La barre latérale et les commandes#

  • Barre latérale Arche : cliquez sur l’icône Arche dans la barre d’activité. Vous parcourez le modèle comme dans l’application Arche :

    • Model : systèmes → composants → ports, fonctions, variables, mémoire, machine à états, exigences. Puis les définitions, messages, types de données, constantes, exigences, acteurs, missions, scénarios, plans de test, traces, catalogues.
    • Files : l’arbre des include.
    • Store Shelves (anciennement Boards) : les six étagères du store — types, unités, cartes, pilotes de périphériques, capteurs et actionneurs, algorithmes. Une pièce montre son résumé d’une ligne. Un clic ouvre sa fiche (les sept lignes, ce qu’elle écrit, la courbe de réponse d’un algorithme) avec Add to This Project, comme archec shelf add. Une carte ou un appareil demande où il va, comme Add Board to Model… et Add Device to Model…. Filter Shelves… filtre toutes les étagères par un mot (étagères, cartes).
    • Store : les paquets de l’Arche Store (store).

    Un clic mène à la source. Les boutons en ligne ouvrent le diagramme et ajoutent une part. Le clic droit propose Add part / port / function / state, Rename…, Set name…, Set kind… et Delete. L’arbre suit le modèle du fichier que vous modifiez ; Select the model to browse en fixe un.

  • Commandes (⇧⌘P → « Arche ») :

    • Build Project, aussi le bouton ▶ dans le titre de l’éditeur ;
    • Export LaTeX Specification… ;
    • Open in Arche : lance arche --project … et ouvre le navigateur ;
    • Validate Project Folder… ;
    • Show Pattern Reference ;
    • Show Requirement Status : ce qui prouve chaque exigence, dans la sortie Arche Status (status) ;
    • Run Test Ladder… : archec test --ladder, une ligne par échelon dans la sortie Arche Status. La carte seulement si vous la choisissez. Un échelon dont l’outil n’est pas installé (Renode, probe-rs) est sauté ;
    • Run FPGA Tests in GHDL : archec test --target vhdl, les cas de test sur le VHDL des composants FPGA du modèle (composants FPGA), avec le GHDL que fournit la version de l’extension pour la plateforme ;
    • Synthesise FPGA Design : archec synth, les composants FPGA synthétisés, placés et routés pour le circuit du modèle : ses cellules et la fmax de chaque horloge, dans la sortie Arche Status. Les outils ne sont pas dans l’extension : archec synth --install-tools dit où les trouver ;
    • Prove a Fix Against a Git Ref… : archec test --against <ref>. Un cas qui échoue sur la version plus ancienne et passe ici prouve le correctif ;
    • Check Board's Build from Trace… : archec status --build <trace>. Le firmware qui a écrit la trace est-il bien la version de ce modèle ?

Réglages#

Réglage Rôle
arche.outputDirectory Où Build Project écrit le projet Arche. Par défaut arche-out. Dans un espace de travail à plusieurs projets, chacun se construit dans son propre sous-dossier, arche-out/<project folder>.
arche.entry Le fichier .arche principal de l’espace de travail. Vide : le fichier que vous modifiez, ou le fichier qui l’inclut.
arche.paths.app L’application Arche que lance Open in Arche. Faites-le pointer sur arche/dist/arche-darwin-arm64. Vide : arche dans le PATH.
arche.port Le port sur lequel Open in Arche sert l’application.
arche.buildOnSave Reconstruit le projet Arche à chaque enregistrement d’un fichier .arche.
arche.lint.minimumSeverity La plus faible gravité affichée dans la vue Problems.
arche.format.indent Le nombre d’espaces par niveau d’indentation.
arche.diagram.theme Les couleurs du diagramme : auto, light ou dark.
arche.suggestions Les indications d’étagère : auto (actives au niveau débutant, par défaut), on ou off.
arche.editorStubs Où sont écrits les noms d’Arche pour les outils Python et TypeScript : project (dans .arche/typings, par défaut), beside (à côté du code, comme le faisaient les versions précédentes) ou off.

Limites#

  • Une exécution dans le débogueur compte au plus 50 000 enregistrements.
  • Avec un arche-cli plus ancien, le débogueur ne garde que la vue en séquence. Il n’y a pas de valeurs de variables, un changement d’état est daté à l’événement qui le précède, une exécution compte au plus 2000 événements, et seule l’exécution d’un cas en échec est gardée. Le débogueur construit sa propre copie du projet et ajoute une dernière étape qui échoue exprès (expect False). Cette étape n’est pas affichée, et un cas qui passe est signalé comme réussi.
  • VS Code demande de maintenir Maj pour déposer dans le diagramme une carte ou un paquet venu des vues Store Shelves et Store.
  • Les erreurs d’un modèle contenu dans un test JavaScript ou TypeScript ne sont pas affichées, sauf si arche.embedded.problems est activé.