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(ouencoder,keys,pointer),theme dark(oulight). Avecdpi 160, archec peut vérifier que les boutons sont assez grands pour un doigt. Sansdisplay, archec prend l’afficheur de la carte sur laquelle la part est construite (sonhardware { 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 Settingsetbackpassent de l’un à l’autre. Undialogs’affiche par-dessus l’écran courant jusqu’à ce qu’on le quitte. Unoverlays’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,widthetheightrèglent la disposition. - Les éléments :
label,gauge,bar,chart,telltale,image,list,table,button,toggle,slider,select,input,stepper, etcustompour 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
setvers 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é deUiModelque 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 sonvisible, sa place dans la disposition qui l’entoure (grow,width,height,align), et lasizeet lacolorde 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ètrebindva 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 = valuedans unon changeaussi. 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
bindqui 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 lefor.maxest 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]avecmax 8est signalé, de même qu’unforsansmax. 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 êtrecountoulenquand l’enregistrement n’a pas d’autre liste sans son propre compte. Le modèle d’interface le nomme (countsur le nœud). if <condition> { … },else if … { … },else { … }montrent ce qu’ils contiennent tant que leur condition est vraie. Ce ne sont qu’unvisiblesur chaque chose qu’ils contiennent : le modèle d’interface n’a pas deif, 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 ungoto) ; 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-unreachablela 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éesafetyou avec un ASIL. Chaque bouton de la boîte qui la quitte a besoin d’unenabledqui dit le contraire :enabled not alerts.BRAKE_FAULT, ou la comparaison contraire (adcu.state != MinimalRisk), seule ou jointe à d’autres parand. - 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 écranMain.
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" }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,trueoufalse, 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 parkedpart 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 previewdessine 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 Faulteden dessine un.- L’UI Preview de VS Code les montre aussi côte à côte.
archec ui snapshotgarde 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 ;gotoetbackpassent 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 testexé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 webexécute tous les cas sur le simulateur du navigateur. Un cas qui atteint du Python que le langage d’action ne sait pas dire, sanspython3pour 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 : sonsent("MSG"), ou l’écran après ungotoou unback; - 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
--tolerancepour cent de ses pixels ont changé (0,1 par défaut). Sa différence est écrite dansarche-out/.archec/ui-diff/Hmi/Driving.png: la référence estompée, et ce qui a changé en rouge.Driving.now.pngse 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
dialogest une boîte par-dessus, surlv_layer_top. Unoverlayest aussi surlv_layer_top, par-dessus tous les écrans.row,columnetgridsont des conteneurs flex. Les enfants d’unstacksont 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 lewhenest devenu vrai. Appelez-la dans le thread de l’ui, avantlv_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_statusdans sa struct. Il est mis à jour pardashboard_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 dansui_<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, renseignezui_<id>_peers_hook. Un vrai produit reçoit la valeur par un message.
- Une variable est celle de la part :
- 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).gotoetbackutilisent une pile de navigation :ui_<id>_goto,ui_<id>_back, et leon enteret leon exitde chaque écran.lights = not lightsmodifie 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.cest le thread de l’ui :lv_init, l’afficheur, puis la boucle. Sur un hôte avecLV_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_UIlance le thread depuis<binary>_start.
Slint (ui-slint/<id>/) est un crate Rust.
ui/<id>.slintcontient :- 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.
- un global
src/<id>_glue.rsest 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.tomletbuild.rssont écrits une seule fois. Ils produisent un binaire hôte qui alimenteReceiveddepuis un canal et affiche chaqueSent. 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
customsans blocqml: 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.
- entrée :
- SocketCAN, en Python (
pip install python-can cantools) :ARCHE_UI_CAN=can0 ARCHE_UI_DBC=bus.dbc python3 main.py, avec le DBC issu dearchec gen --target dbc.- Une trame reçue met à jour les clés qui lisent son message
(
uimodel.RECEIVES, par nom de signal). Un champa.best le signala_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.
- Une trame reçue met à jour les clés qui lisent son message
(
Limites#
- Un
fordans 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. Unfordans 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
forn’est pas produit. LVGL, Qt Quick et le web le produisent. fitsmesure 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 àrangeni à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.
--pnget 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.widthetenv.heightvalent 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.rsSlint écrit avant que les boîtes de dialogue aientwhendoit appelerwatch()lui-même.