Leitfaden · SysML v2
SysML-v2-Tutorial: das Energiesystem eines CubeSats in der textuellen Notation modellieren
Diesen Leitfaden anhören (Audio auf Englisch) 24 min
Dieses SysML-v2-Tutorial baut Schritt für Schritt ein kleines, vollständiges Modell auf: das elektrische Energiesystem des CubeSats EO-1, mit seinen Parts, Größen und Einheiten, Ports und Verbindungen, einem Zyklus aus Sonnen- und Schattenphase, Anforderungen, die ein Werkzeug prüfen kann, einem Verification Case und Ansichten. Jede Auflistung auf dieser Seite ist SysML-v2-Text, der mit einer Sprach-Engine geprüft wurde, und jeder wichtige Schritt zeigt das Diagramm, das der Text erzeugt.
Auf dieser Seite
- Was Sie bauen
- Die erste Idee: Definitionen und Usages
- Schritt 1: ein Paket und seine Importe
- Schritt 2: Part-Definitionen und Attribute mit Einheiten
- Schritt 3: die Baugruppe, mit Werten
- Schritt 4: Ports, Interfaces und Verbindungen
- Schritt 5: Verhalten mit Aktionen und Flows
- Schritt 6: Verhalten der Struktur zuordnen
- Schritt 7: Anforderungen mit Constraints
- Schritt 8: ein Verification Case
- Schritt 9: Ansichten und Diagramme
- Das vollständige Modell
- Wie die Auflistungen geprüft wurden
- In Holarch ausprobieren
- Wie es weitergeht
Was Sie bauen
EO-1 ist ein 6U-CubeSat zur Erdbeobachtung in einer sonnensynchronen Umlaufbahn auf 500 km. Er ist das gemeinsame Beispiel dieser Leitfäden; das MBSE-Beispielprojekt verfolgt das ganze Raumfahrzeug von den Bedarfen bis zur Verifikation. Dieses Tutorial nimmt ein Subsystem, das elektrische Energiesystem (EPS), und schreibt es in SysML-v2-Text.
Das EPS hat drei Parts. Zwei ausklappbare Solar Arrays wandeln Sonnenlicht in Leistung um. Ein Lithium-Ionen-Battery-Pack speichert Energie für die Schattenphase. Eine Leistungsverteilungseinheit (PDU) folgt dem Punkt maximaler Leistung der Arrays, lädt die Batterie und regelt den 12-V-Bus. Zwei Verbraucher an diesem Bus sind ebenfalls im Modell: die Nutzlastkamera und der S-Band-Sender.
Die Zahlen stammen aus dem EO-1-Modell:
| Element | Wert | Wo es verwendet wird |
|---|---|---|
| Solar Arrays: Zellfläche, Zellwirkungsgrad, Spitzenleistung | 0,2 m², 0,295, 75,4 W | Schritt 3 |
| Wirkungsgrad des Leistungspfads; besonnter Anteil der Umlaufbahn | 0.6; 0.62 | Schritt 3 |
| Battery Pack: Kapazität; in der 36-minütigen Schattenphase entnommene Energie | 77 Wh; 18,5 Wh | Schritt 3 |
| Masse: Arrays, Batterie, PDU | 0,45 kg, 0,62 kg, 0,28 kg | Schritt 3 |
| Orbitgemittelte Leistungsaufnahme: Kamera, S-Band-Sender | 6,2 W, 3,4 W | Schritt 3 |
| Anforderung 3.1 Orbit Average Power | mindestens 28 W am Lebensende | Schritt 7 |
| Anforderung 3.2 Battery Capacity | mindestens 77 Wh zu Lebensbeginn | Schritte 7 und 8 |
| Anforderung 3.3 Depth of Discharge | höchstens 30 % pro Umlauf | Schritt 7 |
| Testfall TC-07 Battery Capacity Test | Entladung bei C/2 in einer Kammer bei 20 °C | Schritt 8 |
Das Modell hat drei Pakete:
| Package | Enthält | Schritte |
|---|---|---|
CubeSatEPS | Ports, Parts, eine Berechnung, die Baugruppen mit ihren Werten und das Verhalten | 1 bis 6 |
CubeSatEPSRequirements | Anforderungen 3.1 bis 3.3 und der Verification Case TC-07 | 7 und 8 |
CubeSatEPSViews | Ansichten, die Teile des Modells für Diagramme auswählen | 9 |
Zum Mitmachen ist kein bestimmtes Werkzeug nötig: Der Text ist reines SysML v2 und lässt sich in jedes Werkzeug laden, das die textuelle Notation liest. Das vollständige Modell steht am Ende der Seite und als Download bereit, und der letzte Abschnitt zeigt, wie Sie es in Holarch laden.
Die erste Idee: Definitionen und Usages
SysML v2 trennt eine Definition von einer Usage. Eine Definition sagt, was eine Art von Ding ist: part def BatteryPack beschreibt jedes Battery Pack dieses Entwurfs, mit seinen Attributen und Ports. Eine Usage ist ein solches Ding in einem Kontext: part battery : BatteryPack im Energiesystem ist die eine Batterie des EPS von EO-1, verbunden mit ihrer PDU.
Dieselbe Paarung zieht sich durch die ganze Sprache: attribute def und attribute, port def und port, action def und action, requirement def und requirement. Ein Schlüsselwort gefolgt von def deklariert eine Art; dasselbe Schlüsselwort ohne def verwendet eine. Konkrete Werte gehören meist an Usages, weil an einer Usage eine Entwurfsentscheidung getroffen wird.
Wer SysML v1 kennt, kann eine Definition mit einem Block und eine Usage mit einer Part Property vergleichen. In SysML v2 gilt die Idee für jede Elementart, und Usages lassen sich beliebig tief verschachteln und verfeinern. SysML v1 und SysML v2 im Vergleich vergleicht die beiden Sprachen Konstrukt für Konstrukt.
Schritt 1: ein Paket und seine Importe
Ein Paket ist ein Namensraum: Es gruppiert Elemente und gibt ihnen qualifizierte Namen wie CubeSatEPS::BatteryPack. Beginnen Sie mit einem leeren Paket und den Bibliotheksimporten, die es braucht.
package CubeSatEPS {
doc /* The electrical power system (EPS) of the EO-1 CubeSat: solar arrays, a battery pack and a power distribution unit that feed the payload camera and the S-band transmitter. */
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
}
doc /* … */hängt Dokumentation an das Paket. Anders als ein//-Kommentar ist sie Teil des Modells, und Werkzeuge zeigen sie mit dem Element an.ScalarValuesstellt Grundtypen wieReal,Integer,BooleanundStringbereit.ISQstellt Größentypen aus dem Internationalen Größensystem bereit, etwaMassValue,PowerValueundEnergyValue.SIstellt SI-Einheiten wiekg,V,Wundhbereit.privatehält die importierten Namen innerhalb dieses Pakets, sodass ein Paket, dasCubeSatEPSimportiert, sie nicht darüber erhält.
Ohne die Importe lässt sich ein Name wie MassValue nicht auflösen, und ein Prüfer meldet ihn als unbekannt.
Schritt 2: Part-Definitionen und Attribute mit Einheiten
Jede Komponente erhält eine Part-Definition mit typisierten Attributen. Wer ein Attribut mit einer Größe statt mit Real typisiert, hält fest, was es misst: eine Masse, eine Leistung, eine Energie. Ein Werkzeug kann dann jeden Wert und jeden Ausdruck auf konsistente Dimensionen prüfen.
part def SolarArray {
attribute mass : MassValue;
attribute cellArea : AreaValue;
attribute cellEfficiency : Real;
attribute peakPower : PowerValue;
attribute pathEfficiency : Real;
}
part def BatteryPack {
attribute mass : MassValue;
attribute capacity : EnergyValue;
}
part def PowerDistributionUnit {
attribute mass : MassValue;
attribute busVoltage : ElectricPotentialValue;
}
part def PayloadCamera {
attribute powerDraw : PowerValue;
}
part def SBandTransmitter {
attribute powerDraw : PowerValue;
}
Diese Zeilen gehören in die geschweiften Klammern des Pakets. Die beiden Wirkungsgrade bleiben einfaches Real, weil sie Verhältnisse ohne Einheit sind.
Noch gibt es keine Werte. Eine Definition beschreibt jedes Battery Pack dieser Art; die Zahlen kommen im nächsten Schritt mit der eigenen Batterie von EO-1.
Schritt 3: die Baugruppe, mit Werten
Das Energiesystem ist ebenfalls eine Part-Definition, aus Part Usages zusammengesetzt: den Solar Arrays, der Batterie und der PDU. Jede Usage gibt den von ihrer Definition geerbten Attributen ihre Werte. Eine wiederverwendbare Berechnung macht aus der Spitzenleistung des Arrays die orbitgemittelte Leistung, gegen die Anforderung 3.1 geschrieben ist.
calc def OrbitAverage {
doc /* Orbit-average array output (EQ-1.3): peak power times the sunlit fraction times the power path efficiency. */
in peakPower : PowerValue;
in sunlitFraction : Real;
in pathEfficiency : Real;
return : PowerValue = peakPower * sunlitFraction * pathEfficiency;
}
part def ElectricalPowerSystem {
part solarArrays : SolarArray {
attribute redefines mass = 0.45 [kg];
attribute redefines cellArea = 0.2 [m^2];
attribute redefines cellEfficiency = 0.295;
attribute redefines peakPower = 75.4 [W];
attribute redefines pathEfficiency = 0.6;
}
part battery : BatteryPack {
attribute redefines mass = 0.62 [kg];
attribute redefines capacity = 77 [W*h];
}
part pdu : PowerDistributionUnit {
attribute redefines mass = 0.28 [kg];
attribute redefines busVoltage = 12 [V];
}
attribute sunlitFraction : Real = 0.62;
attribute eclipseEnergy : EnergyValue = 18.5 [W*h];
attribute orbitAveragePower : PowerValue = OrbitAverage(solarArrays.peakPower, sunlitFraction, solarArrays.pathEfficiency);
attribute depthOfDischarge : Real = eclipseEnergy / battery.capacity;
attribute totalMass : MassValue = solarArrays.mass + battery.mass + pdu.mass;
}
part def Spacecraft {
part eps : ElectricalPowerSystem;
part camera : PayloadCamera {
attribute redefines powerDraw = 6.2 [W];
}
part transmitter : SBandTransmitter {
attribute redefines powerDraw = 3.4 [W];
}
}
part battery : BatteryPackdeklariert eine Usage namensbattery, typisiert durch die DefinitionBatteryPack.attribute redefines capacity = 77 [W*h]gibt dem geerbtencapacityeinen Wert. Die Kurzform:>> capacity = 77 [W*h];bedeutet dasselbe. Ohneredefineswürde die Zeile ein zweites Attribut deklarieren, das nur den Namen teilt, und das geerbtecapacityhätte weiterhin keinen Wert.77 [W*h]ist eine Größe: eine Zahl und eine Einheit. Einheiten werden mit*,/und^kombiniert, Wattstunden sind alsoW*hund Quadratmeterm^2.calc def OrbitAverageist eine Berechnung mit Eingaben und einem typisierten Ergebnis.OrbitAverage(…)ruft sie mit den Werten der Arrays auf, sodass die Formel einmal geschrieben wird und jede Verwendung einer Änderung folgt.depthOfDischargeteilt eine Energie durch eine Energie. Die Einheiten kürzen sich, und das Ergebnis ist ein reines Verhältnis.Spacecraftstellt das Energiesystem neben die beiden Verbraucher, denen dieses Tutorial folgt. Der Rest von EO-1 (Lageregelung, Bordrechner, Struktur) bleibt weg, um das Modell kurz zu halten.
Die Werte werden nicht nur gespeichert; ein Werkzeug wertet sie aus. Mit den obigen Zahlen:
| Attribut | Ausdruck | Ergebnis |
|---|---|---|
orbitAveragePower | 75,4 W × 0,62 × 0,6 | 28,05 W |
depthOfDischarge | 18,5 Wh ÷ 77 Wh | 0.24 |
totalMass | 0,45 kg + 0,62 kg + 0,28 kg | 1,35 kg |
Die Spitzenleistung selbst hat eine nachprüfbare Quelle: 0,2 m² Zellen mit 0,295 Wirkungsgrad unter 1361 W/m² Sonnenlicht, bei einem Einfallswinkel von 0,35 rad (cos 0,35 = 0,939), ergeben 75,4 W. Der besonnte Anteil folgt aus der Umlaufbahn: Ein Orbit in 500 km Höhe dauert etwa 94,6 Minuten, davon 36 im Schatten, was 0,62 des Orbits im Sonnenlicht lässt.
Weil jeder Wert eine Einheit trägt, zeigt sich ein Dimensionsfehler, sobald das Modell geprüft wird. Ein häufiger in Leistungsmodellen ist, die Kapazität einer Batterie in Watt statt in Wattstunden zu schreiben:
package UnitCheck {
private import ISQ::*;
private import SI::*;
part def BatteryPack {
attribute capacity : EnergyValue;
}
part battery : BatteryPack {
attribute redefines capacity = 77 [W];
}
}
Ein Prüfer, der Einheiten auswertet, weist den Wert zurück: Eine Leistung ist keine Energie. In Holarch markiert der Editor die Zeile mit einem Dimensionsfehler. In einer Tabellenkalkulation würde derselbe Fehler unbemerkt in die Entladetiefe wandern.
Schritt 4: Ports, Interfaces und Verbindungen
Ports sind die Punkte, an denen ein Part auf seine Umgebung trifft. Eine Port-Definition listet, was die Grenze überquert, jedes Feature mit einer Richtung: out für das, was der Besitzer sendet, in für das, was er empfängt.
port def DCPowerPort {
out attribute voltage : ElectricPotentialValue;
out attribute current : ElectricCurrentValue;
}
port def BusPowerPort {
out attribute voltage : ElectricPotentialValue;
out attribute powerLimit : PowerValue;
}
interface def BusLink {
end source : BusPowerPort;
end load : ~BusPowerPort;
}
Die empfangende Seite verwendet dieselbe Port-Definition, mit ~ konjugiert. ~BusPowerPort ist das Spiegelbild von BusPowerPort: Jedes out wird zu in. Eine Port-Definition beschreibt beide Enden einer Verbindung, sodass die beiden Enden nicht auseinanderlaufen können.
Eine Interface-Definition beschreibt eine Art von Verbindung mit typisierten Enden. BusLink verbindet den 12-V-Bus, der Leistung sendet, mit einem Verbraucher, der sie empfängt. Er übernimmt die Rolle von EO-1s 12 V Power Interface (IFB-1).
Fügen Sie nun die Ports zu den Parts hinzu und verbinden Sie sie. Die Kommentarzeilen stehen für die Zeilen aus den früheren Schritten.
part def SolarArray {
// attributes as in step 2
port arrayOut : DCPowerPort;
}
part def BatteryPack {
// attributes as in step 2
port cellsOut : DCPowerPort;
}
part def PowerDistributionUnit {
// attributes as in step 2
port arrayIn : ~DCPowerPort;
port batteryIn : ~DCPowerPort;
port busOut : BusPowerPort;
}
part def PayloadCamera {
// attributes as in step 2
port powerIn : ~BusPowerPort;
}
part def SBandTransmitter {
// attributes as in step 2
port powerIn : ~BusPowerPort;
}
part def ElectricalPowerSystem {
// parts as in step 3
port bus : BusPowerPort;
connect solarArrays.arrayOut to pdu.arrayIn;
connect battery.cellsOut to pdu.batteryIn;
bind bus = pdu.busOut;
// computed attributes as in step 3
}
part def Spacecraft {
// parts as in step 3
interface payloadPower : BusLink connect eps.bus to camera.powerIn;
interface radioPower : BusLink connect eps.bus to transmitter.powerIn;
}
connect solarArrays.arrayOut to pdu.arrayInist eine einfache Verbindung: der Array-Kabelbaum (EO-1-Schnittstelle IF-20).battery.cellsOutzupdu.batteryInist der Batteriekabelbaum (IF-21).bind bus = pdu.busOutsagt, dass der eigene Portbusdes Energiesystems und der Ausgang der PDU dasselbe sind. So legt ein Part einen inneren Port an seiner Grenze offen: Die Verbraucher verbinden sich mit dem EPS, nicht mit seinem Inneren.interface payloadPower : BusLink connect … to …verbindet zwei Ports über ein typisiertes Interface, sodass die Verbindung die Bedeutung vonBusLinkträgt. Die beiden Bus-Interfaces sind EO-1s Payload Power Line (IF-01) und Radio Power Line (IF-04).
Eine Interconnection View zeichnet das Energiesystem aus diesem Text: jedes Part mit seinen Ports am Rand, die konjugierten Ports mit ~ markiert und der gebundene Port bus am Rahmen.
epsConnections aus Schritt 9: die EPS-Parts, ihre Ports und Verbindungen, aus dem Text gezeichnet.Die technische Folge: Die Schnittstellenliste des Subsystems ist jetzt eine Abfrage, keine eigene Tabelle. Jede Verbindung nennt beide Enden und, wenn sie typisiert ist, was sie überquert. Das ist das Rohmaterial eines Schnittstellensteuerungsdokuments, und es ändert sich, wenn sich das Modell ändert.
Ein häufiger Fehler ist, beiden Enden denselben, nicht konjugierten Port zu geben. Dann senden beide Enden, und keines empfängt:
package PortCheck {
private import ISQ::*;
port def BusPowerPort {
out attribute voltage : ElectricPotentialValue;
}
part def PowerDistributionUnit { port busOut : BusPowerPort; }
part def PayloadCamera { port powerIn : BusPowerPort; }
part def Spacecraft {
part pdu : PowerDistributionUnit;
part camera : PayloadCamera;
connect pdu.busOut to camera.powerIn;
}
}
Der Text lässt sich parsen, aber ein Prüfer, der Richtungen vergleicht, warnt, dass beide Enden der Verbindung voltage senden. Das empfangende Ende zu konjugieren, port powerIn : ~BusPowerPort;, behebt es.
Schritt 5: Verhalten mit Aktionen und Flows
Die Struktur sagt, was das System ist; das Verhalten sagt, was es tut. Eine Action-Definition beschreibt ein Verhalten mit Eingangs- und Ausgangsparametern. Item-Definitionen beschreiben die Dinge, die fließen, hier Sonnenlicht und elektrische Leistung in ihren verschiedenen Formen.
item def Sunlight;
item def ArrayPower;
item def ChargePower;
item def DischargePower;
item def BusPower;
action def ConvertSunlight {
in item sun : Sunlight;
out item power : ArrayPower;
}
action def ChargeBattery {
in item power : ArrayPower;
out item charge : ChargePower;
}
action def StoreEnergy {
in item charge : ChargePower;
out item discharge : DischargePower;
}
action def SupplyBus {
in item discharge : DischargePower;
out item bus : BusPower;
}
action def RunPowerCycle {
doc /* One orbit: about 59 minutes of sunlight, then a 36 minute eclipse. */
action collect : ConvertSunlight;
action charge : ChargeBattery;
action store : StoreEnergy;
action supply : SupplyBus;
flow collect.power to charge.power;
flow charge.charge to store.charge;
flow store.discharge to supply.discharge;
first start then collect;
first collect then charge;
first charge then store;
first store then supply;
first supply then done;
}
in- undout-Parameter sind die Eingaben und Ausgaben einer Aktion.- In
RunPowerCyclesind vier Action Usages die Schritte eines Umlaufs: Im Sonnenlicht sammeln die Arrays Leistung und die PDU lädt die Batterie; im Schatten gibt die Batterie die Energie zurück, und die PDU versorgt daraus den Bus. flow collect.power to charge.powersagt, dass die Ausgabe eines Schritts die Eingabe des nächsten ist.first collect then chargeist eine Succession: Ein Schritt endet, bevor der nächste beginnt. Flows sagen, was sich bewegt; Successions sagen, in welcher Reihenfolge.startunddonesind Anfang und Ende der umschließenden Aktion.
Die Schritte entsprechen den Leistungsfunktionen von EO-1: F3.1 Convert Sunlight to Power, F3.2 Store Battery Energy und F3.3 Regulate Bus Power. Solche Funktionen aus Anforderungen abzuleiten und zu ordnen ist Gegenstand der Funktionsanalyse; die Action-Definitionen sind der Ort, an dem diese Arbeit in SysML v2 landet.
Die folgende Action Flow View ist aus diesem Text zusammen mit der Zuordnung aus Schritt 6 gezeichnet, die jedem Schritt eine Swimlane gibt.
powerCycleFlow: die Schritte im Sonnenlicht, dann die Schritte im Schatten, mit der Leistung, die zwischen ihnen fließt.Die technische Folge: Die Batterie liegt auf dem Weg jedes Watts, das der Bus im Schatten verbraucht. Was die Batterie im Sonnenlicht speichert, muss die Last im Schatten decken, und genau das begrenzen die Anforderungen 3.2 und 3.3 in Schritt 7.
Schritt 6: Verhalten der Struktur zuordnen
Bisher gehört das Verhalten zu keiner Komponente. Eine perform-Anweisung sagt, welches Part welchen Schritt ausführt:
part eo1 : Spacecraft {
part redefines eps {
perform action powerCycle : RunPowerCycle;
part redefines solarArrays { perform powerCycle.collect; }
part redefines battery { perform powerCycle.store; }
part redefines pdu {
perform powerCycle.charge;
perform powerCycle.supply;
}
}
}
eo1 ist eine Usage von Spacecraft auf oberster Ebene des Pakets: das Raumfahrzeug dieses Entwurfs. Sein Energiesystem führt RunPowerCycle aus, und jedes EPS-Part führt seine Schritte aus. part redefines eps verfeinert das von Spacecraft geerbte Energiesystem, statt ein zweites hinzuzufügen. Die PDU führt zwei Schritte aus, das Laden im Sonnenlicht und die Versorgung des Busses im Schatten, weil eine Einheit beide Aufgaben übernimmt.
Das ist die textuelle Form einer funktionalen Zuordnung. Daraus kann ein Werkzeug die Funktionen auflisten, die jede Komponente ausführt, oder den Action Flow mit einer Swimlane pro Part zeichnen, wie in der obigen Ansicht.
Schritt 7: Anforderungen mit Constraints
Anforderungen kommen in ein eigenes Paket, das den Entwurf importiert. In SysML v2 ist eine Anforderung ein Constraint auf einem Subjekt: Der doc-Text sagt in Worten, was gebraucht wird, und ein require constraint sagt dasselbe in einer Form, die ein Werkzeug auswerten kann. Die drei Anforderungen sind die EO-1-Anforderungen 3.1, 3.2 und 3.3, mit ihren eigenen IDs und ihrem Wortlaut.
package CubeSatEPSRequirements {
doc /* Electrical power requirements of EO-1 (section 3) and how one of them is verified. */
private import CubeSatEPS::*;
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
requirement def <'3.1'> OrbitAveragePower {
doc /* The solar arrays shall generate at least 28 W orbit-average power at end of life. */
subject eps : ElectricalPowerSystem;
attribute required : PowerValue;
require constraint { eps.orbitAveragePower >= required }
}
requirement def <'3.2'> BatteryCapacity {
doc /* The battery shall store at least 77 Wh at beginning of life. */
subject eps : ElectricalPowerSystem;
attribute minimum : EnergyValue;
require constraint { eps.battery.capacity >= minimum }
}
requirement def <'3.3'> DepthOfDischarge {
doc /* The EPS shall limit battery depth of discharge to 30% per orbit. */
subject eps : ElectricalPowerSystem;
attribute limit : Real;
require constraint { eps.depthOfDischarge <= limit }
}
requirement powerSpec {
doc /* The electrical power requirements EO-1 is built to. */
subject eps : ElectricalPowerSystem;
requirement orbitAveragePower : OrbitAveragePower {
attribute redefines required = 28 [W];
}
requirement batteryCapacity : BatteryCapacity {
attribute redefines minimum = 77 [W*h];
}
requirement depthOfDischarge : DepthOfDischarge {
attribute redefines limit = 0.3;
}
}
satisfy powerSpec by eo1.eps;
}
<'3.1'>ist ein Kurzname: die Kennung, die Ingenieure in Reviews zitieren. Andere Modellelemente verweisen auf den vollen Namen,OrbitAveragePower.subject eps : ElectricalPowerSystemnennt, worum es in der Anforderung geht.require constraint { eps.orbitAveragePower >= required }ist die Bedingung, die gelten muss. Der Grenzwert ist ein Parameter, sodass dieselbe Definition einem Raumfahrzeug mit anderem Leistungsbedarf dient.powerSpecsammelt die Anforderungen für EO-1 und setzt die Grenzwerte: 28 W, 77 Wh und 0,3.satisfy powerSpec by eo1.epsbehauptet, dass das Energiesystem von EO-1 die Spezifikation erfüllt.
Halten Sie doc-Text und Constraint inhaltsgleich. Prüfende lesen den Text; Werkzeuge werten den Constraint aus. Die Links von der Anforderung zu Entwurf und Test sind das, worauf die Anforderungsnachverfolgbarkeit aufbaut.
Eine Requirement View zeigt die Spezifikation als Baum, mit dem erfüllenden Part und dem Verification Case aus Schritt 8:
requirementTree: die Anforderungen 3.1 bis 3.3, was sie erfüllt und was sie verifiziert.Weil sich die Constraints auswerten lassen, tut ein Prüfer mehr, als die satisfy-Linie zu zeichnen: Er testet die Behauptung gegen die Werte aus Schritt 3. Mit dem Modell wie geschrieben gelten alle drei: 28,05 W gegenüber 28 W, 77 Wh gegenüber 77 Wh und eine Entladetiefe von 0,24 gegenüber 0,3.
Die erste dieser Margen ist knapp. Senken Sie den Wirkungsgrad des Leistungspfads von 0,6 auf 0,59, eine Änderung von weniger als zwei Prozent, und die orbitgemittelte Leistung fällt auf 27,58 W. Der Prüfer meldet dann, dass Anforderung 3.1 nicht mehr erfüllt ist, mit den Werten, die sie verletzt haben:
Die technische Folge: Anforderung 3.1 trägt bereits die Systemmarge (ihre Begründung in EO-1 ist eine Last im Aufnahmemodus von 24 W plus 15 %), aber die Arrays erfüllen 3.1 selbst mit nur 0,05 W Reserve. Jeder Verlust, der nicht in der Schätzung enthalten war, etwa eine schnellere Zelldegradation, erfordert entweder mehr Array-Fläche oder eine kleinere Last. Ein Modell, das die Anforderung bei jeder Änderung prüft, zeigt das, wenn sich die Zahl bewegt, nicht erst beim nächsten Review. Wie wahrscheinlich die Marge hält, wenn die Eingaben unsicher statt fest sind, zeigt Monte-Carlo-Analyse im Systems Engineering.
Schritt 8: ein Verification Case
Eine satisfy-Beziehung ist eine Behauptung, und die Prüfung in Schritt 7 testet sie nur gegen die eigenen Zahlen des Modells. Ein Verification Case sagt, wie die Behauptung an der realen Hardware geprüft wird, per Test, Inspektion, Analyse oder Demonstration. EO-1 verifiziert seine Batteriekapazität mit dem Testfall TC-07.
verification def <'TC-07'> BatteryCapacityTest {
doc /* Discharge the pack at C/2 from full charge in a thermal chamber at 20 degrees C and measure the energy delivered. */
subject eps : ElectricalPowerSystem;
objective {
verify powerSpec.batteryCapacity;
}
return verdict : Boolean = eps.battery.capacity >= powerSpec.batteryCapacity.minimum;
}
verification batteryTest : BatteryCapacityTest {
subject eps = eo1.eps;
}
objective { verify powerSpec.batteryCapacity; }nennt die Anforderung, die dieser Case verifiziert. Aus diesen Links wird eine Verifikationsmatrix erstellt: jede Anforderung gegen die Cases, die sie verifizieren.return verdictist das Ergebnis: hier, ob die gemessene Kapazität die 77 Wh von Anforderung 3.2 erreicht.batteryTestist eine Usage des Case für das Energiesystem von EO-1: der geplante Test, mit seinem Subjekt aneo1.epsgebunden.
Erfüllung und Verifikation werden bewusst getrennt gehalten. Die Erfüllung sagt, welches Entwurfselement eine Anforderung beantwortet; die Verifikation sagt, woher Sie wissen, dass es das tut. Im EO-1-Projekt hat TC-07 mit gemessenen 78,3 Wh bestanden. Die Anforderungen 3.1 und 3.3 brauchen noch eigene Cases, und eine Anforderungs-Verifikationsmatrix ist der Ort, an dem diese Lücke sichtbar wird.
Schritt 9: Ansichten und Diagramme
In SysML v2 ist ein Diagramm keine separate Zeichnung. Eine Ansicht ist ein Element des Modells, das angibt, was gezeigt wird (expose) und welche Elementarten enthalten sind (filter). Ein Werkzeug stellt die Ansicht dar und behält ihr Layout; der Inhalt kommt immer aus dem Modell. Die drei obigen Screenshots sind diese drei Ansichten.
package CubeSatEPSViews {
doc /* Views of the EO-1 power system. Each view selects part of the model; the layout belongs to the tool. */
private import CubeSatEPS::*;
private import CubeSatEPSRequirements::*;
private import StandardViewDefinitions::*;
// The EPS parts, their ports and connections.
view epsConnections : InterconnectionView {
expose CubeSatEPS::ElectricalPowerSystem;
}
// One orbit: the sunlit steps, the eclipse steps and the power that flows between them.
view powerCycleFlow : ActionFlowView {
expose CubeSatEPS::RunPowerCycle;
}
// The requirements with what satisfies and verifies them.
view requirementTree : GeneralView {
filter @SysML::RequirementDefinition or @SysML::RequirementUsage or @SysML::SatisfyRequirementUsage;
expose CubeSatEPSRequirements::**;
}
}
Die Standardbibliothek definiert die gängigen Ansichtsarten:
| Ansicht | Zeigt | In diesem Modell |
|---|---|---|
| General View | Beliebige Elemente und ihre Beziehungen, als Kästen und Linien | requirementTree |
| Interconnection View | Die Parts einer Baugruppe mit ihren Ports und Verbindungen | epsConnections |
| Action Flow View | Die Schritte eines Verhaltens, ihre Reihenfolge und was zwischen ihnen fließt | powerCycleFlow |
| State Transition View | Zustände und die Transitionen zwischen ihnen | Keine |
| Sequence View | Nachrichten zwischen Parts über die Zeit | Keine |
| Grid View | Elemente oder Beziehungen als Tabelle oder Matrix | Keine |
requirementTree ist eine General View, deren Filter nur Anforderungen und satisfy-Beziehungen behält; Werkzeuge, die die Diagrammarten von SysML v1 kennen, darunter Holarch, zeigen eine solche Ansicht als Requirement Diagram. Weil eine Ansicht Teil des Modells ist, ändert das Umbenennen der Batterie jedes Diagramm, das sie zeigt, und ein Prüfender kann im Text genau lesen, was ein Diagramm enthält.
Das vollständige Modell
Die drei Pakete zusammen. Das Modell des EO-1-Energiesystems herunterladen (cubesat-eps.sysml) oder den Text unten kopieren; beide sind identisch.
package CubeSatEPS {
doc /* The electrical power system (EPS) of the EO-1 CubeSat: solar arrays, a battery pack and a power distribution unit that feed the payload camera and the S-band transmitter. */
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
// ---- Ports and interfaces ----
port def DCPowerPort {
out attribute voltage : ElectricPotentialValue;
out attribute current : ElectricCurrentValue;
}
port def BusPowerPort {
out attribute voltage : ElectricPotentialValue;
out attribute powerLimit : PowerValue;
}
interface def BusLink {
end source : BusPowerPort;
end load : ~BusPowerPort;
}
// ---- Components ----
part def SolarArray {
attribute mass : MassValue;
attribute cellArea : AreaValue;
attribute cellEfficiency : Real;
attribute peakPower : PowerValue;
attribute pathEfficiency : Real;
port arrayOut : DCPowerPort;
}
part def BatteryPack {
attribute mass : MassValue;
attribute capacity : EnergyValue;
port cellsOut : DCPowerPort;
}
part def PowerDistributionUnit {
attribute mass : MassValue;
attribute busVoltage : ElectricPotentialValue;
port arrayIn : ~DCPowerPort;
port batteryIn : ~DCPowerPort;
port busOut : BusPowerPort;
}
part def PayloadCamera {
attribute powerDraw : PowerValue;
port powerIn : ~BusPowerPort;
}
part def SBandTransmitter {
attribute powerDraw : PowerValue;
port powerIn : ~BusPowerPort;
}
// ---- Calculations ----
calc def OrbitAverage {
doc /* Orbit-average array output (EQ-1.3): peak power times the sunlit fraction times the power path efficiency. */
in peakPower : PowerValue;
in sunlitFraction : Real;
in pathEfficiency : Real;
return : PowerValue = peakPower * sunlitFraction * pathEfficiency;
}
// ---- The assembly ----
part def ElectricalPowerSystem {
part solarArrays : SolarArray {
attribute redefines mass = 0.45 [kg];
attribute redefines cellArea = 0.2 [m^2];
attribute redefines cellEfficiency = 0.295;
attribute redefines peakPower = 75.4 [W];
attribute redefines pathEfficiency = 0.6;
}
part battery : BatteryPack {
attribute redefines mass = 0.62 [kg];
attribute redefines capacity = 77 [W*h];
}
part pdu : PowerDistributionUnit {
attribute redefines mass = 0.28 [kg];
attribute redefines busVoltage = 12 [V];
}
port bus : BusPowerPort;
connect solarArrays.arrayOut to pdu.arrayIn;
connect battery.cellsOut to pdu.batteryIn;
bind bus = pdu.busOut;
attribute sunlitFraction : Real = 0.62;
attribute eclipseEnergy : EnergyValue = 18.5 [W*h];
attribute orbitAveragePower : PowerValue = OrbitAverage(solarArrays.peakPower, sunlitFraction, solarArrays.pathEfficiency);
attribute depthOfDischarge : Real = eclipseEnergy / battery.capacity;
attribute totalMass : MassValue = solarArrays.mass + battery.mass + pdu.mass;
}
part def Spacecraft {
part eps : ElectricalPowerSystem;
part camera : PayloadCamera {
attribute redefines powerDraw = 6.2 [W];
}
part transmitter : SBandTransmitter {
attribute redefines powerDraw = 3.4 [W];
}
interface payloadPower : BusLink connect eps.bus to camera.powerIn;
interface radioPower : BusLink connect eps.bus to transmitter.powerIn;
}
// ---- Behavior ----
item def Sunlight;
item def ArrayPower;
item def ChargePower;
item def DischargePower;
item def BusPower;
action def ConvertSunlight {
in item sun : Sunlight;
out item power : ArrayPower;
}
action def ChargeBattery {
in item power : ArrayPower;
out item charge : ChargePower;
}
action def StoreEnergy {
in item charge : ChargePower;
out item discharge : DischargePower;
}
action def SupplyBus {
in item discharge : DischargePower;
out item bus : BusPower;
}
action def RunPowerCycle {
doc /* One orbit: about 59 minutes of sunlight, then a 36 minute eclipse. */
action collect : ConvertSunlight;
action charge : ChargeBattery;
action store : StoreEnergy;
action supply : SupplyBus;
flow collect.power to charge.power;
flow charge.charge to store.charge;
flow store.discharge to supply.discharge;
first start then collect;
first collect then charge;
first charge then store;
first store then supply;
first supply then done;
}
part eo1 : Spacecraft {
part redefines eps {
perform action powerCycle : RunPowerCycle;
part redefines solarArrays { perform powerCycle.collect; }
part redefines battery { perform powerCycle.store; }
part redefines pdu {
perform powerCycle.charge;
perform powerCycle.supply;
}
}
}
}
package CubeSatEPSRequirements {
doc /* Electrical power requirements of EO-1 (section 3) and how one of them is verified. */
private import CubeSatEPS::*;
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
requirement def <'3.1'> OrbitAveragePower {
doc /* The solar arrays shall generate at least 28 W orbit-average power at end of life. */
subject eps : ElectricalPowerSystem;
attribute required : PowerValue;
require constraint { eps.orbitAveragePower >= required }
}
requirement def <'3.2'> BatteryCapacity {
doc /* The battery shall store at least 77 Wh at beginning of life. */
subject eps : ElectricalPowerSystem;
attribute minimum : EnergyValue;
require constraint { eps.battery.capacity >= minimum }
}
requirement def <'3.3'> DepthOfDischarge {
doc /* The EPS shall limit battery depth of discharge to 30% per orbit. */
subject eps : ElectricalPowerSystem;
attribute limit : Real;
require constraint { eps.depthOfDischarge <= limit }
}
requirement powerSpec {
doc /* The electrical power requirements EO-1 is built to. */
subject eps : ElectricalPowerSystem;
requirement orbitAveragePower : OrbitAveragePower {
attribute redefines required = 28 [W];
}
requirement batteryCapacity : BatteryCapacity {
attribute redefines minimum = 77 [W*h];
}
requirement depthOfDischarge : DepthOfDischarge {
attribute redefines limit = 0.3;
}
}
satisfy powerSpec by eo1.eps;
verification def <'TC-07'> BatteryCapacityTest {
doc /* Discharge the pack at C/2 from full charge in a thermal chamber at 20 degrees C and measure the energy delivered. */
subject eps : ElectricalPowerSystem;
objective {
verify powerSpec.batteryCapacity;
}
return verdict : Boolean = eps.battery.capacity >= powerSpec.batteryCapacity.minimum;
}
verification batteryTest : BatteryCapacityTest {
subject eps = eo1.eps;
}
}
package CubeSatEPSViews {
doc /* Views of the EO-1 power system. Each view selects part of the model; the layout belongs to the tool. */
private import CubeSatEPS::*;
private import CubeSatEPSRequirements::*;
private import StandardViewDefinitions::*;
// The EPS parts, their ports and connections.
view epsConnections : InterconnectionView {
expose CubeSatEPS::ElectricalPowerSystem;
}
// One orbit: the sunlit steps, the eclipse steps and the power that flows between them.
view powerCycleFlow : ActionFlowView {
expose CubeSatEPS::RunPowerCycle;
}
// The requirements with what satisfies and verifies them.
view requirementTree : GeneralView {
filter @SysML::RequirementDefinition or @SysML::RequirementUsage or @SysML::SatisfyRequirementUsage;
expose CubeSatEPSRequirements::**;
}
}
Wie die Auflistungen geprüft wurden
Jede Auflistung auf dieser Seite wurde mit der Holarch Language Engine geparst und geprüft, der Engine hinter dem SysML-v2-Editor von Holarch, mit geladener SysML-v2-Standardbibliothek. Die Prüfungen lösen jeden Namen auf, vergleichen Einheiten und Dimensionen, vergleichen Port-Richtungen über Verbindungen hinweg und werten Anforderungs-Constraints gegen die Werte aus, die sie erfüllen.
- Das vollständige Modell und die eigenständige Auflistung ergeben keine Fehler und keine Warnungen.
- Jeder Auszug erscheint Zeile für Zeile und in derselben Reihenfolge im vollständigen Modell.
- Die beiden Auflistungen, die Fehler zeigen, ergeben genau den Fehler und die Warnung, die daneben beschrieben sind.
- Das vollständige Modell mit einem Wirkungsgrad des Leistungspfads von 0,59 ergibt genau eine Warnung: Anforderung 3.1 nicht erfüllt.
Welche SysML-v2-Konstrukte die Engine unterstützt und welche Lücken bekannt sind, zeigt die Sprachabdeckung von SysML v2. Um Werkzeuge in denselben Punkten zu vergleichen, siehe was bei einem SysML-v2-Werkzeug zu prüfen ist; dieses Modell ist klein genug, um als Testdatei zu dienen.
In Holarch ausprobieren
- Laden Sie
cubesat-eps.sysmlherunter oder speichern Sie das vollständige Modell unter diesem Namen. - Öffnen Sie Modell → Import und Export, wählen Sie In ein neues SysML-v2-Projekt und ziehen Sie die Datei hinein. Siehe Dateien in ein neues Projekt importieren.
- Öffnen Sie Modell → Editor, um den Text zu lesen und zu ändern. Jedes Paket ist ein Dokument. Siehe den Editor.
- Öffnen Sie die Liste Diagramme und klicken Sie auf
epsConnections,powerCycleFlowoderrequirementTree. Siehe eine Ansicht öffnen. - Ändern Sie in CubeSatEPS
pathEfficiency = 0.6in0.59und warten Sie kurz. Der Editor zeigt die Warnung an dersatisfy-Zeile in CubeSatEPSRequirements. Machen Sie es mit ⌘Z / Strg+Z rückgängig.
Um das Modell stattdessen abzutippen, legen Sie ein SysML-v2-Projekt an, klicken im Editor auf + Neues Package und schreiben die Schritte der Reihe nach; Text, der sich parsen lässt, wird nach einer kurzen Pause übernommen. Siehe Erste Schritte mit SysML-v2-Projekten. Das ganze Raumfahrzeug EO-1 mit seinen Dokumenten, Tests und Budgets ist die CubeSat-Demo: Projektdateien ▾ → Neues Demoprojekt.
Wie es weitergeht
- SysML-v2-Projekte in Holarch: Text, Ansichten und Engineering-Seiten auf einem Modell.
- Referenz zur textuellen Notation: was Holarch unterstützt, die Prüfungen und die Standardbibliothek.
- Referenz zu Ansichten: jede Ansichtsart und wie man darin das Modell bearbeitet.
- Anforderungen und Verifikation in SysML-v2-Projekten: Anforderungsseiten, das Test Center und die RVTM.
- Analyse in SysML-v2-Projekten: Parametrik, Budgets und Trade-Studien.
- Was ist MBSE?: warum Ingenieure das System in einem Modell halten.