Przewodnik · SysML v2
Samouczek SysML v2: model systemu zasilania CubeSata w notacji tekstowej
Posłuchaj tego przewodnika 24 min
Ten samouczek SysML v2 buduje krok po kroku mały, kompletny model: system zasilania elektrycznego CubeSata EO-1, z jego częściami, wielkościami i jednostkami, portami i połączeniami, cyklem oświetlenia i zaćmienia, wymaganiami, które narzędzie może sprawdzić, przypadkiem weryfikacji i widokami. Każdy listing na tej stronie to tekst SysML v2 sprawdzony silnikiem języka, a każdy kluczowy krok pokazuje diagram, który powstaje z tekstu.
Na tej stronie
- Co zbudujesz
- Pierwsza idea: definicje i użycia
- Krok 1: pakiet i jego importy
- Krok 2: definicje części i atrybuty z jednostkami
- Krok 3: zespół z wartościami
- Krok 4: porty, interfejsy i połączenia
- Krok 5: zachowanie z akcjami i przepływami
- Krok 6: alokacja zachowania do struktury
- Krok 7: wymagania z ograniczeniami
- Krok 8: przypadek weryfikacji
- Krok 9: widoki i diagramy
- Kompletny model
- Jak sprawdzono listingi
- Wypróbuj w Holarch
- Co dalej
Co zbudujesz
EO-1 to CubeSat 6U do obserwacji Ziemi na orbicie heliosynchronicznej 500 km. Jest wspólnym przykładem tych przewodników; przykładowy projekt MBSE prowadzi cały statek kosmiczny od potrzeb do weryfikacji. Ten samouczek bierze jeden podsystem, system zasilania elektrycznego (EPS), i zapisuje go w tekście SysML v2.
EPS ma trzy części. Dwa rozkładane panele słoneczne zamieniają światło słoneczne na moc. Pakiet akumulatorów litowo-jonowych magazynuje energię na czas zaćmienia. Jednostka dystrybucji mocy (PDU) śledzi punkt mocy szczytowej paneli, ładuje akumulator i stabilizuje szynę 12 V. W modelu są też dwa odbiorniki na tej szynie: kamera ładunku użytecznego i nadajnik pasma S.
Liczby pochodzą z modelu EO-1:
| Element | Wartość | Gdzie jest używana |
|---|---|---|
| Panele słoneczne: powierzchnia ogniw, sprawność ogniw, moc szczytowa | 0,2 m², 0,295, 75,4 W | Krok 3 |
| Sprawność toru mocy; oświetlona część orbity | 0.6; 0.62 | Krok 3 |
| Pakiet akumulatorów: pojemność; energia pobrana podczas 36-minutowego zaćmienia | 77 Wh; 18,5 Wh | Krok 3 |
| Masa: panele, akumulator, PDU | 0,45 kg, 0,62 kg, 0,28 kg | Krok 3 |
| Średni pobór mocy na orbicie: kamera, nadajnik pasma S | 6,2 W, 3,4 W | Krok 3 |
| Wymaganie 3.1 Orbit Average Power | co najmniej 28 W na koniec życia | Krok 7 |
| Wymaganie 3.2 Battery Capacity | co najmniej 77 Wh na początku życia | Kroki 7 i 8 |
| Wymaganie 3.3 Depth of Discharge | najwyżej 30% na orbitę | Krok 7 |
| Przypadek testowy TC-07 Battery Capacity Test | rozładowanie prądem C/2 w komorze o temperaturze 20 °C | Krok 8 |
Model ma trzy pakiety:
| Pakiet | Zawiera | Kroki |
|---|---|---|
CubeSatEPS | Porty, części, obliczenie, zespoły z ich wartościami oraz zachowanie | 1 do 6 |
CubeSatEPSRequirements | Wymagania 3.1 do 3.3 i przypadek weryfikacji TC-07 | 7 i 8 |
CubeSatEPSViews | Widoki, które wybierają części modelu do diagramów | 9 |
Do śledzenia samouczka nie jest potrzebne żadne konkretne narzędzie: tekst to zwykły SysML v2 i ładuje się w każdym narzędziu, które czyta notację tekstową. Kompletny model jest na końcu strony i do pobrania, a ostatnia sekcja pokazuje, jak załadować go do Holarch.
Pierwsza idea: definicje i użycia
SysML v2 oddziela definicję od użycia. Definicja mówi, czym jest dany rodzaj rzeczy: part def BatteryPack opisuje każdy pakiet akumulatorów tego projektu, z jego atrybutami i portami. Użycie to taka rzecz w kontekście: part battery : BatteryPack wewnątrz systemu zasilania to jedyny akumulator EPS satelity EO-1, połączony z jego PDU.
To samo parowanie przebiega przez cały język: attribute def i attribute, port def i port, action def i action, requirement def i requirement. Słowo kluczowe z def deklaruje rodzaj; to samo słowo kluczowe bez def go używa. Konkretne wartości zwykle należą do użyć, bo to w użyciu zapada decyzja projektowa.
Czytelnicy znający SysML v1 mogą porównać definicję z blokiem, a użycie z właściwością części. W SysML v2 ta idea dotyczy każdego rodzaju elementu, a użycia zagnieżdżają się i uszczegóławiają nawzajem na dowolną głębokość. SysML v1 a SysML v2 porównuje oba języki konstrukcja po konstrukcji.
Krok 1: pakiet i jego importy
Pakiet to przestrzeń nazw: grupuje elementy i nadaje im nazwy kwalifikowane, takie jak CubeSatEPS::BatteryPack. Zacznij od pustego pakietu i potrzebnych mu importów z biblioteki.
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 /* … */dołącza dokumentację do pakietu. W przeciwieństwie do komentarza//jest częścią modelu, a narzędzia pokazują ją razem z elementem.ScalarValuesdostarcza typy podstawowe, takie jakReal,Integer,BooleaniString.ISQdostarcza typy wielkości z Międzynarodowego Układu Wielkości, takie jakMassValue,PowerValueiEnergyValue.SIdostarcza jednostki SI, takie jakkg,V,Wih.privatezatrzymuje zaimportowane nazwy wewnątrz tego pakietu, więc pakiet importującyCubeSatEPSnie otrzymuje ich za jego pośrednictwem.
Bez importów nazwy takiej jak MassValue nie da się rozwiązać, a mechanizm sprawdzający zgłasza ją jako nieznaną.
Krok 2: definicje części i atrybuty z jednostkami
Każdy komponent dostaje definicję części z typowanymi atrybutami. Typowanie atrybutu wielkością, a nie typem Real, zapisuje, co on mierzy: masę, moc, energię. Narzędzie może wtedy sprawdzić spójność wymiarów każdej wartości i każdego wyrażenia.
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;
}
Te wiersze trafiają do nawiasów klamrowych pakietu. Obie sprawności pozostają zwykłym typem Real, bo są stosunkami bez jednostki.
Wartości jeszcze nie ma. Definicja opisuje każdy pakiet akumulatorów tego rodzaju; liczby pojawią się w następnym kroku wraz z akumulatorem samego EO-1.
Krok 3: zespół z wartościami
System zasilania też jest definicją części, złożoną z użyć części: paneli słonecznych, akumulatora i PDU. Każde użycie nadaje wartości atrybutom, które dziedziczy po swojej definicji. Obliczenie wielokrotnego użytku zamienia moc szczytową paneli na średnią moc na orbicie, której dotyczy wymaganie 3.1.
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 : BatteryPackdeklaruje użycie o nazwiebattery, typowane definicjąBatteryPack.attribute redefines capacity = 77 [W*h]nadaje wartość odziedziczonemu atrybutowicapacity. Forma skrócona:>> capacity = 77 [W*h];znaczy to samo. Bezredefineswiersz zadeklarowałby drugi atrybut, który tylko dzieli nazwę, a odziedziczonycapacitynadal nie miałby wartości.77 [W*h]to wielkość: liczba i jednostka. Jednostki łączy się za pomocą*,/i^, więc watogodziny toW*h, a metry kwadratowem^2.calc def OrbitAverageto obliczenie z wejściami i typowanym wynikiem.OrbitAverage(…)wywołuje je z wartościami paneli, więc wzór jest zapisany raz, a każde jego użycie podąża za zmianą.depthOfDischargedzieli energię przez energię. Jednostki się skracają, a wynik jest zwykłym stosunkiem.Spacecraftumieszcza system zasilania obok dwóch odbiorników, którymi zajmuje się ten samouczek. Reszta EO-1 (sterowanie orientacją, komputer pokładowy, struktura) została pominięta, aby model był krótki.
Wartości nie są tylko przechowywane; narzędzie je oblicza. Z powyższymi liczbami:
| Atrybut | Wyrażenie | Wynik |
|---|---|---|
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 |
Sama moc szczytowa ma źródło, które można sprawdzić: 0,2 m² ogniw o sprawności 0,295 w świetle słonecznym 1361 W/m², pod kątem padania 0,35 rad (cos 0,35 = 0,939), daje 75,4 W. Oświetlona część wynika z orbity: orbita 500 km trwa około 94,6 minuty, z czego 36 minut w zaćmieniu, co pozostawia 0,62 orbity w świetle słonecznym.
Ponieważ każda wartość ma jednostkę, błąd wymiaru ujawnia się, gdy tylko model zostanie sprawdzony. Częstym błędem w modelach zasilania jest zapisanie pojemności akumulatora w watach zamiast w watogodzinach:
package UnitCheck {
private import ISQ::*;
private import SI::*;
part def BatteryPack {
attribute capacity : EnergyValue;
}
part battery : BatteryPack {
attribute redefines capacity = 77 [W];
}
}
Mechanizm sprawdzający, który oblicza jednostki, odrzuca tę wartość: moc nie jest energią. W Holarch Edytor oznacza wiersz błędem wymiaru. W arkuszu kalkulacyjnym ta sama pomyłka przeszłaby niezauważona do głębokości rozładowania.
Krok 4: porty, interfejsy i połączenia
Porty to punkty, w których część styka się z otoczeniem. Definicja portu wymienia, co przekracza granicę, każdą cechę z kierunkiem: out dla tego, co właściciel wysyła, in dla tego, co odbiera.
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;
}
Strona odbierająca używa tej samej definicji portu, sprzężonej za pomocą ~. ~BusPowerPort to lustrzane odbicie BusPowerPort: każde out staje się in. Jedna definicja portu opisuje oba końce łącza, więc nie mogą się one rozejść.
Definicja interfejsu opisuje rodzaj połączenia z typowanymi końcami. BusLink łączy szynę 12 V, która wysyła moc, z odbiornikiem, który ją odbiera. Pełni rolę interfejsu 12 V Power Interface (IFB-1) satelity EO-1.
Teraz dodaj porty do części i połącz je. Wiersze komentarza zastępują wiersze z wcześniejszych kroków.
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.arrayInto zwykłe połączenie: wiązka paneli (interfejs IF-20 satelity EO-1).battery.cellsOutdopdu.batteryInto wiązka akumulatora (IF-21).bind bus = pdu.busOutstwierdza, że własny portbussystemu zasilania i wyjście PDU to to samo. W ten sposób część wystawia wewnętrzny port na swojej granicy: odbiorniki łączą się z EPS, a nie z jego wnętrzem.interface payloadPower : BusLink connect … to …łączy dwa porty przez typowany interfejs, więc połączenie niesie znaczenieBusLink. Dwa interfejsy szyny to Payload Power Line (IF-01) i Radio Power Line (IF-04) satelity EO-1.
Interconnection View rysuje system zasilania z tego tekstu: każdą część z portami na krawędzi, porty sprzężone oznaczone ~ oraz powiązany port bus na ramce.
epsConnections z kroku 9: części EPS, ich porty i połączenia, narysowane z tekstu.Konsekwencja inżynierska: lista interfejsów podsystemu jest teraz zapytaniem, a nie osobną tabelą. Każde połączenie nazywa oba końce, a gdy jest typowane, także to, co przez nie przechodzi. To surowiec dla dokumentu kontroli interfejsów, który zmienia się, gdy zmienia się model.
Częstym błędem jest nadanie obu końcom tego samego, niesprzężonego portu. Wtedy oba końce wysyłają i żaden nie odbiera:
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;
}
}
Tekst się parsuje, ale mechanizm sprawdzający, który porównuje kierunki, ostrzega, że oba końce połączenia wysyłają voltage. Sprzężenie końca odbierającego, port powerIn : ~BusPowerPort;, rozwiązuje problem.
Krok 5: zachowanie z akcjami i przepływami
Struktura mówi, czym system jest; zachowanie mówi, co robi. Definicja akcji opisuje zachowanie z parametrami wejściowymi i wyjściowymi. Definicje elementów (item) opisują rzeczy, które przepływają, tutaj światło słoneczne i moc elektryczną w różnych postaciach.
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;
}
- Parametry
inioutto wejścia i wyjścia akcji. - Wewnątrz
RunPowerCyclecztery użycia akcji to kroki jednej orbity: w świetle słonecznym panele zbierają moc, a PDU ładuje akumulator; w zaćmieniu akumulator oddaje energię, a PDU zasila z niej szynę. flow collect.power to charge.powermówi, że wyjście jednego kroku jest wejściem następnego.first collect then chargeto następstwo: jeden krok kończy się, zanim zacznie się następny. Przepływy mówią, co się przemieszcza; następstwa mówią, w jakiej kolejności.startidoneto początek i koniec akcji nadrzędnej.
Kroki odpowiadają funkcjom zasilania EO-1: F3.1 Convert Sunlight to Power, F3.2 Store Battery Energy i F3.3 Regulate Bus Power. Wyprowadzanie takich funkcji z wymagań i ich porządkowanie to przedmiot analizy funkcjonalnej; definicje akcji to miejsce, w którym ta praca trafia do SysML v2.
Poniższy Action Flow View jest narysowany z tego tekstu wraz z alokacją z kroku 6, która przydziela każdemu krokowi tor.
powerCycleFlow: kroki w świetle słonecznym, potem kroki w zaćmieniu, z mocą przepływającą między nimi.Konsekwencja inżynierska: akumulator leży na drodze każdego wata, który szyna zużywa w zaćmieniu. To, co akumulator zmagazynuje w świetle słonecznym, musi pokryć obciążenie w zaćmieniu, a dokładnie to ograniczają wymagania 3.2 i 3.3 w kroku 7.
Krok 6: alokacja zachowania do struktury
Jak dotąd zachowanie nie należy do żadnego komponentu. Instrukcja perform mówi, która część wykonuje który krok:
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 to użycie Spacecraft na najwyższym poziomie pakietu: statek kosmiczny tego projektu. Jego system zasilania wykonuje RunPowerCycle, a każda część EPS wykonuje swoje kroki. part redefines eps uszczegóławia system zasilania odziedziczony po Spacecraft, zamiast dodawać drugi. PDU wykonuje dwa kroki, ładowanie w świetle słonecznym i zasilanie szyny w zaćmieniu, bo jedna jednostka wykonuje obie prace.
To tekstowa forma alokacji funkcjonalnej. Na jej podstawie narzędzie może wypisać funkcje wykonywane przez każdy komponent albo narysować przepływ akcji z jednym torem na część, jak w widoku powyżej.
Krok 7: wymagania z ograniczeniami
Wymagania trafiają do własnego pakietu, który importuje projekt. W SysML v2 wymaganie jest ograniczeniem nałożonym na podmiot: tekst doc mówi słowami, co jest potrzebne, a require constraint mówi to samo w formie, którą narzędzie może obliczyć. Trzy wymagania to wymagania 3.1, 3.2 i 3.3 satelity EO-1, z ich własnymi identyfikatorami i brzmieniem.
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'>to nazwa skrócona: identyfikator, który inżynierowie przytaczają w przeglądach. Inne elementy modelu odwołują się do pełnej nazwy,OrbitAveragePower.subject eps : ElectricalPowerSystemnazywa to, czego dotyczy wymaganie.require constraint { eps.orbitAveragePower >= required }to warunek, który musi być spełniony. Limit jest parametrem, więc ta sama definicja służy statkowi kosmicznemu o innym zapotrzebowaniu na moc.powerSpeczbiera wymagania dla EO-1 i ustala limity: 28 W, 77 Wh i 0,3.satisfy powerSpec by eo1.epsstwierdza, że system zasilania EO-1 spełnia specyfikację.
Dbaj, aby tekst doc i ograniczenie mówiły to samo. Recenzenci czytają tekst; narzędzia obliczają ograniczenie. Powiązania od wymagania do projektu i testu to podstawa identyfikowalności wymagań.
Requirement View pokazuje specyfikację jako drzewo, z częścią spełniającą i przypadkiem weryfikacji z kroku 8:
requirementTree: wymagania 3.1 do 3.3, co je spełnia i co je weryfikuje.Ponieważ ograniczenia można obliczyć, mechanizm sprawdzający robi więcej, niż tylko rysuje linię satisfy: testuje to stwierdzenie względem wartości z kroku 3. W modelu w obecnej postaci wszystkie trzy są spełnione: 28,05 W wobec 28 W, 77 Wh wobec 77 Wh i głębokość rozładowania 0,24 wobec 0,3.
Pierwszy z tych zapasów jest niewielki. Obniż sprawność toru mocy z 0,6 do 0,59, czyli o mniej niż dwa procent, a średnia moc na orbicie spada do 27,58 W. Mechanizm sprawdzający zgłasza wtedy, że wymaganie 3.1 nie jest już spełnione, podając wartości, które to spowodowały:
Konsekwencja inżynierska: wymaganie 3.1 już zawiera zapas systemowy (jego uzasadnienie w EO-1 to obciążenie 24 W w trybie obrazowania plus 15%), ale panele spełniają samo 3.1 z zapasem zaledwie 0,05 W. Każda strata nieujęta w szacunku, na przykład szybsza degradacja ogniw, wymaga albo większej powierzchni paneli, albo mniejszego obciążenia. Model, który sprawdza wymaganie przy każdej zmianie, pokazuje to, gdy liczba się zmienia, a nie na następnym przeglądzie. Aby zobaczyć, jak prawdopodobne jest utrzymanie zapasu, gdy dane wejściowe są niepewne, a nie stałe, zobacz analizę Monte Carlo w inżynierii systemów.
Krok 8: przypadek weryfikacji
Relacja satisfy to stwierdzenie, a kontrola z kroku 7 testuje je tylko względem liczb samego modelu. Przypadek weryfikacji mówi, jak to stwierdzenie sprawdza się na rzeczywistym sprzęcie: testem, inspekcją, analizą lub demonstracją. EO-1 weryfikuje pojemność akumulatora przypadkiem testowym 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; }nazywa wymaganie, które ten przypadek weryfikuje. Z tych powiązań buduje się macierz weryfikacji: każde wymaganie zestawione z przypadkami, które je weryfikują.return verdictto wynik: tutaj to, czy zmierzona pojemność osiąga 77 Wh z wymagania 3.2.batteryTestto użycie tego przypadku dla systemu zasilania EO-1: zaplanowany test z podmiotem powiązanym zeo1.eps.
Spełnienie i weryfikacja są celowo rozdzielone. Spełnienie mówi, który element projektu odpowiada na wymaganie; weryfikacja mówi, skąd wiadomo, że to robi. W projekcie EO-1 TC-07 zakończył się pozytywnie z wynikiem pomiaru 78,3 Wh. Wymagania 3.1 i 3.3 wciąż potrzebują własnych przypadków, a macierz weryfikacji wymagań to miejsce, w którym ta luka jest widoczna.
Krok 9: widoki i diagramy
W SysML v2 diagram nie jest osobnym rysunkiem. Widok to element modelu, który określa, co pokazać (expose) i jakie rodzaje elementów uwzględnić (filter). Narzędzie renderuje widok i zachowuje jego układ; treść zawsze pochodzi z modelu. Trzy powyższe zrzuty ekranu to właśnie te trzy widoki.
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::**;
}
}
Biblioteka standardowa definiuje typowe rodzaje widoków:
| Widok | Pokazuje | W tym modelu |
|---|---|---|
| General View | Dowolne elementy i ich relacje jako prostokąty i linie | requirementTree |
| Widok połączeń | Części jednego zespołu z ich portami i połączeniami | epsConnections |
| Widok przepływu akcji | Kroki zachowania, ich kolejność i to, co między nimi przepływa | powerCycleFlow |
| Widok przejść stanów | Stany i przejścia między nimi | Brak |
| Widok sekwencji | Komunikaty między częściami w czasie | Brak |
| Widok siatki | Elementy lub relacje jako tabela lub macierz | Brak |
requirementTree to General View, którego filtr zachowuje tylko wymagania i relacje satisfy; narzędzia znające rodzaje diagramów SysML v1, w tym Holarch, pokazują taki widok jako diagram wymagań. Ponieważ widok jest częścią modelu, zmiana nazwy akumulatora zmienia każdy diagram, który go pokazuje, a recenzent może przeczytać w tekście, co dokładnie zawiera diagram.
Kompletny model
Trzy pakiety razem. Pobierz model systemu zasilania EO-1 (cubesat-eps.sysml) albo skopiuj poniższy tekst; oba są identyczne.
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::**;
}
}
Jak sprawdzono listingi
Każdy listing na tej stronie został sparsowany i sprawdzony przez Holarch Language Engine, silnik Edytora SysML v2 w Holarch, z załadowaną biblioteką standardową SysML v2. Kontrole rozwiązują każdą nazwę, porównują jednostki i wymiary, porównują kierunki portów w połączeniach i obliczają ograniczenia wymagań względem wartości, które je spełniają.
- Kompletny model i samodzielny listing nie dają żadnych błędów ani ostrzeżeń.
- Każdy fragment występuje wiersz po wierszu, w tej samej kolejności, w kompletnym modelu.
- Dwa listingi pokazujące błędy dają dokładnie ten błąd i to ostrzeżenie, które opisano obok nich.
- Kompletny model ze sprawnością toru mocy 0,59 daje dokładnie jedno ostrzeżenie: wymaganie 3.1 niespełnione.
Informacje o tym, które konstrukcje SysML v2 obsługuje silnik i jakie ma znane luki, znajdziesz w pokryciu języka SysML v2. Aby porównać narzędzia w tych samych punktach, zobacz co sprawdzić w narzędziu SysML v2; ten model jest na tyle mały, że może posłużyć jako plik testowy.
Wypróbuj w Holarch
- Pobierz
cubesat-eps.sysmlalbo zapisz kompletny model pod tą nazwą. - Otwórz Model → Import i eksport, wybierz Do nowego projektu SysML v2 i upuść plik. Zobacz importowanie plików do nowego projektu.
- Otwórz Model → Edytor, aby czytać i zmieniać tekst. Każdy pakiet jest dokumentem. Zobacz Edytor.
- Otwórz listę Diagramy i kliknij
epsConnections,powerCycleFlowlubrequirementTree. Zobacz otwieranie widoku. - W CubeSatEPS zmień
pathEfficiency = 0.6na0.59i odczekaj chwilę. Edytor pokazuje ostrzeżenie w wierszusatisfyw CubeSatEPSRequirements. Cofnij za pomocą ⌘Z / Ctrl+Z.
Aby zamiast tego wpisać model, utwórz projekt SysML v2, kliknij + Nowy pakiet w Edytorze i zapisz kroki po kolei; tekst, który się parsuje, jest stosowany po krótkiej przerwie. Zobacz pierwsze kroki z projektami SysML v2. Cały statek kosmiczny EO-1, z dokumentami, testami i budżetami, to demo CubeSat: Pliki projektu ▾ → Nowy projekt demonstracyjny.
Co dalej
- Projekty SysML v2 w Holarch: tekst, widoki i strony inżynierskie w jednym modelu.
- Dokumentacja notacji tekstowej: co obsługuje Holarch, kontrole i biblioteka standardowa.
- Dokumentacja widoków: każdy rodzaj widoku i sposób edycji modelu w nim.
- Wymagania i weryfikacja w projektach SysML v2: strony wymagań, Centrum testów i RVTM.
- Analiza w projektach SysML v2: parametryka, budżety i analizy kompromisów.
- Czym jest MBSE?: dlaczego inżynierowie przechowują system w modelu.