Guides pratiques › Modéliser les interfaces

Guides pratiques

L’interface utilisateur du produit

Un produit a souvent un écran : le tableau de bord d’une voiture, la dalle tactile d’une machine, le petit afficheur d’un capteur. Avec arche-lang, vous décrivez cet écran dans le modèle, à côté de ce qu’il affiche. Le composant qui possède l’afficheur reçoit un bloc ui { }. Chaque jauge, chaque texte et chaque bouton y est lié au modèle : une variable, un message que la part reçoit, ou l’état d’une part voisine. Quand le modèle change, archec vous dit ce qui ne correspond plus à l’écran.

Cette page est un guide. Chaque mot et chaque propriété se trouvent dans la référence du langage. archec explain ui liste les vérifications.

Un premier écran#

component Dashboard "Driver display" {
  in bus:     data receives STATUS, BRAKE_FAULT
  out cmd:    data sends ENGAGE_REQ, STOP
  var lights: bool = false

  ui {
    display 800x480
    input touch
    theme dark

    screen Driving "Driving" {
      row {
        gauge speedo "Speed" { value bus.STATUS.speed }
        label mode { text "Mode: ${ctrl.state}" }
      }
      row {
        button engage "Engage" { enabled ctrl.state == Ready; on press send cmd ENGAGE_REQ(true) }
        button stop "Stop" { style danger; on press send cmd STOP(true) }
        button settings "Settings" { on press goto Settings }
      }
    }

    screen Settings "Settings" {
      toggle lights "Lights" { value lights }
      button done "Done" { on press back }
    }

    overlay Warnings {
      telltale brake "Brake fault" { on bus.BRAKE_FAULT; color amber }
    }
  }
}

Lisez-le de haut en bas :

  • Le matériel : display 800x480 (en pixels), input touch (ou encoder, keys, pointer), theme dark (ou light). Avec dpi 160, archec peut vérifier que les boutons sont assez grands pour un doigt. Sans display, archec prend l’afficheur de la carte sur laquelle la part est construite (son hardware { display … }).
  • Les écrans : ce que l’afficheur montre à un instant donné. L’interface démarre sur le premier, ou sur celui que nomme initial Settings. goto Settings et back passent de l’un à l’autre. Un dialog s’affiche par-dessus l’écran courant jusqu’à ce qu’on le quitte. Un overlay s’affiche par-dessus tous les écrans : c’est la place des alertes.
  • La disposition : row (côte à côte), column (l’un sous l’autre), grid (columns 3), stack (empilés), spacer (un espace vide). Les enfants directs d’un écran forment une colonne. gap, padding, align, grow, width et height règlent la disposition.
  • Les éléments : label, gauge, bar, chart, telltale, image, list, table, button, toggle, slider, select, input, stepper, et custom pour un élément que vous dessinez vous-même. Le nom qui suit le mot (speedo) est facultatif. Le « Texte » qui vient ensuite est ce que l’élément affiche.

Ces mots ne sont des mots-clés qu’à l’intérieur de ui { }. Partout ailleurs, label, button ou row sont des noms ordinaires : une part appelée label fonctionne toujours.

Essayez#

Le tableau de bord a besoin d’un modèle autour de lui : les messages qu’il lit et envoie, et le contrôleur auquel il parle. Mettez ceci dans main.arche, suivi du Dashboard ci-dessus :

message STATUS { speed: float32 unit km/h range 0..200; distance: float32 unit m }
message BRAKE_FAULT: bool
message ENGAGE_REQ: bool
message STOP { hard: bool }

component Ctrl "Controller" {
  in cmd: data receives ENGAGE_REQ, STOP
  out st: data sends STATUS, BRAKE_FAULT
  states {
    state Idle
    state Ready
    Idle -> Ready on ENGAGE_REQ
    Ready -> Idle on STOP
  }
}

system Car "Car" {
  part ctrl: Ctrl
  part dash: Dashboard
  dash.cmd -> ctrl.cmd
  ctrl.st -> dash.bus
}

archec check main.arche affiche ✓ no errors. Listez ensuite les écrans :

archec ui main.arche
Dashboard (Car.dash) — 800×480, touch, dark
  screen Driving "Driving"  ← start ~306×267
    row
      gauge speedo "Speed"  value bus.STATUS.speed : a float km/h · 0..200 km/h
      label mode "Mode: ${ctrl.state}"
    row
      button engage "Engage"  enabled ctrl.state == Ready : a bool
        on press: send cmd ENGAGE_REQ(true)
      button stop "Stop"
        on press: send cmd STOP(hard: true)
      button settings "Settings"
        on press: goto Settings
  screen Settings "Settings" ~149×128
    toggle lights "Lights"  value lights : a bool
    button done "Done"
      on press: back
  overlay Warnings ~177×72
    telltale brake "Brake fault"  on bus.BRAKE_FAULT : a bool
  navigation: Driving → Settings, Settings → back
  reads: bus.STATUS.speed (message-field), ctrl.state (part-state), lights (var), bus.BRAKE_FAULT (message)

Chaque élément indique ce qu’il lit, avec le type, l’unité et la plage tirés du modèle. Pour voir les écrans dessinés, écrivez une page :

archec ui preview main.arche
✓ screens.html — 2 screens with sample values; click an element to see where it is written

Ce qu’affiche un élément : les liaisons#

value, enabled, visible et le on d’un témoin prennent une expression du langage d’action. C’est le même langage que celui des corps ```arche. Les noms de l’expression sont ce que la part de l’afficheur connaît :

Vous écrivez C’est
lights une variable de la part
state l’état de la part elle-même
bus.STATUS.speed le dernier STATUS reçu sur le port bus, son champ speed
bus.BRAKE_FAULT la dernière valeur d’un message à une seule valeur (message BRAKE_FAULT : bool)
ctrl.state, ctrl.speed l’état, ou une variable, d’une part voisine dans le système. L’aperçu et le simulateur les lisent dans le modèle ; un vrai produit les reçoit sous forme de messages.
MAX_SPEED une constante
DriveMode.MANUAL une valeur d’énumération
page une variable de l’ui
env.width, env.theme l’appareil

Un état se compare par son nom : ctrl.state == Ready. Un texte affiche des valeurs avec ${…} : text "Obstacle ${bus.STATUS.distance} m".

archec connaît le type, l’unité et la plage de chaque valeur grâce au modèle. Une jauge sur bus.STATUS.speed (un float32 unit km/h range 0..200) en prend l’unité et la plage. Si la jauge indique unit mph, archec le signale (ui-binding). Il signale aussi un interrupteur lié à un nombre, et un nom que la part ne possède pas.

Un toggle, slider, select, input ou stepper lié à une variable de sa propre part modifie cette variable quand il change. Pour faire autre chose, écrivez on change …. Dans ce bloc, value est la nouvelle valeur.

L’état propre de l’ui, et l’appareil#

Quelle page d’un écran est ouverte, un texte en cours de saisie : cela regarde l’afficheur, aucune autre part n’en a besoin. Une var écrite dans l’ui appartient à l’ui :

ui {
  var page = "Vehicle"
  screen Details "Vehicle" {
    select show "Show" { options "Vehicle", "Steering"; value page }
    bar accel "Acceleration" { value adcu.accel; visible page == "Vehicle" }
    label health { text "Steering: ${steering.health}"; visible page == "Steering" }
  }
}
  • Une liaison la lit, un contrôle qui lui est lié la modifie (value page), une action la modifie (page = "Steering"). Son type est écrit (var n: uint8) ou est celui de sa première valeur ; une variable typée sans valeur démarre à son zéro.
  • Elle n’est jamais envoyée : pas de message, pas de set vers la part (le socket de la cible web), pas de variable de la part dans les simulateurs, le projet Arche ou le modèle formel (archec verify, NuSMV, UPPAAL).
  • Chaque cible la garde comme état d’interface : une statique de ui_<id>.c (un texte dans un tampon à lui), une propriété du global Slint, une propriété de UiModel que la passerelle Qt Quick n’envoie jamais.
  • Son nom lui est propre : une variable ou un port de la part portant ce nom est signalé (ui-structure).
  • Un aperçu peut la fixer.

env est l’appareil. Il se lit comme n’importe quel nom, dans n’importe quelle liaison :

Nom C’est
env.width, env.height les pixels de l’afficheur (800×480 quand l’ui ne donne pas de taille)
env.theme dark ou light
env.input touch, encoder, keys ou pointer
env.locale la langue affichée (en quand la page n’en a choisi aucune)

Les quatre premiers sont fixes pour un afficheur : archec les calcule donc à la construction. visible env.width < 400 vaut false sur l’afficheur 1280×480 de la voiture, et aucune cible ne lit rien pour cela. "${env.width}" dans un texte est du texte. env.locale suit la langue que montre la page ; les cibles d’appareil, qui écrivent les textes dans la langue du modèle, prennent en.

Ce que fait un appui : les actions#

on press prend des instructions du langage d’action, sur sa ligne ou dans un bloc. C’est aussi le cas de on release, on long-press et on change, ainsi que du on enter et du on exit d’un écran :

button stop "Stop" {
  style danger
  on press {
    send cmd STOP(true)
    goto Driving
  }
}
Instruction Effet
send cmd STOP(true) envoie un message sur un port out ; les arguments dans l’ordre des champs, ou STOP { hard: true }
goto Settings affiche un autre écran (ou une boîte de dialogue)
back revient à l’écran précédent
lights = not lights modifie une variable de la part
if … { … } else { … } choisit
reset() appelle une fonction de la part

archec vérifie que le port envoie bien ce message, que les arguments correspondent à ses champs et que l’écran existe. Il vérifie aussi que quelque chose reçoit le message. Un appui sur un port sans lien, ou vers une part qui ne reçoit pas le message, est signalé (ui-dead-press).

Vos propres éléments#

Un écran montre souvent le même morceau encore et encore : un pneu, une ligne de défaut, un réglage. Écrivez-le une fois comme un élément, avec des paramètres typés, et utilisez-le comme un élément fourni :

component Dashboard {
  in bus:     can receives TPMS
  var lights: bool = false

  ui {
    element Tyre(title: string, p: float32) {
      column {
        label { text title; size small }
        gauge g { value p; range 0..4; unit bar }
      }
    }
    element Setting(title: string, on: bind bool) {
      toggle { text title; value on }
    }
    screen Main "Main" {
      row {
        Tyre front("Front", bus.TPMS.front)
        Tyre rear("Rear", bus.TPMS.rear) { grow 1 }
      }
      Setting("Lights", lights)
    }
  }
}
  • Où. Dans l’ui, à côté des écrans, ou en tête d’un fichier. Un élément en tête d’un fichier sert à toutes les ui du projet. Un kit d’interface peut aussi fournir des éléments.
  • Une utilisation est le nom de l’élément, puis ses arguments entre parenthèses, sans espace avant : Tyre("Front", bus.TPMS.front). Un argument peut être nommé : Tyre(title: "Front", p: bus.TPMS.front). Une utilisation peut aussi donner son visible, sa place dans la disposition qui l’entoure (grow, width, height, align), et la size et la color de ce qu’elle contient.
  • Développé avant l’IR. archec remplace chaque utilisation par ce que contient l’élément, ses paramètres donnés. Le modèle d’interface (archec ui --json), les aperçus, le simulateur et les quatre cibles ne voient que des éléments fournis. Ils n’ont besoin d’aucun code pour les vôtres.
  • Les noms. Une utilisation avec un nom (Tyre front(…)) donne ce nom à la seule chose que contient l’élément. Les identifiants à l’intérieur commencent alors par lui (front_g). Sans nom, les identifiants restent tels qu’écrits. Un élément avec des identifiants, utilisé deux fois dans un écran, a donc besoin d’un nom à chaque utilisation.
  • bind. Un paramètre bind va dans les deux sens. Il prend quelque chose qu’un changement peut modifier : une variable de la part. Un toggle ou un slider qui lui est lié modifie cette variable. on = value dans un on change aussi. Tout autre paramètre est en lecture seule.

archec vérifie ce que donne chaque utilisation, d’après les paramètres :

  • le nombre d’arguments, leurs noms et leurs types ;
  • un paramètre bind qui reçoit quelque chose qu’on ne peut pas modifier ;
  • l’utilisation d’un élément qui n’existe pas (il propose le nom le plus proche) ;
  • un élément qui se contient lui-même, à travers n’importe quel nombre d’autres.

Les vérifications de ce que contient l’élément suivent les paramètres. Par exemple, une jauge en bar qui reçoit une valeur en km/h est signalée à l’utilisation. Le message dit où c’est dans l’élément, et l’éditeur montre aussi cet endroit. L’éditeur complète vos éléments dans un écran, avec leurs paramètres, et le survol d’une utilisation montre ses paramètres.

L’IHM de la voiture (examples/autonomous-car) affiche ses valeurs avec un élément Readout. Ses quatre cibles sont les mêmes qu’avec les libellés écrits en entier. Les panneaux plus petits des autres exemples (listés plus bas) écrivent leurs éléments en entier.

Tiré du modèle : for et if#

Une liste de défauts montre les défauts présents. Une partie d’un écran n’existe que dans un état. for et if les écrivent dans une disposition :

column {
  for f in bus.FAULTS.active max 8 {
    row {
      label code { text "${f.code}  ${f.text}" }
      button ack "Ack" { on press send cmd ACK(f.code) }
    }
  }
  if bus.FAULTS.count == 0 { label ok "No fault" }
  else { label n { text "${bus.FAULTS.count} faults" } }
}
  • for f in <list> max N { … } dessine ce qu’il contient une fois pour chaque élément d’une liste : le champ tableau d’un message, ou une variable qui est un tableau. L’élément a un nom (f), et les liaisons et les actions à l’intérieur l’utilisent (${f.code}, send cmd ACK(f.code)). Les lignes vont dans la ligne ou la colonne qui entoure le for.
  • max est obligatoire. Un afficheur embarqué n’a pas de tas à perdre. Le modèle dit donc le plus grand nombre de lignes qu’un écran peut contenir. archec le compare à la longueur déclarée du tableau (ui-bound) : Fault[9] avec max 8 est signalé, de même qu’un for sans max. Un tableau sans longueur (Fault[]) reçoit une suggestion.
  • Combien il y en a. Un tableau C a toujours toute sa longueur. Quand l’enregistrement a un compte à côté de la liste, les lignes s’arrêtent donc là. Le compte est <list>_count, n_<list> ou <list>_len. Il peut aussi être count ou len quand l’enregistrement n’a pas d’autre liste sans son propre compte. Le modèle d’interface le nomme (count sur le nœud).
  • if <condition> { … }, else if … { … }, else { … } montrent ce qu’ils contiennent tant que leur condition est vraie. Ce ne sont qu’un visible sur chaque chose qu’ils contiennent : le modèle d’interface n’a pas de if, et les cibles n’ont besoin de rien pour lui.

Dans le modèle d’interface, un for est un nœud de genre repeat. Sa value est la liste. Son repeat est { item, max, length }, et son seul enfant est la ligne (une column quand le for contient plusieurs choses). Dans le moteur d’exécution et les tests, un nœud d’une ligne a l’indice de la ligne après le chemin du repeat : Main.column0.repeat0[2].row0.ack.

Cible Un for est
le moteur d’exécution, les aperçus, ui-web ses lignes, redessinées quand leur nombre change
ui-qml un Repeater dont le délégué est la ligne, son élément le modelData du délégué
ui-slint le for de Slint, sur une propriété que la glue remplit depuis la liste (au plus max), son élément une struct Slint. Un appui dans une ligne n’est pas produit : une note le dit
ui-lvgl une réserve de max lignes, créées une fois (mémoire statique seulement). Chaque mise à jour montre les lignes qu’a la liste, les remplit depuis leurs éléments et masque les autres. Un appui dans une ligne connaît sa ligne

Une list ou une table liée à une liste de la part se remplit de la même façon : Qt Quick et le web l’ont toujours fait, et maintenant LVGL et Slint aussi. Une liste montre des nombres, des booléens ou des textes ; un tableau montre une liste d’enregistrements, une colonne par champ.

Les boîtes de dialogue qu’ouvre le modèle#

Dans un produit, les écrans qui comptent le plus ne s’atteignent pas par un appui : un défaut les fait apparaître. when après le titre d’une boîte de dialogue dit ce qui l’ouvre :

dialog BrakeFault "Brake fault" when alerts.BRAKE_FAULT {
  label advice { text "Take over and stop the car safely." }
  button ok "OK" { enabled not alerts.BRAKE_FAULT; on press back }
}
  • La boîte de dialogue s’affiche quand sa condition devient vraie, par-dessus l’écran affiché à ce moment. Elle reste jusqu’à ce qu’on la quitte (back, ou un goto) ; la quitter remet cet écran. La condition doit redevenir fausse, puis vraie, pour l’ouvrir à nouveau.
  • La condition est n’importe quelle liaison : un message qui est un booléen (alerts.BRAKE_FAULT), un message qui est un enregistrement (ouverte dès qu’il est reçu), adcu.state == MinimalRisk.
  • ui-unreachable la compte comme atteinte depuis chaque écran.
  • Sécurité (ui-safety). Une boîte de dialogue ouverte par une condition de sécurité ne doit pas pouvoir être fermée tant que la condition est vraie. Une condition de sécurité est un message que nomme l’analyse de sécurité (comme pour les témoins, plus bas), une valeur que lit un témoin dans un overlay, ou l’état d’une part marquée safety ou avec un ASIL. Chaque bouton de la boîte qui la quitte a besoin d’un enabled qui dit le contraire : enabled not alerts.BRAKE_FAULT, ou la comparaison contraire (adcu.state != MinimalRisk), seule ou jointe à d’autres par and.
  • Les tests d’ui générés (TP-GEN-UI) déclenchent chaque condition. Un message est envoyé par la part reliée au port de l’ui, une variable d’une part est modifiée. Le cas vérifie que la boîte de dialogue est affichée, et que sa sortie est désactivée jusqu’à ce que la condition disparaisse.

Chaque cible surveille les conditions : le moteur d’exécution sous les aperçus, les simulateurs et ui-web ; LVGL à chaque ui_<id>_update() ; Slint dans watch(), que le main.rs de la glue appelle après receive() ; Qt Quick avec une propriété liée à la condition.

L’IHM de la voiture autonome ouvre BrakeFault quand l’ECU de freinage signale un défaut.

Les vérifications#

Code Détecte
ui-structure un mot qui n’est pas un mot d’écran (guage), deux éléments de même nom, aucun écran, un display qui n’est pas de la forme WxH, l’utilisation d’un élément qui n’existe pas, un élément qui se contient lui-même, un style qui n’est pas un enregistrement constant, une clé qu’aucun style ne fixe
ui-binding un nom que l’interface ne voit pas, un type qui ne convient pas à l’élément, une unité différente de celle de l’élément, un send que son port ne fait pas, un goto vers aucun écran, un élément qui reçoit un mauvais nombre ou un mauvais type d’arguments, un paramètre bind qui reçoit ce qu’on ne peut pas modifier
ui-dead-press un appui que rien ne reçoit ; un bouton sans action (une suggestion)
ui-unreachable un écran qu’aucun goto n’atteint (une boîte de dialogue avec when est atteinte depuis chaque écran) ; un écran sans issue (le correctif rapide ajoute un bouton Retour)
ui-safety un message nommé par un danger ou un objectif de sécurité, affiché sur certains écrans seulement et pas par un témoin dans un overlay ; une boîte de dialogue ouverte par une condition de sécurité qu’un bouton quitte tant que la condition est vraie
ui-bound un for dont la liste peut contenir plus d’éléments que son max (le correctif rapide les dessine tous), un for sans max, une liste sans longueur déclarée (une suggestion)
ui-fit un écran dont le contenu dépasse l’afficheur, un texte plus large que lui, une cible tactile de moins de 9 mm, un fits dont aucune disposition ne tient
ui-a11y un contraste sous le niveau WCAG AA, un bouton sans texte, un témoin qui ne s’exprime que par sa couleur
ui-text un texte non traduit alors que les autres textes du projet le sont
ui-test une étape de test qui appuie sur ce qu’aucune ui ne possède ou le lit (press hmi.engag, expect hmi.mode.colour), un change sur un bouton (Tester une interface)

archec check les signale avec les autres. L’éditeur les affiche pendant la saisie. Il complète aussi :

  • les mots d’éléments à l’intérieur d’un écran, et vos propres éléments, avec leurs paramètres ;
  • les noms qu’une liaison peut lire : bus. propose ses messages, bus.STATUS. leurs champs ;
  • les écrans après goto.

Le survol d’un élément indique à quoi il est lié. Le survol d’une utilisation de votre propre élément montre ses paramètres.

Dans le diagramme : la palette#

La palette du diagramme a une section Interface utilisateur : Screen, Dialog, Overlay, les dispositions (row, column, grid, stack, spacer) et tous les éléments. Déposez-en un sur un bloc : il est écrit dans le ui { } de la définition du bloc (pour une part, le composant dont elle est une copie), en une seule modification annulable :

  • un Screen (une boîte de dialogue, un overlay) demande son nom et se place à la fin de l’ui ; le bloc reçoit un ui { } s’il n’en a pas ;
  • un élément ou une disposition va dans l’écran (demandé quand l’ui en a plusieurs), à la fin, avec une première liaison vers ce que l’ui peut lire : pour une jauge, le premier nombre (value bus.STATUS.speed), pour un interrupteur, une variable booléenne de la part, pour un témoin, un message booléen. Un bloc sans ui en reçoit une, avec un écran Main.

Sélectionnez le bloc : son panneau liste son ui, chaque écran, chaque disposition et chaque élément. Cliquez sur l’un d’eux pour ouvrir son formulaire, construit à partir de la fiche du mot (la même que pour la complétion et le survol). value, enabled, visible (et le on d’un témoin) proposent les noms que l’ui peut lire, du genre que l’élément affiche (bus.STATUS.speed, ctrl.state, lights), et acceptent n’importe quelle expression. style, size et align sont des listes de choix. text, range, unit, format, gap… sont des champs. Les actions (on press …) s’écrivent dans le source.

Thèmes et kits d’interface#

theme dark et theme light sont fournis par archec ; colors { … } en modifie certaines couleurs. Votre propre thème est un enregistrement constant, dont base est le thème de départ :

component Panel "Front panel" {
  ui {
    theme ACME
    screen Main "Main" { label hello { text "Hello" } }
  }
}

/// Ours: light, with the company's blue.
const ACME = { base: "light", primary: "#0d47a1", background: "#fafafa" }
Diagramme : Front panel
Ce qu’archec dessine depuis ce code : Front panel

Un kit d’interface de l’Arche Store en fournit un : theme "acme/automotive-dark" prend le thème du kit que le projet utilise sous ce nom. Un kit peut aussi fournir des éléments : un projet qui utilise le kit s’en sert dans ses écrans, sans include.

Les styles, et les dispositions qui tiennent#

Un style à vous est un enregistrement constant, comme un thème. Un bouton ou un libellé le prend avec style :

component Panel {
  out cmd: data sends STOP
  ui {
    screen Main "Main" {
      button stop "Stop" { style WARN; on press send cmd STOP(true) }
    }
  }
}

/// How a warning action looks, on every screen.
const WARN = { color: "amber", size: "large", icon: "warning", style: "danger" }

Un style fixe color, size, icon, format, width, height, grow et align, et son propre style est l’un des styles fournis (primary, danger, quiet), qui fonctionnent toujours comme avant. Ce que l’élément dit lui-même l’emporte sur son style. Une clé qui n’est aucune de celles-ci est signalée (ui-structure).

size et color sur une disposition passent à ce qu’elle contient, sauf si ceux-ci disent les leurs : column { size large; color teal; … } rend ses libellés grands et bleu-vert. Une utilisation d’un de vos éléments les prend aussi : Readout("…") { size large }.

fits liste des dispositions, la plus large d’abord. Pour l’afficheur pour lequel l’ui est construite, archec garde la première qui tient et laisse les autres de côté :

fits {
  row { gauge s1 { value speed }; gauge r1 { value rpm }; gauge s2 { value speed } }
  column { gauge s3 { value speed }; gauge r3 { value rpm } }
  label compact { text "${speed} km/h  ${rpm} rpm" }
}

L’afficheur est le display de l’ui, ou la part d’afficheur à côté d’elle. Une même IHM, incluse par un produit avec un écran 800×480 et par un autre avec un écran 320×240, construit donc la ligne pour le premier et le libellé pour le second, sans écran écrit deux fois. La taille de chaque disposition est l’estimation qu’utilise ui-fit. Quand aucune ne tient, la dernière est gardée et ui-fit le dit.

Exigences et traductions#

satisfies REQ-HMI-3 sur un écran ou un élément trace l’exigence jusqu’à l’interface. Les textes se traduisent comme tous les textes du modèle : "Driving" fr "Conduite" là où ils sont écrits, ou un bloc translations fr { "Driving" "Conduite" }.

Voir l’interface : archec ui#

archec ui main.arche          # the screens, element by element, with what each reads and does
archec ui main.arche --json   # the resolved model

La construction écrit le même modèle dans ui/<component>.json, dans le projet Arche. C’est la seule chose que lisent les aperçus, les simulateurs, les tests et les générateurs de code : le type UiModel de src/ui.ts. Il contient le matériel et le thème, l’arbre des éléments de chaque écran avec leurs tailles, chaque liaison sous forme de petit arbre d’expression et en JavaScript, chaque action sous forme d’instructions vérifiées, la navigation, les textes avec leurs traductions, et l’endroit où chaque élément est écrit.

L’IHM de la voiture autonome en a une : examples/autonomous-car/components.arche. De plus petites, chacune un modèle à part à côté du main.arche de l’exemple, avec ses tests d’ui et ses captures de référence :

  • le panneau avant de la bouilloire, examples/kettle/panel.arche : la température de l’eau, l’état de la bouilloire, un voyant Done et un bouton Stop ;
  • le panneau de diagnostic du banc brake-by-wire, examples/brake-by-wire/panel.arche : la pression que remonte l’ECU de frein, l’état des deux ECU, un voyant de défaut et un freinage de test ;
  • l’écran d’état de la serre, examples/greenhouse/screen.arche : la température de l’air, l’état et le voyant du ventilateur, et un second écran avec les seuils.

Voir les écrans : archec ui preview#

archec ui preview main.arche                      # screens.html: each named preview, every screen, drawn
archec ui preview main.arche --screen Settings    # one
archec ui preview main.arche --preview Faulted    # one named preview
archec ui preview main.arche --png screens.png    # a picture of them (headless Chrome)

Une seule page, rien à installer, aucune URL externe. Elle montre chaque écran et chaque boîte de dialogue de chaque ui, à la taille de l’afficheur (mise à l’échelle), avec les overlays par-dessus, dans les couleurs du thème. Chaque élément affiche une valeur d’exemple : les premières valeurs du modèle (les variables et l’état de chaque part au début d’une exécution du simulateur du navigateur ; le libellé de mode de la voiture affiche Mode: Boot), ses constantes et, pour un message pas encore reçu, une valeur dans la plage de son type. Cliquez sur un élément : la page indique ce qu’il est, ce qu’il lit (value bus.STATUS.speed, son unité), ce que fait un appui, et le fichier et la ligne où il est écrit.

--png fait appel à Chrome ou Chromium (--chrome <path>, $CHROME, sinon les emplacements habituels). archec doc --html montre les mêmes écrans sous forme de figures, dans un chapitre User interface.

Dans VS Code, UI Preview (le bouton de la barre de titre de l’éditeur pour un modèle qui a une ui, ou Arche: UI Preview) affiche les écrans à côté de l’éditeur et les redessine pendant la saisie ; un clic sur un élément montre sa ligne.

Aperçus nommés#

Un écran se relit dans les états qui comptent : à l’arrêt, en croisière, un défaut de freinage en pleine vitesse. Un preview dans l’ui en nomme un, par ce que l’afficheur lit, fixé à une valeur, ou par une keyframe du système dont il part :

ui {
  …
  preview Cruising "Autonomous at 88 km/h" {
    adcu.state = Autonomous
    adcu.speed = 24.45
    adcu.obstacle_m = 60
  }
  preview Faulted "Brake fault at 88 km/h" {
    adcu.state = Autonomous
    adcu.speed = 24.45
    alerts.BRAKE_FAULT = true
  }
  preview Boot "Cold start" from keyframe parked
}
  • Chaque ligne est name = value. Le nom est un nom que l’ui lit : une variable de la part, un message ou l’un de ses champs (bus.STATUS.speed), l’état ou une variable d’une part voisine, une variable de l’ui. La valeur est un nombre, un texte, true ou false, un état, une valeur d’énumération ou une constante, du type du nom (ui-binding). Un nom qu’aucun écran ne lit est signalé : l’aperçu serait le même sans lui.
  • from keyframe parked part de la keyframe du système : ses variables fixées, puis ce que l’aperçu fixe par-dessus. Les deux peuvent être écrits.
  • Ce qui n’est pas fixé vient du début d’une exécution, comme pour les écrans.

Où ils servent :

  • archec ui preview dessine chaque aperçu, côte à côte, avant les écrans. Un aperçu montre ce que ses valeurs font apparaître : l’écran sur lequel l’ui démarre, et une boîte de dialogue que ses valeurs ouvrent. --preview Faulted en dessine un.
  • L’UI Preview de VS Code les montre aussi côte à côte.
  • archec ui snapshot garde une capture de référence de chacun : ui/screenshots/Hmi/preview-Faulted.png, à côté de celles des écrans.
  • Un cas de test part de l’un d’eux : case TC-7 "Fault at speed" from preview Faulted { … }. L’exécution part de la keyframe de l’aperçu. Puis, à 0, ce qu’il fixe : une variable d’une part, l’état d’une part (aucune action d’entrée ne s’exécute), un message comme si la part l’avait reçu. Le cas s’exécute sur le simulateur du navigateur.
  • Le « Try it » du store ouvre les écrans sur le premier aperçu. Un choix au-dessus d’eux en prend un autre, ou l’exécution en direct. Lecture, ou un pas, donne les écrans à l’exécution.

La voiture autonome en a trois, avec leurs captures de référence.

Les simuler#

Les écrans s’exécutent avec le modèle dans le simulateur du navigateur :

  • archec sim main.arche --html sim.html : la page montre les écrans au-dessus du schéma-bloc. Leurs valeurs viennent de l’exécution : les variables et l’état de la part, le dernier message reçu par chacun de ses ports, les parts voisines. Un appui envoie son message dans l’exécution, où les liens du port l’acheminent ; goto et back passent d’un écran à l’autre. Appuyez sur Engage sur le tableau de bord de la voiture : l’ADCU passe en Autonomous, et le libellé de mode l’affiche.
  • VS Code ▶ Run (le Run du diagramme, Simulate) : l’UI Preview s’ouvre à côté et montre les écrans en direct. Appuyez sur les boutons à cet endroit.
  • La page « Try it » du store, pour un paquet qui a une ui : la même chose.

Un test les pilote sans page#

Le moteur d’exécution qui sert à tous est sans affichage (src/uiruntime.ts). Il garde l’écran affiché et le chemin de retour, calcule ce que montre chaque élément à partir d’une source de valeurs, et exécute les appuis et les changements. Il interprète les arbres d’expression du modèle, sans eval. Il fonctionne donc dans une webview, dans une page ou dans un test :

const { buildUi, createUiRuntime } = require('arche-lang');
const rt = createUiRuntime(buildUi(program)[0], {
  values: (key) => values[key],                  // 'ctrl.state', 'bus.STATUS.speed', …
  send: (port, message, fields) => sent.push({ port, message, fields }),
});
rt.screen;                     // 'Driving'
rt.element('engage');          // { text: 'Engage', enabled: false, visible: true, … }
rt.press('engage');            // { ok: false, why: 'Driving.row1.engage is disabled' }
rt.change('Settings.lights', true);
rt.snapshot();                 // the screen, the way back, every element shown

uiSimLink().create(model, simProgram, live) fournit la source de valeurs et le send au-dessus du simulateur du navigateur en direct (src/websimlive.ts).

Tester une interface#

Un cas de test pilote les écrans comme le ferait le conducteur, dans ses lignes do et expect. Nommez un élément par la part qui possède l’ui, puis par l’identifiant de l’élément : hmi.engage. Quand deux écrans ont un élément de ce nom, écrivez hmi.Screen.id.

test-plan TP-UI "Driver HMI, on the screen" {
  case TC-UI-01 "Engage, then take over" {
    at 5ms "Ready" expect hmi.engage.enabled
    at 5ms expect hmi.mode.text == "Mode: Ready"
    at 5ms "Engage" do press hmi.engage
    at 10ms expect hmi.mode.text == "Mode: Autonomous"
    at 10ms expect sent("ENGAGE_REQ") == 1
    at 10ms expect not hmi.mrm.on
  }
  case TC-UI-02 "Details and back" {
    at 0ms do press hmi.details
    at 0ms expect hmi.screen == Details
    at 0ms do press hmi.back
    at 0ms expect hmi.screen == Driving
  }
}
Ligne Effet
do press hmi.engage appuie sur l’élément (de même pour long-press et release) : exécute son on press, c’est-à-dire un envoi dans l’exécution, un goto ou un back. Un appui sur un élément masqué, désactivé ou absent de l’écran affiché fait échouer le cas, en disant pourquoi
do change hmi.limit 80 règle un toggle, slider, select, input ou stepper (True, "text", une constante) : sa variable, son on change
expect hmi.mode.text == "…" ce qu’affiche un élément : text, label, value, display (formaté, avec son unité), enabled, visible, on (un témoin), shown (visible, sur un écran affiché), options
expect hmi.screen == Details l’écran affiché (un écran par son nom, ou "Details")
expect within 50ms: sent("ENGAGE_REQ") >= 1 les messages envoyés jusque-là, dont ceux d’un appui

Un cas peut partir d’un aperçu nommé : case TC-7 "Fault at speed" from preview Faulted { … }.

Ces lignes vont aussi dans une chronologie (at 5ms do press hmi.engage), avec le reste du Python du cas (adcu.state == "Manual"). Le vérificateur les reconnaît pendant la saisie. Un nom qui ne désigne aucun élément, une part sans ui ou un change sur un bouton est une erreur (ui-test).

Où ils s’exécutent. Le simulateur Python d’Arche n’a pas d’écran, pas de enabled et pas de mise en forme des textes. Un cas avec une étape d’ui s’exécute donc sur le simulateur du navigateur : le comportement du modèle dans node (src/websimrt.ts), avec le moteur de l’ui par-dessus. C’est la même paire que pour archec sim --html et ▶ Run.

  • archec test exécute ces cas à cet endroit, et les autres cas dans arche-cli, en un seul rapport. Quand tous les cas qu’il exécute ont une étape d’ui, il n’a pas du tout besoin d’arche-cli.
  • --sim web exécute tous les cas sur le simulateur du navigateur. Un cas qui atteint du Python que le langage d’action ne sait pas dire, sans python3 pour l’exécuter, est non concluant, jamais réussi (sim).
  • Dans le projet Arche, les lignes d’ui sont écrites en Python qui arrête le cas et indique qu’il s’exécute sur le simulateur du navigateur. Lancé depuis Arche, un tel cas échoue. Il ne réussit jamais pour rien.

Générés. archec gen --target tests écrit un plan TP-GEN-UI, à côté des plans pour les transitions et les limites. Il contient :

  • un cas par bouton. Le cas fait les appuis qui amènent l’ui sur l’écran du bouton, par le plus court chemin de gotos depuis l’écran de départ. Si le bouton a une condition, il attend et vérifie expect … .enabled. Puis il appuie et vérifie ce que l’appui doit faire : son sent("MSG"), ou l’écran après un goto ou un back ;
  • un cas par écran, qui l’atteint ;
  • un cas par boîte de dialogue qu’ouvre le modèle : sa condition déclenchée, la boîte affichée, sa sortie désactivée jusqu’à ce que la condition disparaisse.

Un écran qu’aucun goto n’atteint est écrit avec un TODO. Il est listé dans tests/generated.allow, comme les transitions que rien ne déclenche.

En CI. archec ci a une étape ui. Une liaison, un appui ou une étape d’ui qui ne tient pas la fait échouer. Par exemple : un message renommé alors qu’un bouton envoie encore l’ancien nom (ui-binding), ou un appui que rien ne reçoit (ui-dead-press). L’étape test exécute les cas d’ui sur le simulateur du navigateur, même en l’absence d’arche-cli.

Captures de référence#

archec ui snapshot main.arche --update   # ui/screenshots/Hmi/Driving.png, Details.png, preview-Faulted.png
archec ui snapshot main.arche            # each screen drawn again, compared
archec test main.arche --ui-golden       # the cases, then the same comparison

Une capture de référence (golden) est l’image de référence d’un écran, enregistrée à côté du modèle. Chaque écran et chaque boîte de dialogue est dessiné comme le fait archec ui preview --png : dans un Chrome sans affichage, avec les valeurs d’exemple. Puis il est comparé, pixel par pixel, à sa référence.

  • Un pixel dont les canaux sont à moins de 24 de ceux de la référence compte comme identique. Cela tolère l’anticrénelage des textes.
  • Un écran échoue quand plus de --tolerance pour cent de ses pixels ont changé (0,1 par défaut). Sa différence est écrite dans arche-out/.archec/ui-diff/Hmi/Driving.png : la référence estompée, et ce qui a changé en rouge. Driving.now.png se trouve à côté.
  • Quand le changement est voulu, relancez avec --update.

La cible web : gen --target ui-web#

archec gen main.arche --target ui-web -o out    # out/ui-web/index.html, ui.js, ui.css, ui.json

Cette commande écrit un dossier autonome : ouvrez index.html, ou servez le dossier. Par défaut, les valeurs viennent du modèle. La page simule en temps réel le système dans lequel se trouve la part de l’ui : il démarre, et les boutons envoient dans l’exécution. ui.json contient les modèles d’interface, les valeurs d’exemple et le programme du simulateur, pour d’autres outils.

Avec index.html?ws=ws://host:port, les valeurs viennent plutôt d’un WebSocket : le vrai produit, une passerelle vers un bus CAN, un banc de test. Chaque trame est un objet JSON :

De Message Signification
le serveur {"type":"value","key":"bus.STATUS.speed","value":72.5} la valeur actuelle d’une référence (key : une clé des refs du modèle)
le serveur {"type":"values","values":{"ctrl.state":"Ready","bus.STATUS.speed":72.5}} plusieurs à la fois
la page {"type":"hello","uis":["Dashboard"],"keys":{"Dashboard":["bus.STATUS.speed","ctrl.state","lights"]}} à la connexion : les clés qu’elle lit
la page {"type":"send","ui":"Dashboard","port":"cmd","message":"STOP","fields":{"hard":true}} un appui a envoyé un message (pour un message à une seule valeur : "fields":{"value":true})
la page {"type":"set","ui":"Dashboard","key":"lights","value":true} l’interface a modifié une variable de sa part (un interrupteur) ; jamais une variable propre à l’ui

Tout message peut porter "ui" pour désigner une ui parmi plusieurs. La page se reconnecte quand le socket se ferme.

Du code pour un appareil : ui-lvgl et ui-slint#

archec gen main.arche --target c -o generated        # the parts, as C
archec gen main.arche --target ui-lvgl -o generated  # the ui, for LVGL 9, beside it
archec gen main.arche --target ui-slint -o generated # the ui, in Slint, as a Rust crate

LVGL (ui-lvgl/) reçoit deux sortes de fichiers. ui_<id>.c/.h, pour chaque ui, est réécrit à chaque exécution. ui_<id>_task.c est écrit une seule fois ; ensuite, il vous appartient.

  • Les écrans. Chaque écran est un écran LVGL. Un dialog est une boîte par-dessus, sur lv_layer_top. Un overlay est aussi sur lv_layer_top, par-dessus tous les écrans. row, column et grid sont des conteneurs flex. Les enfants d’un stack sont centrés les uns sur les autres. Les couleurs du thème servent pour les écrans, le texte et les boutons.
  • Construction et mise à jour. ui_<id>_create(&part) construit les écrans pour la part à laquelle appartient l’ui (sa struct C issue de --target c). ui_<id>_update() relit toutes les liaisons, et ouvre une boîte de dialogue dont le when est devenu vrai. Appelez-la dans le thread de l’ui, avant lv_timer_handler().
  • D’où viennent les valeurs.
    • Une variable est celle de la part : self->lights. Une variable de l’ui est une statique du fichier : ui_<id>_uivar_page.
    • Un message est le dernier reçu. La part garde le dernier de chaque message que son ui lit : arche_ui_bus_status dans sa struct. Il est mis à jour par dashboard_ui_got_bus_status(), que le câblage appelle à l’arrivée de chaque message.
    • Un état ou une variable d’une part voisine (ctrl.state) se trouve dans ui_<id>_peers. Avec un déploiement, le câblage le copie depuis cette part quand elle s’exécute dans le même binaire. Sinon, renseignez ui_<id>_peers_hook. Un vrai produit reçoit la valeur par un message.
  • Les événements sont des callbacks.
    • send cmd STOP(true) appelle la fonction d’envoi de la part, celle qu’écrit la cible C (dashboard_send_cmd_stop).
    • goto et back utilisent une pile de navigation : ui_<id>_goto, ui_<id>_back, et le on enter et le on exit de chaque écran.
    • lights = not lights modifie la variable de la part.
    • Un toggle, slider, select, input ou stepper lié à une variable la modifie quand il change.
  • Le thread. ui_<id>_task.c est le thread de l’ui : lv_init, l’afficheur, puis la boucle. Sur un hôte avec LV_USE_SDL, l’afficheur est une fenêtre SDL. Sinon, c’est un tampon, avec le callback de flush que fournit le pilote de votre écran. Un binaire de déploiement compilé avec -DARCHE_UI lance le thread depuis <binary>_start.

Slint (ui-slint/<id>/) est un crate Rust.

  • ui/<id>.slint contient :

    • un global <Id>State : une propriété pour chaque nom que l’ui lit, l’écran affiché, et un callback pour chaque événement ;
    • un composant par écran, boîte de dialogue et overlay ;
    • la <Id>Window.

    Les liaisons sont des expressions Slint sur le global.

  • src/<id>_glue.rs est le modèle qui se trouve derrière :

    • Received : chaque message que l’ui lit, et chaque part voisine ;
    • Sent : chaque message qu’elle envoie ;
    • <Id>Ui, avec les valeurs, receive(), apply() vers la fenêtre, watch() (les boîtes de dialogue qu’ouvre le modèle), et les événements en Rust ;
    • bind(), qui installe les callbacks.
  • src/main.rs, Cargo.toml et build.rs sont écrits une seule fois. Ils produisent un binaire hôte qui alimente Received depuis un canal et affiche chaque Sent. Branchez-le sur votre bus.

Ce que produit chaque cible. Chaque mot d’élément a une entrée dans la liste de chaque cible (src/gen/uitargets.ts). Quand une cible ne produit un élément qu’en partie, archec gen le signale dans une note. Il ne le supprime jamais.

Élément LVGL Slint
row column grid stack spacer conteneurs flex layouts
label button toggle slider select input lv_label, lv_button, lv_switch, lv_slider (son step), lv_dropdown, lv_textarea Text, Button, Switch, Slider, ComboBox, LineEdit
gauge lv_arc, avec sa valeur dedans sa valeur et un ProgressIndicator (pas de cadran dans Slint)
bar chart lv_bar, lv_chart (un point tous les window/60) ProgressIndicator, un Path que dessine la glue
telltale lv_led et son texte, masqués quand il est éteint un point et son texte, quand il est allumé
stepper lv_spinbox avec − et + SpinBox (pas de 1)
image lv_image du fichier via le système de fichiers de LVGL (UI_IMAGE_DRIVE) Image (@image-url, à côté du .slint)
list table leurs options et colonnes fixes ; une liste de nombres, de booléens ou de textes de la part, et un tableau de ses enregistrements, remplis à chaque mise à jour la même chose, dans une ListView et une StandardTableView
for une réserve de max lignes créées une fois, affichées et remplies à chaque mise à jour le for de Slint, ses lignes sans leurs événements
custom son code lvgl son code slint

release est un clic dans Slint. L’appui long n’y est pas produit (archec l’indique dans une note). Les textes restent dans la langue où ils sont écrits.

L’afficheur. Quand l’ui n’a pas de display, une part d’afficheur voisine de la part de l’ui fournit la taille, la densité et l’entrée. Cette part se trouve dans le même système, ou dans la plateforme de son déploiement. Le store propose un ILI9341 (320×240, tactile), des ST7789 (240×320, 240×240), le SSD1306 (128×64) et un afficheur HDMI (cartes). Le modèle rover (archec new --template rover-esp32) a un écran d’état sur un ILI9341.

Sur une carte Linux : Qt Quick (--target ui-qml)#

archec gen main.arche --target ui-qml -o generated
cd generated/ui-qml/Dashboard
cmake -B build && cmake --build build && ./build/dashboard_ui     # C++, Qt 6.5+
python3 main.py                                                 # or PySide6

Chaque ui { } devient une application Qt Quick dans ui-qml/<component>/. Elle est écrite à partir du modèle résolu, jamais à partir du source :

Fichier Ce que c’est
Main.qml la fenêtre à la taille de l’afficheur : une StackView des écrans (goto en affiche un, en revenant à lui s’il est sous l’écran courant ; back dépile), un Popup pour les boîtes de dialogue, les overlays par-dessus tout, les couleurs du thème
<Screen>Screen.qml un composant par écran (<D>Dialog.qml, <O>Overlay.qml) : row, column, grid deviennent RowLayout, ColumnLayout, GridLayout ; on enter / on exit sur StackView.onActivated / onDeactivated
uimodel.h, uimodel.py UiModel, l’objet que lisent les liaisons : une propriété par nom que l’interface lit (bus.STATUS.speed → bus_STATUS_speed), en C++ (Q_PROPERTY) et pour PySide6
uibridge.h, bridge.py la passerelle vers le produit (voir plus bas)
main.cpp, CMakeLists.txt, main.py l’application, écrite une seule fois, puis à vous
README.md les propriétés et le protocole

Les éléments sont des Qt Quick Controls, dans le style Basic, avec le thème comme palette :

Élément QML
label un Label
gauge un arc sur un Canvas
bar une ProgressBar
chart une sparkline sur un Canvas, sur sa window
telltale un Rectangle allumé, affiché tant que sa condition est vraie
image une Image
list une ListView
table une TableView, avec une colonne par champ de columns
button un Button ; style danger utilise la couleur de danger du thème
toggle, slider, select un Switch, un Slider, une ComboBox
input, stepper un TextField, une SpinBox
custom son bloc qml, qui reçoit value
for un Repeater, son élément le modelData du délégué

Chaque élément a pour objectName son chemin dans le modèle d’interface, par exemple Driving.column0.row1.stop. Un test le retrouve par ce nom.

Une liaison est une liaison QML sur root.model.<name>. Un événement, ce sont les instructions vérifiées, en JavaScript : root.model.send("cmd", "STOP", { "hard": true }), root.nav.goto("Settings"), root.nav.back(), root.model.lights = !root.model.lights. Un contrôle lié à une variable de sa part la modifie quand il change.

Ce que QML ne sait pas afficher est signalé dans une note, jamais supprimé :

  • un custom sans bloc qml : un emplacement vide est affiché ;
  • une image, que vous copiez à côté du QML ;
  • un tableau dont les colonnes ne sont pas connues : il est affiché comme une liste ;
  • une SpinBox, qui ne contient que des nombres entiers ;
  • les traductions : les textes sont dans la langue du modèle.

La passerelle#

Sur un Raspberry Pi ou un Jetson, l’interface parle au reste du produit par UiModel. Renseignez ses valeurs et connectez-vous à son signal sent. Deux passerelles sont écrites :

  • WebSocket, trames texte JSON : ARCHE_UI_WS=ws://host:8765. En C++ quand Qt WebSockets est installé, et en Python.
    • entrée : {"type":"value","key":"bus.STATUS.speed","value":42} fixe une valeur que l’interface lit ;
    • sortie : {"type":"send","port":"cmd","message":"STOP","fields":{"hard":true}} pour un appui ;
    • sortie : {"type":"value","key":"lights","value":true} quand l’interface modifie une variable de sa part.
  • SocketCAN, en Python (pip install python-can cantools) : ARCHE_UI_CAN=can0 ARCHE_UI_DBC=bus.dbc python3 main.py, avec le DBC issu de archec gen --target dbc.
    • Une trame reçue met à jour les clés qui lisent son message (uimodel.RECEIVES, par nom de signal). Un champ a.b est le signal a_b.
    • Un appui est encodé d’après le nom de son message.
    • L’état ou une variable d’une part voisine de l’afficheur ne passe pas sur un bus. Il arrive par le WebSocket.

Limites#

  • Un for dans LVGL et Slint se répète sur une liste de la part (le champ d’un message, une variable), sur un seul niveau dans LVGL. Un for dans la ligne d’un autre n’est dessiné que par le moteur d’exécution et Qt Quick.
  • Dans Slint, un appui dans une ligne d’un for n’est pas produit. LVGL, Qt Quick et le web le produisent.
  • fits mesure chaque disposition par rapport à l’écran entier (l’afficheur, moins la marge intérieure de l’écran), pas par rapport à la place qui reste là où elle est écrite. Une ui est construite pour un afficheur : un produit avec deux écrans a deux constructions.
  • Un élément à vous est vérifié là où il est utilisé. Un élément que rien n’utilise n’est pas vérifié.
  • Ses paramètres se donnent aux liaisons (value, enabled, visible, on), aux textes (text, ${…}) et aux mots (size, color, icon, style). Ils ne se donnent pas à range ni à options, et une action ne peut pas en être un.
  • Le simulateur Python d’Arche n’a pas d’écran. Un cas avec une étape d’ui s’exécute sur le simulateur du navigateur, et échoue quand on le lance depuis Arche.
  • --png et les captures de référence ont besoin de Chrome ou de Chromium. Sans l’un ni l’autre, la comparaison est sautée, et archec le signale.
  • Des captures de référence dessinées sur une machine peuvent différer sur une autre, à cause des polices. Créez-les là où la comparaison s’exécute.
  • Slint n’a pas de cadran pour une gauge, et l’appui long n’y est pas produit.
  • Les cibles LVGL, Slint et Qt Quick écrivent les textes dans la langue du modèle. Elles n’emportent pas les traductions.
  • L’état ou une variable d’une part voisine de l’afficheur ne circule pas sur CAN. La passerelle Qt Quick le reçoit par le WebSocket.
  • Sans taille d’afficheur, env.width et env.height valent 800 et 480 pour toutes les cibles, comme la cible web le dessine.
  • La condition d’une boîte de dialogue est vue quand l’ui regarde : à chaque mise à jour (LVGL, une image de la page), à chaque événement de l’exécution d’un test. Une condition qui monte et retombe entre deux regards n’ouvre rien. Un main.rs Slint écrit avant que les boîtes de dialogue aient when doit appeler watch() lui-même.