Apprendre › Aide-mémoire

Apprendre

Aide-mémoire

Cette page présente arche-lang sur une seule page. Elle donne les déclarations avec lesquelles s’écrit tout modèle, une ligne chacune. Le cœur 1.0, avec un exemple de chaque construction et ce que l’édition 1.0 promet de garder, se trouve dans core.md.

Le plus petit modèle qui passe la vérification tient en un composant et un système :

component Lamp "Lamp" { var level: uint8 = 0 }
system Room "Room" { part lamp: Lamp }

Enregistrez-le sous room.arche, puis lancez :

archec check room.arche
✓ no errors

Les idées derrière ces déclarations sont dans les concepts. Chaque propriété figure dans la référence du langage. Un modèle complet qui utilise chaque ligne se trouve à la fin de cette page.

Déclarations#

Écrire Ce que c’est
project Pump "Water pump" { version "0.1" } Le projet : son nom, sa version, les bibliothèques qu’il utilise. Un seul par modèle.
include "parts/motor.arche" Un autre fichier du modèle.
type Flow = float32 unit l/min range 0..120 Un type de données : un type de base, une unité, une plage.
enum Mode { Off, On } Un choix parmi des valeurs nommées.
struct Point { x: float32; y: float32 } Un enregistrement de champs.
const MAX_FLOW = 100 unit l/min Une valeur nommée.
message PRESS "Press" { count: uint8 } Ce qui circule entre les parts. message GO: bool transporte une seule valeur.
component Lamp "Lamp" { … } Une définition : ses ports, variables, fonctions et états.
in cmd: can receives PRESS Un port qui reçoit. out click: can sends PRESS envoie ; inout fait les deux.
var level: uint8 = 0 Une variable du composant, avec sa valeur initiale.
fn dim "Dim" ```arche … ``` Une fonction et ce qu’elle fait, dans le langage d’action. main s’exécute dès le démarrage.
states { state Off; state On; Off -> On on PRESS [level > 0] } La machine à états. Elle démarre dans le premier état. Une transition s’écrit A -> B on trigger [guard] / action.
system Room "Room" { … } Ce qu’Arche affiche et exécute : des parts et les liens qui les relient.
part lamp: Lamp Une instance d’un composant, dans un système.
button.click -> lamp.cmd { latency 1ms } Un lien d’un port vers un port.
requirement REQ-ON "Turn on" { text "The lamp shall …" } Ce qui doit être vrai.
satisfies REQ-ON Dans un composant ou une part : il remplit l’exigence. Dans un cas de test, verifies REQ-ON : il la vérifie.
trace refines REQ-ON -> REQ-1 Une trace écrite à part, pour les autres liens (derives, refines, allocates…).
test-plan TP-ON "Turning on" { case TC-1 "…" { … } } Des tests, exécutés dans le simulateur. Les étapes s’écrivent at 0ms do … et within 50ms expect ….

Dans un corps ```arche#

Écrire Ce que cela fait
var d = speed * 2.0 Une variable locale.
level = 0, level += 1 Affecte une variable de la part.
if level > 0 { … } else { … } Un choix. while c { … } et for i in 0..4 { … } sont des boucles.
send click PRESS { count: 1 } Envoie un message sur un port.
goto On, state == On Change d’état ; teste l’état courant.
wait 10ms Attend.
dim(), return x Appelle une fonction de la part ; retourne une valeur.
log "pressed", level Écrit dans le journal du simulateur.

Un corps écrit en ```python fonctionne toujours. Pour réécrire un corps simple en corps arche, utilisez le correctif rapide Convert to arche body dans l’éditeur, ou lancez archec fix --only arche-body.

Commandes#

Lancer Pour
archec new Démarrer un projet à partir d’un modèle de projet.
archec check main.arche Vérifier le modèle.
archec sim main.arche Exécuter le comportement et afficher la trace. Rien à installer. --html sim.html écrit une page pour l’exécuter dans un navigateur.
archec test main.arche Exécuter ses plans de test dans le simulateur.
archec gen main.arche --target c Générer du code (embassy, go, ros2…).
archec build main.arche Écrire le projet Arche, à ouvrir dans Arche.

Tout à la fois#

project Room "Room" {
  version "0.1"
}

message PRESS "Press" { count: uint8 }

const MAX_LEVEL = 10

requirement REQ-ON "Turn on" {
  text "The lamp shall turn on within 50 ms of a press."
}

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

component Lamp "Lamp" {
  satisfies REQ-ON
  in cmd:    can receives PRESS
  var level: uint8 = 0
  states {
    state Off
    state On
    Off -> On on PRESS
    On -> Off on PRESS
  }
  fn main "Brighten" ```arche
    while true {
      wait 100ms
      if state == On and level < MAX_LEVEL {
        level += 1
      }
    }
  ```
}

system Home "Home" {
  part button: Button
  part lamp:   Lamp
  button.click -> lamp.cmd
}

test-plan TP-ON "Turning on" {
  case TC-ON-01 "A press turns it on" {
    verifies REQ-ON
    at 0ms do send(button.click, PRESS(count=1))
    within 50ms expect lamp.state == "On"
  }
}
Diagramme : Home
Ce qu’archec dessine depuis ce code : Home
Essayer

Enregistrez-le sous main.arche. archec check main.arche affiche ✓ no errors, et archec test main.arche exécute le plan de test :

PASS  TP-ON/TC-ON-01 A press turns it on

1/1 passed, 0 failing, 0 known failure(s)

Requirements: 1 verified by passing cases, 0 failing