Holarch

SysML v2

Tutoriels SysML v2

Neuf tutoriels guidés pour les projets SysML v2, du premier package aux ports, actions, états, exigences, vérification, contraintes et variantes, avec un panneau d'étapes qui vérifie votre travail.

Utilisation →

Sur cette page
  1. Mode d'emploi
    1. Commencer un tutoriel SysML v2
    2. Saisir le texte d'une étape
    3. Conseils
  2. Premiers pas
  3. Définitions et attributs
  4. Ports et interfaces
  5. Actions et flux
  6. États et transitions
  7. Exigences
  8. Vérification et traçabilité
  9. Contraintes et calculs
  10. Variantes et configurations
  11. Projets des tutoriels
  12. Voir aussi

Holarch propose une série de tutoriels guidés pour les projets SysML v2. Chacun crée un petit projet SysML v2 de départ et ouvre un panneau d'étapes à côté de la page. Le panneau contrôle le modèle pendant que vous travaillez : une étape passe au vert lorsque le modèle contient ce qu'elle demande. Cette page liste chaque étape sous forme de texte, pour que vous puissiez aussi suivre ici.

Le premier tutoriel utilise la station météo WS-1, comme les tutoriels LML. Les autres construisent des parties d'une voiture hybride, le modèle de la démo Hybrid Car : types de valeurs et composants, ports et interfaces du groupe motopropulseur, un cycle de conduite, les états du groupe motopropulseur, les exigences de la voiture, leur vérification, les contrôles des valeurs de la berline et la ligne de produits. Chaque tutoriel a son propre projet de départ, vous pouvez donc les suivre dans n'importe quel ordre. Chaque projet de départ et chaque tutoriel terminé se contrôle avec 0 problème.

TutorielDuréeVous apprenez à
Premiers pas15 minécrire du texte SysML v2, le voir sous forme d'arborescence et de vue, dessiner dans la vue et ajouter une exigence
Définitions et attributs20 minécrire des énumérations, des types de valeurs et des définitions abstraites, spécialiser avec des valeurs et des unités, et utiliser la complétion, Insérer et le renommage
Ports et interfaces20 mindéfinir des ports et des interfaces, conjuguer des ports, relier des parties et dessiner une interface dans une vue d'interconnexion
Actions et flux20 minécrire des définitions d'action et un cycle de conduite avec un fork, des flux et un join, ajouter des couloirs et construire des étapes dans le FFBD
États et transitions20 minécrire des signaux et une machine à états avec des déclencheurs, des gardes et des actions d'état, et dessiner une transition temporisée
Exigences20 minécrire des limites, des définitions et des usages d'exigence, les satisfaire et voir une exigence non respectée
Vérification et traçabilité15 minécrire un cas de vérification, tracer une étape dans la matrice de traçabilité et dériver une exigence
Contraintes et calculs20 minécrire des contraintes et des calculs, lier des valeurs dans une vue paramétrique, exécuter un cas d'analyse et marquer des valeurs TBD et TBR
Variantes et configurations15 minécrire des variations et des variantes, une ligne de produits avec une règle, des configurations et un mot-clé à vous

Mode d'emploi

Commencer un tutoriel SysML v2

  1. Ouvrez Aide → Tutoriels dans le rail, ou appuyez sur ⌘K / Ctrl+K et saisissez tutorial. Hors d'un projet, la page Tutoriels liste d'abord les tutoriels LML, puis Tutoriels pour les projets SysML v2. Dans un projet SysML v2, elle ne liste que les tutoriels SysML v2.
  2. Cliquez sur Commencer sur une carte. Holarch crée le projet, par exemple Tutorial: SysML v2 Ports and Interfaces (Hybrid Car), et l'ouvre avec le panneau d'étapes à droite.

Le panneau d'étapes fonctionne comme dans les tutoriels LML : Montrer met en évidence la commande dont une étape a besoin, Y aller ouvre la page, En savoir plus ouvre la rubrique d'aide, et Recommencer…, Marquer comme terminé et × fonctionnent de la même façon. Voir Tutoriels.

Saisir le texte d'une étape

La plupart des étapes donnent du texte SysML à saisir dans Modèle → Éditeur. L'étape indique où vont les lignes, par exemple « avant la dernière accolade fermante du package ». Le texte est appliqué au modèle lorsque vous faites une pause dans la saisie ; l'état sous l'éditeur l'indique, et l'étape passe au vert.

  • Saisissez les lignes comme indiqué. L'indentation n'a pas d'importance pour le modèle ; l'éditeur conserve la vôtre.
  • Un soulignement rouge marque une erreur : pointez dessus pour lire le message. Un texte comportant une erreur de syntaxe reste un brouillon et n'est pas appliqué tant que vous ne l'avez pas corrigé.
  • ⌘Z / Ctrl+Z annule la dernière modification appliquée.

Conseils

  • Suivez les tutoriels dans l'ordre la première fois : chacun explique le texte qu'il utilise, et les suivants supposent acquises les idées précédentes (définitions et usages, :> et :>>).
  • Une étape qui reste ouverte contient généralement une faute de frappe dans un nom. Comparez votre texte avec les lignes de l'étape ; en SysML v2, les noms sont sensibles à la casse.
  • Les tutoriels enseignent le même langage que Bases de SysML v2 ; la page Notation textuelle donne les détails.

Premiers pas

Écrivez un premier modèle de la station météo : ouvrez le texte, ajoutez une définition de partie avec une valeur et une unité, utilisez-la dans une autre définition, voyez le modèle dans le Navigateur et dans une vue générale, dessinez une partie dans la vue et regardez-la apparaître dans le texte, ajoutez une exigence avec satisfy et exportez le modèle sous forme de fichier .sysml. Les étapes sont décrites dans Bien démarrer avec les projets SysML v2.

Définitions et attributs

Le projet de départ contient le package Vehicles avec une définition de partie, Car.

  1. Ouvrir le package. Cliquez sur Modèle → Éditeur. Chaque déclaration est un mot-clé et un nom, puis un corps entre accolades ou un point-virgule.
  2. Écrire une énumération. Au-dessus de part def Car {, ajoutez enum def DriveMode { enum economy; enum normal; enum sport; } (une valeur par ligne).
  3. Définir un type de valeur. En dessous, ajoutez attribute def TirePressure :> ScalarValue;. :> signifie « spécialise ».
  4. Écrire une définition abstraite. Ajoutez abstract part def Component avec un commentaire doc et les attributs mass : MassValue, partNumber : String et power : PowerValue. // commence une note qui reste uniquement dans le texte.
  5. Laisser le vérificateur trouver une erreur. Ajoutez part def Battery :> Component avec attribute redefines mass = 45 [kg]; et, volontairement, attribute redefines power = 60 [kg];. Le vérificateur souligne l'unité : les kilogrammes ne sont pas une puissance.
  6. Corriger l'unité. Remplacez-la par 60 [W].
  7. Compléter un nom. Dans la batterie, saisissez attribute capacity : Ener, acceptez EnergyValue dans la liste de complétion avec Enter et terminez par ;.
  8. Le chercher dans la bibliothèque standard. Cliquez sur Paramètres → Bibliothèque standard en bas du rail et saisissez EnergyValue dans le champ de recherche.
  9. Insérer une définition. Dans l'éditeur, appuyez sur ⌃⇧Space / Ctrl+Shift+Space (ou cliquez sur Insérer ▾) sur une ligne vide, choisissez Définition de part et complétez part def Engine :> Component avec attribute redefines mass = 110 [kg]; et attribute cylinders : Integer;.
  10. Utiliser les définitions. Dans Car, ajoutez attribute mode : DriveMode;, part battery : Battery; et part engine : Engine;.
  11. Renommer partout. Placez le curseur sur cylinders, appuyez sur F2 et renommez-le en cylinderCount.

Ports et interfaces

Le projet de départ contient les composants du groupe motopropulseur avec leurs ports de couple et de puissance, les définitions de port TorquePort et PowerPort, et les définitions d'interface Shaft et HighVoltageBus.

  1. Définir un port. Au-dessus de port def TorquePort, ajoutez port def FuelPort avec out attribute flowRate : Real; et attribute kind : FuelKind;. out signifie que la valeur quitte la partie qui possède le port.
  2. Donner leurs ports aux parties. Ajoutez port fuelOut : FuelPort; à FuelTank et port fuelIn : ~FuelPort; à Engine. ~ conjugue le port : l'entrée et la sortie sont inversées.
  3. Définir une interface. Ajoutez interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }.
  4. Construire le groupe motopropulseur. À la fin du package, ajoutez part def Powertrain avec les parties tank, engine, motor, battery et transmission, un port output : TorquePort et bind output = transmission.output;.
  5. Relier deux parties. Dans le groupe motopropulseur, ajoutez interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn;.
  6. Ajouter les arbres de transmission. Ajoutez interface engineShaft : Shaft connect engine.output to transmission.engineIn; et interface motorShaft : Shaft connect motor.output to transmission.motorIn;.
  7. Créer une vue d'interconnexion. Cliquez sur Architecture → Vues d'interconnexion, puis sur + Nouveau diagramme. Choisissez Powertrain sous Affiche et cliquez sur Créer.
  8. Dessiner une interface. Faites glisser depuis la poignée du port powerOut de la batterie jusqu'au port powerIn du moteur électrique, et déposez sur Interface : HighVoltageBus.
  9. Nommer l'interface. Sélectionnez la nouvelle ligne et saisissez hvBus comme Nom dans l'inspecteur.
  10. La voir dans le texte. Cliquez sur Modèle → Éditeur : l'interface se trouve dans le groupe motopropulseur, avec son nom, son type et ses extrémités.

Actions et flux

Le projet de départ contient le package VehicleBehavior avec les items Fuel et Torque, les fonctions ProduceTorque (F.2) et DriveWheels (F.3), et trois définitions de partie.

  1. Définir une fonction. Ajoutez action def <'F.1'> SupplyFuel avec in attribute fuelDemand : Real; et out item fuel : Fuel;. Le nom court entre chevrons est le numéro de la fonction.
  2. Écrire le cycle de conduite. Ajoutez action def <'F'> DriveCycle avec first start then split;, fork split;, then supply;, then produce; et les étapes action supply : SupplyFuel et action produce : ProduceTorque, chacune avec une duration.
  3. Ajouter un flux. Dans le cycle de conduite, ajoutez flow of Fuel from supply.fuel to produce.fuel;.
  4. Réunir les branches. Ajoutez first supply then ready;, first produce then ready;, join ready;, then action drive : DriveWheels { … }, then done; et flow produce.torque to drive.torque;.
  5. Créer une vue de flux d'Action. Cliquez sur Comportement → Flux d'actions, puis sur + Nouveau diagramme, et choisissez DriveCycle sous Affiche.
  6. Indiquer qui exécute chaque étape. Ajoutez part def DrivenCar avec perform action trip : DriveCycle; et les parties tank, engine et transmission, chacune avec perform trip.supply;, perform trip.produce; ou perform trip.drive;. La vue reçoit un couloir par partie.
  7. Ouvrir l'analyse fonctionnelle. Cliquez sur Comportement → Analyse fonctionnelle, cliquez sur Choisir… et choisissez DriveCycle.
  8. Déclarer une autre action. Ajoutez action def EmergencyShutdown;.
  9. Construire des étapes dans le FFBD. Cliquez sur Comportement → FFBD, puis sur + Nouveau diagramme, et choisissez EmergencyShutdown. Dans le panneau Ajouter, saisissez Open Contactors et appuyez sur Enter, puis Cut Fuel.
  10. Voir les étapes dans le texte. Cliquez sur Modèle → Éditeur : le FFBD a écrit les étapes et leurs successions.

États et transitions

Le projet de départ contient le package PowertrainBehavior avec une part def Car vide.

  1. Définir les signaux. Ajoutez attribute def StartRequest;, puis StopRequest, PlugIn et Unplug de la même façon.
  2. Écrire une définition d'état. Ajoutez state def PowertrainStates avec in attribute charge : Real;, entry; then off; et les états off, electric et hybrid.
  3. Ajouter des transitions. Après state off;, ajoutez accept StartRequest if charge > 20 then electric; et accept StartRequest then hybrid;.
  4. Donner ses actions à un état. Remplacez state electric; par un corps contenant entry action spinUpMotor;, do action driveElectric; et exit action holdMotor;.
  5. Quitter l'état électrique. Après celui-ci, ajoutez if charge < 15 then hybrid; et accept StopRequest then off; ; ajoutez aussi accept StopRequest then off; après state hybrid;.
  6. Ajouter un état avec des transitions nommées. Ajoutez state charging { do action chargeBattery; }, transition plugIn first off accept PlugIn then charging; et transition unplugged first charging accept Unplug then off;.
  7. Créer une vue des transitions d'état. Cliquez sur Comportement → Machines à états, puis sur + Nouveau diagramme, et choisissez PowertrainStates sous Affiche.
  8. Dessiner une transition temporisée. Faites glisser depuis la poignée de charging jusqu'à off et déposez sur Transition. Dans le panneau de la transition, saisissez le Nom charged et le Déclencheur after 30 [min].
  9. La voir dans le texte. Cliquez sur Modèle → Éditeur : la transition est écrite sous forme de transition nommée.
  10. Faire présenter les états par la voiture. Dans Car, ajoutez exhibit state powertrainStates : PowertrainStates;.

Exigences

Le projet de départ contient le package VehicleRequirements avec une petite copie de la conception : Battery, Car et la sedan de la flotte, avec une masse à vide de 1580 kg.

  1. Nommer les limites. Ajoutez attribute maxCurbMass : MassValue = 1650 [kg]; et attribute minBatteryCapacity : EnergyValue = 1.2 [kW*h];.
  2. Écrire une définition d'exigence. Ajoutez requirement def <'VR-1'> CurbMass avec une déclaration doc, subject car : Car;, attribute limit : MassValue; et require constraint { car.curbMass <= limit }.
  3. Insérer une exigence. Appuyez sur ⌃⇧Space / Ctrl+Shift+Space sur une ligne vide, choisissez Définition d'exigence et écrivez VR-3 BatteryCapacity avec le sujet battery : Battery et require constraint { battery.capacity >= minBatteryCapacity }.
  4. Imbriquer des exigences dans une spécification. Ajoutez requirement carSpec avec subject car : Car; et requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }.
  5. Indiquer ce qui les satisfait. Ajoutez satisfy carSpec by fleet.sedan; et satisfy requirement batterySpec : BatteryCapacity by fleet.sedan.battery;.
  6. Enfreindre une exigence. Remplacez la masse à vide de la berline par 1700 [kg]. L'éditeur marque le satisfy : la berline ne respecte plus VR-1.1.
  7. La respecter de nouveau. Appuyez sur ⌘Z / Ctrl+Z, ou remettez-la à 1580 [kg].
  8. Voir le tableau des exigences. Cliquez sur Besoins et exigences → Exigences.
  9. Créer une vue des exigences. Sur la page Diagrammes, cliquez sur + Nouveau diagramme, choisissez Vue des exigences et carSpec sous Affiche.
  10. Contrôler les énoncés. Cliquez sur Besoins et exigences → Qualité, puis sur Contrôler la qualité.

Vérification et traçabilité

Le projet de départ contient l'exigence de masse à vide et la spécification de la voiture, un cycle de conduite avec les étapes cruise et brake, VR-6 batteryMassLimit et VR-7 stopFromCruise.

  1. Écrire un cas de vérification. Ajoutez verification def <'VC-1'> CurbMassTest avec subject car : Car;, objective massObjective { verify carSpec.sedanMass; } et return verdict : Boolean = car.curbMass <= maxCurbMass;.
  2. L'appliquer à la berline. Ajoutez verification <'VC-1.1'> sedanWeighing : CurbMassTest { subject car = fleet.sedan; }.
  3. Ouvrir les cas de vérification. Cliquez sur Vérification → Cas de vérification. Les étapes, les résultats et l'état sont des données Holarch associées au modèle. Dans la ligne de Sedan Weighing, cliquez sur + Étapes, puis sur + Ajouter une étape, saisissez Weigh the car sous Action et cliquez sur Appliquer. Cliquez ensuite sur Réussis dans ses boutons d'état.
  4. Lire la RVTM. Cliquez sur Vérification → RVTM.
  5. Tracer une étape vers une exigence. Cliquez sur Vérification → Matrice de traçabilité, affichez les exigences en lignes et les actions en colonnes, cliquez sur la cellule de stopFromCruise et brake, et choisissez satisfied by.
  6. Dériver une exigence. Ajoutez private import RequirementDerivation::*; et connection batteryMassDerivation : Derivation connect carSpec.sedanMass to batteryMassLimit;.
  7. Lancer les contrôles du modèle. Cliquez sur Vérification → Contrôles du modèle.

Contraintes et calculs

Le projet de départ contient le package VehicleAnalysis avec le moteur, la batterie, la voiture et les valeurs de la berline, ainsi que les objectifs maxCurbMass et minPowerToWeight.

  1. Écrire une définition de contrainte. Ajoutez constraint def MassLimit avec in mass : MassValue;, in limit : MassValue; et l'expression mass <= limit.
  2. Écrire un calcul. Ajoutez calc def PowerToWeight avec les paramètres power et mass et return ratio = power / mass;.
  3. Lier les valeurs de la berline. Ajoutez constraint sedanMassCheck : MassLimit { in mass = fleet.sedan.curbMass; in limit = maxCurbMass; }.
  4. Créer une vue paramétrique. Sur la page Diagrammes, cliquez sur + Nouveau diagramme, choisissez Vue paramétrique et VehicleAnalysis sous Affiche. Le contrôle réussit : 1580 kg est dans la limite de 1650 kg.
  5. Faire échouer le contrôle. Remplacez la masse à vide de la berline par 1700 [kg] ; la vue montre l'échec du contrôle.
  6. Le faire réussir de nouveau. Annulez, ou remettez-la à 1580 [kg]. Tout résoudre contrôle de nouveau chaque contrainte.
  7. Exécuter un cas d'analyse. Ajoutez analysis def PowerToWeightAnalysis avec un objectif qui exige ratio >= minPowerToWeight, et analysis sedanPowerToWeight : PowerToWeightAnalysis { subject car = fleet.sedan; }.
  8. Marquer les valeurs ouvertes. Ajoutez private import HolarchMetadata::*; et l'exigence VR-5 ChargeTime avec #TBR sur sa limite de temps et @TBD avec un responsable, une échéance et une justification sur la puissance du chargeur. TBD et TBR proviennent de la bibliothèque HolarchMetadata de Holarch, et non de la bibliothèque standard SysML v2 ; ils spécialisent les métadonnées standard StatusInfo.
  9. Ouvrir le registre TBD/TBR. Cliquez sur Besoins et exigences → TBD/TBR. Le temps de charge y figure avec le responsable et l'échéance de ses métadonnées @TBD. Le registre est en lecture seule : modifiez le responsable ou la date dans les métadonnées, dans l'éditeur.
  10. Consolider la masse. Cliquez sur Architecture → Budgets et TPM et sélectionnez la partie racine sedan.

Variantes et configurations

Le projet de départ contient Component, Battery, Controller, Car et Powertrain.

  1. Importer le package de variabilité. Ajoutez private import HolarchVariability::*;.
  2. Écrire une variation. Sur une ligne vide, appuyez sur ⌃⇧Space / Ctrl+Shift+Space (ou cliquez sur Insérer ▾), choisissez Variation et complétez variation part def BatteryPack :> Battery avec les variantes standardPack (1,4 kWh) et largePack (12 kWh, 120 kg).
  3. Écrire la ligne de produits. Ajoutez part def CarLine :> Car avec part pack : BatteryPack;, une variation part charger avec les variantes noCharger et wallbox, et assert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack }.
  4. Commencer une configuration. Choisissez Insérer ▾ → Configuration et complétez part plugInHybrid : CarLine { @HolarchConfiguration; }. L'éditeur signale les points de variation encore ouverts.
  5. Choisir les variantes. Dans plugInHybrid, choisissez Insérer ▾ → Choix de variante pour chaque point et complétez part :>> pack = BatteryPack::largePack; et part :>> charger = charger::wallbox;.
  6. Ajouter une deuxième configuration. Ajoutez selfChargingHybrid de la même façon, avec le pack standard et sans chargeur.
  7. Définir un mot-clé à vous. Ajoutez metadata def <safetyCritical> SafetyCritical.
  8. Utiliser le mot-clé. Dans Powertrain, écrivez #safetyCritical part controller : Controller;.
  9. Voir la ligne de produits. Créez une vue générale de Vehicles : le pack de batterie est marqué comme variation.

Projets des tutoriels

Les projets des tutoriels SysML v2 suivent les mêmes règles que les autres projets de tutoriel : ils ne comptent pas dans les projets actifs de votre offre, contiennent jusqu'à 300 éléments, et vous pouvez en avoir un par tutoriel. Voir Tutoriels.

SysML® et OMG® sont des marques déposées d'Object Management Group, Inc. aux États-Unis et dans d'autres pays.