SysML v2
SysML v2-Tutorials
Neun geführte Tutorials für SysML v2-Projekte, vom ersten Package bis zu Ports, Aktionen, Zuständen, Anforderungen, Verifikation, Constraints und Varianten, mit einem Schrittbereich, der Ihre Arbeit prüft.
Auf dieser Seite
Holarch bietet eine Reihe geführter Tutorials für SysML v2-Projekte. Jedes erstellt ein kleines SysML v2-Startprojekt und öffnet neben der Seite einen Schrittbereich. Der Bereich prüft das Modell, während Sie arbeiten: Ein Schritt wird grün, wenn das Modell enthält, was der Schritt verlangt. Diese Seite listet jeden Schritt als Text auf, sodass Sie auch hier mitarbeiten können.
Das erste Tutorial verwendet wie die LML-Tutorials die WS-1 Weather Station. Die anderen bauen Teile eines Hybridautos auf, des Modells der Hybrid-Car-Demo: Werttypen und Komponenten, die Ports und Interfaces des Antriebsstrangs, einen Fahrzyklus, die Zustände des Antriebsstrangs, die Anforderungen an das Auto, ihre Verifikation, die Prüfungen der Werte der Limousine und die Produktlinie. Jedes Tutorial hat sein eigenes Startprojekt, sodass Sie sie in beliebiger Reihenfolge durcharbeiten können. Jedes Startprojekt und jedes abgeschlossene Tutorial wird mit 0 Problemen geprüft.
| Tutorial | Zeit | Sie lernen, |
|---|---|---|
| Erste Schritte | 15 Min. | SysML v2-Text schreiben, ihn als Baum und als Ansicht sehen, in der Ansicht zeichnen und eine Anforderung hinzufügen |
| Definitionen und Attribute | 20 Min. | Enumerationen, Werttypen und abstrakte Definitionen schreiben, mit Werten und Einheiten spezialisieren sowie Vervollständigung, Einfügen und Umbenennen verwenden |
| Ports und Schnittstellen | 20 Min. | Ports und Interfaces definieren, Ports konjugieren, Parts verbinden und ein Interface in einer Interconnection View zeichnen |
| Aktionen und Flüsse | 20 Min. | Action-Definitionen und einen Fahrzyklus mit Fork, Flows und Join schreiben, Swimlanes hinzufügen und Schritte im FFBD aufbauen |
| Zustände und Übergänge | 20 Min. | Signale und einen Zustandsautomaten mit Auslösern, Guards und Zustandsaktionen schreiben und einen zeitgesteuerten Übergang zeichnen |
| Anforderungen | 20 Min. | Grenzwerte, Requirement-Definitionen und -Verwendungen schreiben, sie erfüllen und eine nicht erfüllte Anforderung sehen |
| Verifikation und Nachverfolgbarkeit | 15 Min. | Einen Verifikationsfall schreiben, einen Schritt in der Nachverfolgbarkeitsmatrix verfolgen und eine Anforderung ableiten |
| Constraints und Berechnungen | 20 Min. | Constraints und Berechnungen schreiben, Werte in einer Parametrik-Ansicht binden, einen Analysefall ausführen und TBD- und TBR-Werte markieren |
| Varianten und Konfigurationen | 15 Min. | Variationen und Varianten, eine Produktlinie mit einer Regel, Konfigurationen und ein eigenes Schlüsselwort schreiben |
So setzen Sie es ein
Ein SysML v2-Tutorial starten
- Öffnen Sie in der Leiste Hilfe → Tutorials, oder drücken Sie ⌘K / Ctrl+K und geben Sie
tutorialein. Außerhalb eines Projekts listet die Seite Tutorials zuerst die LML-Tutorials und dann Tutorials für SysML-v2-Projekte. Innerhalb eines SysML v2-Projekts listet sie nur die SysML v2-Tutorials. - Klicken Sie auf einer Karte auf Starten. Holarch erstellt das Projekt, zum Beispiel Tutorial: SysML v2 Ports and Interfaces (Hybrid Car), und öffnet es mit dem Schrittbereich rechts.
Der Schrittbereich funktioniert wie in den LML-Tutorials: Zeig es mir hebt das Bedienelement hervor, das ein Schritt benötigt, Dorthin gehen öffnet die Seite, Mehr lesen öffnet das Hilfethema, und Neu starten…, Als erledigt markieren und × funktionieren genauso. Siehe Tutorials.
Den Text eines Schritts eingeben
Die meisten Schritte geben SysML-Text vor, den Sie in Modell → Editor eingeben. Der Schritt sagt, wohin die Zeilen gehören, zum Beispiel „vor die letzte schließende geschweifte Klammer des Packages“. Der Text wird auf das Modell angewendet, wenn Sie beim Tippen innehalten; der Status unter dem Editor meldet es, und der Schritt wird grün.
- Geben Sie die Zeilen wie gezeigt ein. Die Einrückung spielt für das Modell keine Rolle; der Editor behält Ihre bei.
- Eine rote Unterstreichung markiert einen Fehler: Zeigen Sie darauf, um die Meldung zu lesen. Text mit einem Syntaxfehler bleibt ein Entwurf und wird erst angewendet, wenn Sie ihn korrigieren.
- ⌘Z / Ctrl+Z macht die zuletzt angewendete Änderung rückgängig.
Tipps
- Arbeiten Sie die Tutorials beim ersten Mal der Reihe nach durch: Jedes erklärt den Text, den es verwendet, und spätere setzen die früheren Konzepte voraus (Definitionen und Verwendungen,
:>und:>>). - Ein Schritt, der offen bleibt, hat meist einen Tippfehler in einem Namen. Vergleichen Sie Ihren Text mit den Zeilen des Schritts; in SysML v2 wird bei Namen zwischen Groß- und Kleinschreibung unterschieden.
- Die Tutorials vermitteln dieselbe Sprache wie SysML v2-Grundlagen; die Seite Textnotation enthält die Details.
Erste Schritte
Schreiben Sie ein erstes Modell der Weather Station: Öffnen Sie den Text, fügen Sie eine Part-Definition mit einem Wert und einer Einheit hinzu, verwenden Sie sie in einer anderen Definition, sehen Sie das Modell im Browser und in einer General View, zeichnen Sie einen Part in der Ansicht und sehen Sie zu, wie er im Text erscheint, fügen Sie eine Anforderung mit satisfy hinzu und exportieren Sie das Modell als .sysml-Datei. Die Schritte sind unter Erste Schritte mit SysML v2-Projekten beschrieben.
Definitionen und Attribute
Das Startprojekt enthält das Package Vehicles mit einer Part-Definition, Car.
- Das Package öffnen. Klicken Sie auf Modell → Editor. Jede Deklaration besteht aus einem Schlüsselwort und einem Namen, dann einem Rumpf in geschweiften Klammern oder einem Semikolon.
- Eine Enumeration schreiben. Fügen Sie über
part def Car {die Zeileenum def DriveMode { enum economy; enum normal; enum sport; }hinzu (ein Wert pro Zeile). - Einen Werttyp definieren. Fügen Sie darunter
attribute def TirePressure :> ScalarValue;hinzu.:>bedeutet „spezialisiert“. - Eine abstrakte Definition schreiben. Fügen Sie
abstract part def Componentmit einemdoc-Kommentar und den Attributenmass : MassValue,partNumber : Stringundpower : PowerValuehinzu.//beginnt eine Notiz, die nur im Text bleibt. - Den Checker einen Fehler finden lassen. Fügen Sie
part def Battery :> Componentmitattribute redefines mass = 45 [kg];und absichtlichattribute redefines power = 60 [kg];hinzu. Der Checker unterstreicht die Einheit: Kilogramm sind keine Leistung. - Die Einheit korrigieren. Ändern Sie sie in
60 [W]. - Einen Namen vervollständigen. Geben Sie in der Batterie
attribute capacity : Enerein, übernehmen SieEnergyValuemit Enter aus der Vervollständigungsliste und schließen Sie mit;ab. - In der Standardbibliothek nachschlagen. Klicken Sie unten in der Leiste auf Einstellungen → Standardbibliothek und geben Sie
EnergyValuein das Suchfeld ein. - Eine Definition einfügen. Drücken Sie im Editor in einer leeren Zeile ⌃⇧Space / Ctrl+Shift+Space (oder klicken Sie auf Einfügen ▾), wählen Sie Part-Definition und vervollständigen Sie
part def Engine :> Componentmitattribute redefines mass = 110 [kg];undattribute cylinders : Integer;. - Die Definitionen verwenden. Fügen Sie in
Cardie Zeilenattribute mode : DriveMode;,part battery : Battery;undpart engine : Engine;hinzu. - Überall umbenennen. Setzen Sie den Cursor auf
cylinders, drücken Sie F2 und benennen Sie es incylinderCountum.
Ports und Schnittstellen
Das Startprojekt enthält die Komponenten des Antriebsstrangs mit ihren Drehmoment- und Leistungsports, die Port-Definitionen TorquePort und PowerPort sowie die Interface-Definitionen Shaft und HighVoltageBus.
- Einen Port definieren. Fügen Sie über
port def TorquePortdie Definitionport def FuelPortmitout attribute flowRate : Real;undattribute kind : FuelKind;hinzu.outbedeutet, dass der Wert den Part verlässt, dem der Port gehört. - Den Parts ihre Ports geben. Fügen Sie
port fuelOut : FuelPort;zuFuelTankundport fuelIn : ~FuelPort;zuEnginehinzu.~konjugiert den Port: Ein- und Ausgang sind vertauscht. - Ein Interface definieren. Fügen Sie
interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }hinzu. - Den Antriebsstrang aufbauen. Fügen Sie am Ende des Packages
part def Powertrainmit den Partstank,engine,motor,batteryundtransmission, einem Portoutput : TorquePortundbind output = transmission.output;hinzu. - Zwei Parts verbinden. Fügen Sie im Antriebsstrang
interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn;hinzu. - Die Wellen hinzufügen. Fügen Sie
interface engineShaft : Shaft connect engine.output to transmission.engineIn;undinterface motorShaft : Shaft connect motor.output to transmission.motorIn;hinzu. - Eine Interconnection View erstellen. Klicken Sie auf Architektur → Interconnection Views und dann auf + Neues Diagramm. Wählen Sie unter Zeigt
Powertrainund klicken Sie auf Erstellen. - Ein Interface zeichnen. Ziehen Sie vom Griff des Ports
powerOutder Batterie zum PortpowerIndes Motors und legen Sie auf Interface : HighVoltageBus ab. - Das Interface benennen. Wählen Sie die neue Linie aus und geben Sie im Inspektor
hvBusals Name ein. - Es im Text sehen. Klicken Sie auf Modell → Editor: Das Interface steht im Antriebsstrang, mit seinem Namen, seinem Typ und seinen Enden.
Aktionen und Flüsse
Das Startprojekt enthält das Package VehicleBehavior mit den Items Fuel und Torque, den Funktionen ProduceTorque (F.2) und DriveWheels (F.3) sowie drei Part-Definitionen.
- Eine Funktion definieren. Fügen Sie
action def <'F.1'> SupplyFuelmitin attribute fuelDemand : Real;undout item fuel : Fuel;hinzu. Der Kurzname in spitzen Klammern ist die Funktionsnummer. - Den Fahrzyklus schreiben. Fügen Sie
action def <'F'> DriveCyclemitfirst start then split;,fork split;,then supply;,then produce;und den Schrittenaction supply : SupplyFuelundaction produce : ProduceTorquehinzu, jeder mit einerduration. - Einen Flow hinzufügen. Fügen Sie im Fahrzyklus
flow of Fuel from supply.fuel to produce.fuel;hinzu. - Die Zweige zusammenführen. Fügen Sie
first supply then ready;,first produce then ready;,join ready;,then action drive : DriveWheels { … },then done;undflow produce.torque to drive.torque;hinzu. - Eine Action Flow View erstellen. Klicken Sie auf Verhalten → Action Flows, dann auf + Neues Diagramm, und wählen Sie unter Zeigt
DriveCycle. - Festlegen, wer jeden Schritt ausführt. Fügen Sie
part def DrivenCarmitperform action trip : DriveCycle;und den Partstank,engineundtransmissionhinzu, jeweils mitperform trip.supply;,perform trip.produce;oderperform trip.drive;. Die Ansicht erhält eine Swimlane pro Part. - Die Funktionsanalyse öffnen. Klicken Sie auf Verhalten → Funktionsanalyse, klicken Sie auf Auswählen… und wählen Sie
DriveCycle. - Eine weitere Action deklarieren. Fügen Sie
action def EmergencyShutdown;hinzu. - Schritte im FFBD aufbauen. Klicken Sie auf Verhalten → FFBD, dann auf + Neues Diagramm, und wählen Sie
EmergencyShutdown. Geben Sie im Bereich HinzufügenOpen Contactorsein und drücken Sie Enter, dannCut Fuel. - Die Schritte im Text sehen. Klicken Sie auf Modell → Editor: Das FFBD hat die Schritte und ihre Abfolgen geschrieben.
Zustände und Übergänge
Das Startprojekt enthält das Package PowertrainBehavior mit einem leeren part def Car.
- Die Signale definieren. Fügen Sie
attribute def StartRequest;hinzu und ebensoStopRequest,PlugInundUnplug. - Eine Zustandsdefinition schreiben. Fügen Sie
state def PowertrainStatesmitin attribute charge : Real;,entry; then off;und den Zuständenoff,electricundhybridhinzu. - Übergänge hinzufügen. Fügen Sie nach
state off;die Zeilenaccept StartRequest if charge > 20 then electric;undaccept StartRequest then hybrid;hinzu. - Einem Zustand seine Actions geben. Ersetzen Sie
state electric;durch einen Rumpf mitentry action spinUpMotor;,do action driveElectric;undexit action holdMotor;. - Den Zustand electric verlassen. Fügen Sie danach
if charge < 15 then hybrid;undaccept StopRequest then off;hinzu; fügen Sieaccept StopRequest then off;auch nachstate hybrid;hinzu. - Einen Zustand mit benannten Übergängen hinzufügen. Fügen Sie
state charging { do action chargeBattery; },transition plugIn first off accept PlugIn then charging;undtransition unplugged first charging accept Unplug then off;hinzu. - Eine State Transition View erstellen. Klicken Sie auf Verhalten → State Machines, dann auf + Neues Diagramm, und wählen Sie unter Zeigt
PowertrainStates. - Einen zeitgesteuerten Übergang zeichnen. Ziehen Sie vom Griff von
chargingzuoffund legen Sie auf Übergang ab. Geben Sie im Übergangsbereich als Namechargedund als Auslöserafter 30 [min]ein. - Es im Text sehen. Klicken Sie auf Modell → Editor: Der Übergang ist als benannter Übergang geschrieben.
- Das Auto die Zustände aufweisen lassen. Fügen Sie in
Cardie Zeileexhibit state powertrainStates : PowertrainStates;hinzu.
Anforderungen
Das Startprojekt enthält das Package VehicleRequirements mit einer kleinen Kopie des Entwurfs: Battery, Car und die Limousine sedan der Flotte mit einer Leermasse von 1580 kg.
- Die Grenzwerte benennen. Fügen Sie
attribute maxCurbMass : MassValue = 1650 [kg];undattribute minBatteryCapacity : EnergyValue = 1.2 [kW*h];hinzu. - Eine Requirement-Definition schreiben. Fügen Sie
requirement def <'VR-1'> CurbMassmit einerdoc-Aussage,subject car : Car;,attribute limit : MassValue;undrequire constraint { car.curbMass <= limit }hinzu. - Eine Anforderung einfügen. Drücken Sie in einer leeren Zeile ⌃⇧Space / Ctrl+Shift+Space, wählen Sie Requirement-Definition und schreiben Sie
VR-3 BatteryCapacitymit dem Subjektbattery : Batteryundrequire constraint { battery.capacity >= minBatteryCapacity }. - Anforderungen in einer Spezifikation verschachteln. Fügen Sie
requirement carSpecmitsubject car : Car;undrequirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }hinzu. - Festlegen, was sie erfüllt. Fügen Sie
satisfy carSpec by fleet.sedan;undsatisfy requirement batterySpec : BatteryCapacity by fleet.sedan.battery;hinzu. - Eine Anforderung verletzen. Ändern Sie die Leermasse der Limousine in
1700 [kg]. Der Editor markiert das Satisfy: Die Limousine erfüllt VR-1.1 nicht mehr. - Sie wieder erfüllen. Drücken Sie ⌘Z / Ctrl+Z oder ändern Sie den Wert zurück in
1580 [kg]. - Die Anforderungstabelle ansehen. Klicken Sie auf Bedarfe & Anforderungen → Anforderungen.
- Eine Requirement-Ansicht erstellen. Klicken Sie auf der Seite Diagramme auf + Neues Diagramm, wählen Sie Requirement-Ansicht und unter Zeigt
carSpec. - Die Aussagen prüfen. Klicken Sie auf Bedarfe & Anforderungen → Qualität und dann auf Qualität prüfen.
Verifikation und Nachverfolgbarkeit
Das Startprojekt enthält die Anforderung an die Leermasse und die Spezifikation des Autos, einen Fahrzyklus mit den Schritten cruise und brake, VR-6 batteryMassLimit und VR-7 stopFromCruise.
- Einen Verifikationsfall schreiben. Fügen Sie
verification def <'VC-1'> CurbMassTestmitsubject car : Car;,objective massObjective { verify carSpec.sedanMass; }undreturn verdict : Boolean = car.curbMass <= maxCurbMass;hinzu. - Ihn auf die Limousine anwenden. Fügen Sie
verification <'VC-1.1'> sedanWeighing : CurbMassTest { subject car = fleet.sedan; }hinzu. - Die Verifikationsfälle öffnen. Klicken Sie auf Verifikation → Verifikationsfälle. Schritte, Ergebnisse und Status sind Holarch-Daten neben dem Modell. Klicken Sie in der Zeile von Sedan Weighing auf + Schritte, dann auf + Schritt hinzufügen, geben Sie unter Action
Weigh the carein und klicken Sie auf Anwenden. Klicken Sie dann in den Statusschaltflächen auf Bestanden. - Die RVTM lesen. Klicken Sie auf Verifikation → RVTM.
- Einen Schritt zu einer Anforderung verfolgen. Klicken Sie auf Verifikation → Nachverfolgbarkeitsmatrix, zeigen Sie Anforderungen als Zeilen und Actions als Spalten an, klicken Sie auf die Zelle von
stopFromCruiseundbrakeund wählen Sie erfüllt durch. - Eine Anforderung ableiten. Fügen Sie
private import RequirementDerivation::*;undconnection batteryMassDerivation : Derivation connect carSpec.sedanMass to batteryMassLimit;hinzu. - Die Modellprüfungen ausführen. Klicken Sie auf Verifikation → Modellprüfungen.
Constraints und Berechnungen
Das Startprojekt enthält das Package VehicleAnalysis mit Motor, Batterie, Auto und den Werten der Limousine sowie den Zielwerten maxCurbMass und minPowerToWeight.
- Eine Constraint-Definition schreiben. Fügen Sie
constraint def MassLimitmitin mass : MassValue;,in limit : MassValue;und dem Ausdruckmass <= limithinzu. - Eine Berechnung schreiben. Fügen Sie
calc def PowerToWeightmit den Parameternpowerundmassundreturn ratio = power / mass;hinzu. - Die Werte der Limousine binden. Fügen Sie
constraint sedanMassCheck : MassLimit { in mass = fleet.sedan.curbMass; in limit = maxCurbMass; }hinzu. - Eine Parametrik-Ansicht erstellen. Klicken Sie auf der Seite Diagramme auf + Neues Diagramm, wählen Sie Parametrik-Ansicht und unter Zeigt
VehicleAnalysis. Die Prüfung ist bestanden: 1580 kg liegen innerhalb von 1650 kg. - Die Prüfung scheitern lassen. Ändern Sie die Leermasse der Limousine in
1700 [kg]; die Ansicht zeigt die fehlgeschlagene Prüfung. - Sie wieder bestehen lassen. Machen Sie die Änderung rückgängig oder ändern Sie den Wert zurück in
1580 [kg]. Alle lösen prüft jeden Constraint erneut. - Einen Analysefall ausführen. Fügen Sie
analysis def PowerToWeightAnalysismit einem Ziel, dasratio >= minPowerToWeightverlangt, undanalysis sedanPowerToWeight : PowerToWeightAnalysis { subject car = fleet.sedan; }hinzu. - Offene Werte markieren. Fügen Sie
private import HolarchMetadata::*;und die Anforderung VR-5ChargeTimehinzu, mit#TBRan ihrem Zeitlimit und@TBDmit einem Verantwortlichen, einem Fälligkeitsdatum und einer Begründung an der Ladeleistung.TBDundTBRstammen aus der Holarch-BibliothekHolarchMetadata, nicht aus der SysML v2-Standardbibliothek; sie spezialisieren die Standard-MetadatenStatusInfo. - Das TBD/TBR-Register öffnen. Klicken Sie auf Bedarfe & Anforderungen → TBD/TBR. Die Ladezeit wird mit dem Verantwortlichen und dem Fälligkeitsdatum ihrer
@TBD-Metadaten aufgeführt. Das Register ist schreibgeschützt: Ändern Sie den Verantwortlichen oder das Datum in den Metadaten im Editor. - Die Masse aufsummieren. Klicken Sie auf Architektur → Budgets & TPMs und wählen Sie den Wurzel-Part
sedan.
Varianten und Konfigurationen
Das Startprojekt enthält Component, Battery, Controller, Car und Powertrain.
- Das Variabilitäts-Package importieren. Fügen Sie
private import HolarchVariability::*;hinzu. - Eine Variation schreiben. Drücken Sie in einer leeren Zeile ⌃⇧Space / Ctrl+Shift+Space (oder klicken Sie auf Einfügen ▾), wählen Sie Variation und vervollständigen Sie
variation part def BatteryPack :> Batterymit den VariantenstandardPack(1,4 kWh) undlargePack(12 kWh, 120 kg). - Die Produktlinie schreiben. Fügen Sie
part def CarLine :> Carmitpart pack : BatteryPack;, einemvariation part chargermit den VariantennoChargerundwallboxsowieassert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack }hinzu. - Eine Konfiguration beginnen. Wählen Sie Einfügen ▾ → Konfiguration und füllen Sie
part plugInHybrid : CarLine { @HolarchConfiguration; }aus. Der Editor vermerkt die noch offenen Variationspunkte. - Die Varianten wählen. Wählen Sie in
plugInHybridfür jeden Punkt Einfügen ▾ → Variantenwahl und füllen Siepart :>> pack = BatteryPack::largePack;undpart :>> charger = charger::wallbox;aus. - Eine zweite Konfiguration hinzufügen. Fügen Sie
selfChargingHybridauf dieselbe Weise hinzu, mit dem Standard-Pack und ohne Ladegerät. - Ein eigenes Schlüsselwort definieren. Fügen Sie
metadata def <safetyCritical> SafetyCriticalhinzu. - Das Schlüsselwort verwenden. Schreiben Sie in
Powertraindie Zeile#safetyCritical part controller : Controller;. - Die Produktlinie ansehen. Erstellen Sie eine General View von
Vehicles: Das Batterie-Pack ist als Variation markiert.
Tutorial-Projekte
SysML v2-Tutorial-Projekte folgen denselben Regeln wie die anderen Tutorial-Projekte: Sie zählen nicht zu den aktiven Projekten Ihres Tarifs, enthalten bis zu 300 Elemente, und Sie können pro Tutorial eines haben. Siehe Tutorials.
Verwandte Themen
- Tutorials
- Erste Schritte mit SysML v2-Projekten
- Texteditor und Browser
- Textnotation
- Views
- Anforderungen in SysML v2-Projekten
SysML® und OMG® sind eingetragene Marken der Object Management Group, Inc. in den Vereinigten Staaten und anderen Ländern.