Holarch

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.

So gehen Sie vor →

Auf dieser Seite
  1. So setzen Sie es ein
    1. Ein SysML v2-Tutorial starten
    2. Den Text eines Schritts eingeben
    3. Tipps
  2. Erste Schritte
  3. Definitionen und Attribute
  4. Ports und Schnittstellen
  5. Aktionen und Flüsse
  6. Zustände und Übergänge
  7. Anforderungen
  8. Verifikation und Nachverfolgbarkeit
  9. Constraints und Berechnungen
  10. Varianten und Konfigurationen
  11. Tutorial-Projekte
  12. Verwandte Themen

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.

TutorialZeitSie lernen,
Erste Schritte15 Min.SysML v2-Text schreiben, ihn als Baum und als Ansicht sehen, in der Ansicht zeichnen und eine Anforderung hinzufügen
Definitionen und Attribute20 Min.Enumerationen, Werttypen und abstrakte Definitionen schreiben, mit Werten und Einheiten spezialisieren sowie Vervollständigung, Einfügen und Umbenennen verwenden
Ports und Schnittstellen20 Min.Ports und Interfaces definieren, Ports konjugieren, Parts verbinden und ein Interface in einer Interconnection View zeichnen
Aktionen und Flüsse20 Min.Action-Definitionen und einen Fahrzyklus mit Fork, Flows und Join schreiben, Swimlanes hinzufügen und Schritte im FFBD aufbauen
Zustände und Übergänge20 Min.Signale und einen Zustandsautomaten mit Auslösern, Guards und Zustandsaktionen schreiben und einen zeitgesteuerten Übergang zeichnen
Anforderungen20 Min.Grenzwerte, Requirement-Definitionen und -Verwendungen schreiben, sie erfüllen und eine nicht erfüllte Anforderung sehen
Verifikation und Nachverfolgbarkeit15 Min.Einen Verifikationsfall schreiben, einen Schritt in der Nachverfolgbarkeitsmatrix verfolgen und eine Anforderung ableiten
Constraints und Berechnungen20 Min.Constraints und Berechnungen schreiben, Werte in einer Parametrik-Ansicht binden, einen Analysefall ausführen und TBD- und TBR-Werte markieren
Varianten und Konfigurationen15 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

  1. Öffnen Sie in der Leiste Hilfe → Tutorials, oder drücken Sie ⌘K / Ctrl+K und geben Sie tutorial ein. 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.
  2. 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.

  1. 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.
  2. Eine Enumeration schreiben. Fügen Sie über part def Car { die Zeile enum def DriveMode { enum economy; enum normal; enum sport; } hinzu (ein Wert pro Zeile).
  3. Einen Werttyp definieren. Fügen Sie darunter attribute def TirePressure :> ScalarValue; hinzu. :> bedeutet „spezialisiert“.
  4. Eine abstrakte Definition schreiben. Fügen Sie abstract part def Component mit einem doc-Kommentar und den Attributen mass : MassValue, partNumber : String und power : PowerValue hinzu. // beginnt eine Notiz, die nur im Text bleibt.
  5. Den Checker einen Fehler finden lassen. Fügen Sie part def Battery :> Component mit attribute redefines mass = 45 [kg]; und absichtlich attribute redefines power = 60 [kg]; hinzu. Der Checker unterstreicht die Einheit: Kilogramm sind keine Leistung.
  6. Die Einheit korrigieren. Ändern Sie sie in 60 [W].
  7. Einen Namen vervollständigen. Geben Sie in der Batterie attribute capacity : Ener ein, übernehmen Sie EnergyValue mit Enter aus der Vervollständigungsliste und schließen Sie mit ; ab.
  8. In der Standardbibliothek nachschlagen. Klicken Sie unten in der Leiste auf Einstellungen → Standardbibliothek und geben Sie EnergyValue in das Suchfeld ein.
  9. 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 :> Component mit attribute redefines mass = 110 [kg]; und attribute cylinders : Integer;.
  10. Die Definitionen verwenden. Fügen Sie in Car die Zeilen attribute mode : DriveMode;, part battery : Battery; und part engine : Engine; hinzu.
  11. Überall umbenennen. Setzen Sie den Cursor auf cylinders, drücken Sie F2 und benennen Sie es in cylinderCount um.

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.

  1. Einen Port definieren. Fügen Sie über port def TorquePort die Definition port def FuelPort mit out attribute flowRate : Real; und attribute kind : FuelKind; hinzu. out bedeutet, dass der Wert den Part verlässt, dem der Port gehört.
  2. Den Parts ihre Ports geben. Fügen Sie port fuelOut : FuelPort; zu FuelTank und port fuelIn : ~FuelPort; zu Engine hinzu. ~ konjugiert den Port: Ein- und Ausgang sind vertauscht.
  3. Ein Interface definieren. Fügen Sie interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; } hinzu.
  4. Den Antriebsstrang aufbauen. Fügen Sie am Ende des Packages part def Powertrain mit den Parts tank, engine, motor, battery und transmission, einem Port output : TorquePort und bind output = transmission.output; hinzu.
  5. Zwei Parts verbinden. Fügen Sie im Antriebsstrang interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn; hinzu.
  6. Die Wellen hinzufügen. Fügen Sie interface engineShaft : Shaft connect engine.output to transmission.engineIn; und interface motorShaft : Shaft connect motor.output to transmission.motorIn; hinzu.
  7. Eine Interconnection View erstellen. Klicken Sie auf Architektur → Interconnection Views und dann auf + Neues Diagramm. Wählen Sie unter Zeigt Powertrain und klicken Sie auf Erstellen.
  8. Ein Interface zeichnen. Ziehen Sie vom Griff des Ports powerOut der Batterie zum Port powerIn des Motors und legen Sie auf Interface : HighVoltageBus ab.
  9. Das Interface benennen. Wählen Sie die neue Linie aus und geben Sie im Inspektor hvBus als Name ein.
  10. 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.

  1. Eine Funktion definieren. Fügen Sie action def <'F.1'> SupplyFuel mit in attribute fuelDemand : Real; und out item fuel : Fuel; hinzu. Der Kurzname in spitzen Klammern ist die Funktionsnummer.
  2. Den Fahrzyklus schreiben. Fügen Sie action def <'F'> DriveCycle mit first start then split;, fork split;, then supply;, then produce; und den Schritten action supply : SupplyFuel und action produce : ProduceTorque hinzu, jeder mit einer duration.
  3. Einen Flow hinzufügen. Fügen Sie im Fahrzyklus flow of Fuel from supply.fuel to produce.fuel; hinzu.
  4. Die Zweige zusammenführen. Fügen Sie first supply then ready;, first produce then ready;, join ready;, then action drive : DriveWheels { … }, then done; und flow produce.torque to drive.torque; hinzu.
  5. Eine Action Flow View erstellen. Klicken Sie auf Verhalten → Action Flows, dann auf + Neues Diagramm, und wählen Sie unter Zeigt DriveCycle.
  6. Festlegen, wer jeden Schritt ausführt. Fügen Sie part def DrivenCar mit perform action trip : DriveCycle; und den Parts tank, engine und transmission hinzu, jeweils mit perform trip.supply;, perform trip.produce; oder perform trip.drive;. Die Ansicht erhält eine Swimlane pro Part.
  7. Die Funktionsanalyse öffnen. Klicken Sie auf Verhalten → Funktionsanalyse, klicken Sie auf Auswählen… und wählen Sie DriveCycle.
  8. Eine weitere Action deklarieren. Fügen Sie action def EmergencyShutdown; hinzu.
  9. Schritte im FFBD aufbauen. Klicken Sie auf Verhalten → FFBD, dann auf + Neues Diagramm, und wählen Sie EmergencyShutdown. Geben Sie im Bereich Hinzufügen Open Contactors ein und drücken Sie Enter, dann Cut Fuel.
  10. 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.

  1. Die Signale definieren. Fügen Sie attribute def StartRequest; hinzu und ebenso StopRequest, PlugIn und Unplug.
  2. Eine Zustandsdefinition schreiben. Fügen Sie state def PowertrainStates mit in attribute charge : Real;, entry; then off; und den Zuständen off, electric und hybrid hinzu.
  3. Übergänge hinzufügen. Fügen Sie nach state off; die Zeilen accept StartRequest if charge > 20 then electric; und accept StartRequest then hybrid; hinzu.
  4. Einem Zustand seine Actions geben. Ersetzen Sie state electric; durch einen Rumpf mit entry action spinUpMotor;, do action driveElectric; und exit action holdMotor;.
  5. Den Zustand electric verlassen. Fügen Sie danach if charge < 15 then hybrid; und accept StopRequest then off; hinzu; fügen Sie accept StopRequest then off; auch nach state hybrid; hinzu.
  6. Einen Zustand mit benannten Übergängen hinzufügen. Fügen Sie state charging { do action chargeBattery; }, transition plugIn first off accept PlugIn then charging; und transition unplugged first charging accept Unplug then off; hinzu.
  7. Eine State Transition View erstellen. Klicken Sie auf Verhalten → State Machines, dann auf + Neues Diagramm, und wählen Sie unter Zeigt PowertrainStates.
  8. Einen zeitgesteuerten Übergang zeichnen. Ziehen Sie vom Griff von charging zu off und legen Sie auf Übergang ab. Geben Sie im Übergangsbereich als Name charged und als Auslöser after 30 [min] ein.
  9. Es im Text sehen. Klicken Sie auf Modell → Editor: Der Übergang ist als benannter Übergang geschrieben.
  10. Das Auto die Zustände aufweisen lassen. Fügen Sie in Car die Zeile exhibit 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.

  1. Die Grenzwerte benennen. Fügen Sie attribute maxCurbMass : MassValue = 1650 [kg]; und attribute minBatteryCapacity : EnergyValue = 1.2 [kW*h]; hinzu.
  2. Eine Requirement-Definition schreiben. Fügen Sie requirement def <'VR-1'> CurbMass mit einer doc-Aussage, subject car : Car;, attribute limit : MassValue; und require constraint { car.curbMass <= limit } hinzu.
  3. 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 BatteryCapacity mit dem Subjekt battery : Battery und require constraint { battery.capacity >= minBatteryCapacity }.
  4. Anforderungen in einer Spezifikation verschachteln. Fügen Sie requirement carSpec mit subject car : Car; und requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; } hinzu.
  5. Festlegen, was sie erfüllt. Fügen Sie satisfy carSpec by fleet.sedan; und satisfy requirement batterySpec : BatteryCapacity by fleet.sedan.battery; hinzu.
  6. 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.
  7. Sie wieder erfüllen. Drücken Sie ⌘Z / Ctrl+Z oder ändern Sie den Wert zurück in 1580 [kg].
  8. Die Anforderungstabelle ansehen. Klicken Sie auf Bedarfe & Anforderungen → Anforderungen.
  9. Eine Requirement-Ansicht erstellen. Klicken Sie auf der Seite Diagramme auf + Neues Diagramm, wählen Sie Requirement-Ansicht und unter Zeigt carSpec.
  10. 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.

  1. Einen Verifikationsfall schreiben. Fügen Sie verification def <'VC-1'> CurbMassTest mit subject car : Car;, objective massObjective { verify carSpec.sedanMass; } und return verdict : Boolean = car.curbMass <= maxCurbMass; hinzu.
  2. Ihn auf die Limousine anwenden. Fügen Sie verification <'VC-1.1'> sedanWeighing : CurbMassTest { subject car = fleet.sedan; } hinzu.
  3. 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 car ein und klicken Sie auf Anwenden. Klicken Sie dann in den Statusschaltflächen auf Bestanden.
  4. Die RVTM lesen. Klicken Sie auf Verifikation → RVTM.
  5. 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 stopFromCruise und brake und wählen Sie erfüllt durch.
  6. Eine Anforderung ableiten. Fügen Sie private import RequirementDerivation::*; und connection batteryMassDerivation : Derivation connect carSpec.sedanMass to batteryMassLimit; hinzu.
  7. 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.

  1. Eine Constraint-Definition schreiben. Fügen Sie constraint def MassLimit mit in mass : MassValue;, in limit : MassValue; und dem Ausdruck mass <= limit hinzu.
  2. Eine Berechnung schreiben. Fügen Sie calc def PowerToWeight mit den Parametern power und mass und return ratio = power / mass; hinzu.
  3. Die Werte der Limousine binden. Fügen Sie constraint sedanMassCheck : MassLimit { in mass = fleet.sedan.curbMass; in limit = maxCurbMass; } hinzu.
  4. 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.
  5. Die Prüfung scheitern lassen. Ändern Sie die Leermasse der Limousine in 1700 [kg]; die Ansicht zeigt die fehlgeschlagene Prüfung.
  6. 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.
  7. Einen Analysefall ausführen. Fügen Sie analysis def PowerToWeightAnalysis mit einem Ziel, das ratio >= minPowerToWeight verlangt, und analysis sedanPowerToWeight : PowerToWeightAnalysis { subject car = fleet.sedan; } hinzu.
  8. Offene Werte markieren. Fügen Sie private import HolarchMetadata::*; und die Anforderung VR-5 ChargeTime hinzu, mit #TBR an ihrem Zeitlimit und @TBD mit einem Verantwortlichen, einem Fälligkeitsdatum und einer Begründung an der Ladeleistung. TBD und TBR stammen aus der Holarch-Bibliothek HolarchMetadata, nicht aus der SysML v2-Standardbibliothek; sie spezialisieren die Standard-Metadaten StatusInfo.
  9. 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.
  10. 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.

  1. Das Variabilitäts-Package importieren. Fügen Sie private import HolarchVariability::*; hinzu.
  2. 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 :> Battery mit den Varianten standardPack (1,4 kWh) und largePack (12 kWh, 120 kg).
  3. Die Produktlinie schreiben. Fügen Sie part def CarLine :> Car mit part pack : BatteryPack;, einem variation part charger mit den Varianten noCharger und wallbox sowie assert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack } hinzu.
  4. 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.
  5. Die Varianten wählen. Wählen Sie in plugInHybrid für jeden Punkt Einfügen ▾ → Variantenwahl und füllen Sie part :>> pack = BatteryPack::largePack; und part :>> charger = charger::wallbox; aus.
  6. Eine zweite Konfiguration hinzufügen. Fügen Sie selfChargingHybrid auf dieselbe Weise hinzu, mit dem Standard-Pack und ohne Ladegerät.
  7. Ein eigenes Schlüsselwort definieren. Fügen Sie metadata def <safetyCritical> SafetyCritical hinzu.
  8. Das Schlüsselwort verwenden. Schreiben Sie in Powertrain die Zeile #safetyCritical part controller : Controller;.
  9. 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.

SysML® und OMG® sind eingetragene Marken der Object Management Group, Inc. in den Vereinigten Staaten und anderen Ländern.