Guida · SysML v2
Tutorial SysML v2: modellare il sistema di potenza di un CubeSat nella notazione testuale
Ascolta questa guida 24 min
Questo tutorial di SysML v2 costruisce passo per passo un modello piccolo ma completo: il sistema di alimentazione elettrica del CubeSat EO-1, con le sue parti, grandezze e unità, porte e connessioni, un ciclo di luce ed eclissi, requisiti che uno strumento può controllare, un caso di verifica e viste. Ogni listato di questa pagina è testo SysML v2 controllato con un motore di linguaggio, e ogni passo chiave mostra il diagramma prodotto dal testo.
In questa pagina
- Che cosa si costruirà
- Primo concetto: definizioni e usi
- Passo 1: un pacchetto e i suoi import
- Passo 2: definizioni di parte e attributi con unità
- Passo 3: l’assieme, con i valori
- Passo 4: porte, interfacce e connessioni
- Passo 5: comportamento con azioni e flussi
- Passo 6: allocare il comportamento alla struttura
- Passo 7: requisiti con vincoli
- Passo 8: un caso di verifica
- Passo 9: viste e diagrammi
- Il modello completo
- Come sono stati controllati i listati
- Provarlo in Holarch
- Dove andare dopo
Che cosa si costruirà
EO-1 è un CubeSat 6U per l’osservazione della Terra in un’orbita eliosincrona a 500 km. È l’esempio comune di queste guide; il progetto di esempio MBSE segue l’intero veicolo spaziale dalle esigenze alla verifica. Questo tutorial prende un sottosistema, il sistema di alimentazione elettrica (EPS), e lo scrive in testo SysML v2.
L’EPS ha tre parti. Due pannelli solari dispiegabili trasformano la luce solare in potenza. Un pacco batteria agli ioni di litio accumula energia per l’eclissi. Un’unità di distribuzione dell’alimentazione (PDU) insegue il punto di massima potenza dei pannelli, carica la batteria e regola il bus a 12 V. Nel modello ci sono anche due carichi su quel bus: la fotocamera del payload e il trasmettitore in banda S.
I numeri provengono dal modello EO-1:
| Elemento | Valore | Dove viene usato |
|---|---|---|
| Pannelli solari: area delle celle, rendimento delle celle, potenza di picco | 0,2 m², 0,295, 75,4 W | Passo 3 |
| Rendimento del percorso di alimentazione; frazione illuminata dell’orbita | 0.6; 0.62 | Passo 3 |
| Pacco batteria: capacità; energia prelevata nell’eclissi di 36 minuti | 77 Wh; 18,5 Wh | Passo 3 |
| Massa: pannelli, batteria, PDU | 0,45 kg, 0,62 kg, 0,28 kg | Passo 3 |
| Assorbimento medio orbitale: fotocamera, trasmettitore in banda S | 6,2 W, 3,4 W | Passo 3 |
| Requisito 3.1 Orbit Average Power | almeno 28 W a fine vita | Passo 7 |
| Requisito 3.2 Battery Capacity | almeno 77 Wh a inizio vita | Passi 7 e 8 |
| Requisito 3.3 Depth of Discharge | al massimo il 30% per orbita | Passo 7 |
| Caso di test TC-07 Battery Capacity Test | scarica a C/2 in una camera a 20 °C | Passo 8 |
Il modello ha tre pacchetti:
| Pacchetto | Contiene | Passi |
|---|---|---|
CubeSatEPS | Porte, parti, un calcolo, gli assiemi con i loro valori e il comportamento | Da 1 a 6 |
CubeSatEPSRequirements | I requisiti da 3.1 a 3.3 e il caso di verifica TC-07 | 7 e 8 |
CubeSatEPSViews | Viste che selezionano parti del modello per i diagrammi | 9 |
Per seguire il tutorial non serve uno strumento particolare: il testo è SysML v2 puro e si carica in qualsiasi strumento che legga la notazione testuale. Il modello completo si trova alla fine della pagina e come file scaricabile, e l’ultima sezione mostra come caricarlo in Holarch.
Primo concetto: definizioni e usi
SysML v2 separa una definizione da un uso. Una definizione dice che cos’è un tipo di cosa: part def BatteryPack descrive ogni pacco batteria di questo progetto, con i suoi attributi e le sue porte. Un uso è una tale cosa in un contesto: part battery : BatteryPack all’interno del sistema di alimentazione è l’unica batteria dell’EPS di EO-1, collegata alla sua PDU.
Lo stesso abbinamento attraversa l’intero linguaggio: attribute def e attribute, port def e port, action def e action, requirement def e requirement. Una parola chiave seguita da def dichiara un tipo; la stessa parola chiave senza def ne usa uno. I valori specifici appartengono di solito agli usi, perché è nell’uso che si prende una decisione di progetto.
Chi conosce SysML v1 può paragonare una definizione a un blocco e un uso a una part property. In SysML v2 l’idea si applica a ogni tipo di elemento, e gli usi si annidano e si raffinano a vicenda a qualsiasi profondità. SysML v1 e SysML v2 a confronto confronta i due linguaggi costrutto per costrutto.
Passo 1: un pacchetto e i suoi import
Un pacchetto è uno spazio dei nomi: raggruppa elementi e dà loro nomi qualificati come CubeSatEPS::BatteryPack. Iniziare con un pacchetto vuoto e gli import di libreria necessari.
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 /* … */associa documentazione al pacchetto. A differenza di un commento//, fa parte del modello, e gli strumenti la mostrano con l’elemento.ScalarValuesfornisce tipi di base comeReal,Integer,BooleaneString.ISQfornisce tipi di grandezza del Sistema internazionale delle grandezze, comeMassValue,PowerValueedEnergyValue.SIfornisce unità SI comekg,V,Weh.privatemantiene i nomi importati all’interno di questo pacchetto, così un pacchetto che importaCubeSatEPSnon li riceve attraverso di esso.
Senza gli import, un nome come MassValue non può essere risolto, e un verificatore lo segnala come sconosciuto.
Passo 2: definizioni di parte e attributi con unità
Ogni componente riceve una definizione di parte con attributi tipizzati. Tipizzare un attributo con una grandezza anziché con Real registra che cosa misura: una massa, una potenza, un’energia. Uno strumento può allora controllare la coerenza dimensionale di ogni valore e di ogni espressione.
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;
}
Queste righe vanno all’interno delle parentesi graffe del pacchetto. I due rendimenti restano semplici Real perché sono rapporti senza unità.
Non ci sono ancora valori. Una definizione descrive ogni pacco batteria di questo tipo; i numeri arrivano con la batteria propria di EO-1 nel passo successivo.
Passo 3: l’assieme, con i valori
Anche il sistema di alimentazione è una definizione di parte, composta da usi di parte: i pannelli solari, la batteria e la PDU. Ogni uso assegna i valori agli attributi che eredita dalla sua definizione. Un calcolo riutilizzabile trasforma la potenza di picco dei pannelli nella potenza media orbitale rispetto alla quale è scritto il requisito 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 : BatteryPackdichiara un uso chiamatobattery, tipizzato dalla definizioneBatteryPack.attribute redefines capacity = 77 [W*h]assegna un valore allacapacityereditata. La forma breve:>> capacity = 77 [W*h];ha lo stesso significato. Senzaredefines, la riga dichiarerebbe un secondo attributo che condivide solo il nome, e lacapacityereditata resterebbe senza valore.77 [W*h]è una grandezza: un numero e un’unità. Le unità si combinano con*,/e^, quindi i wattora sonoW*he i metri quadratim^2.calc def OrbitAverageè un calcolo con input e un risultato tipizzato.OrbitAverage(…)lo richiama con i valori dei pannelli, così la formula è scritta una sola volta e ogni suo uso segue una modifica.depthOfDischargedivide un’energia per un’energia. Le unità si annullano, e il risultato è un semplice rapporto.Spacecraftmette il sistema di alimentazione accanto ai due carichi seguiti da questo tutorial. Il resto di EO-1 (controllo d’assetto, computer di bordo, struttura) è omesso per mantenere breve il modello.
I valori non sono solo memorizzati; uno strumento li valuta. Con i numeri sopra:
| Attributo | Espressione | Risultato |
|---|---|---|
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 |
La potenza di picco stessa ha un’origine verificabile: 0,2 m² di celle con rendimento 0,295 sotto 1361 W/m² di luce solare, con un angolo di incidenza di 0,35 rad (cos 0,35 = 0,939), danno 75,4 W. La frazione illuminata discende dall’orbita: un’orbita a 500 km dura circa 94,6 minuti, di cui 36 in eclissi, il che lascia 0,62 dell’orbita alla luce del sole.
Poiché ogni valore ha un’unità, un errore dimensionale emerge non appena il modello viene controllato. Uno frequente nei modelli di potenza è scrivere la capacità di una batteria in watt anziché in wattora:
package UnitCheck {
private import ISQ::*;
private import SI::*;
part def BatteryPack {
attribute capacity : EnergyValue;
}
part battery : BatteryPack {
attribute redefines capacity = 77 [W];
}
}
Un verificatore che valuta le unità rifiuta il valore: una potenza non è un’energia. In Holarch l’Editor segnala la riga con un errore dimensionale. In un foglio di calcolo lo stesso errore passerebbe inosservato nella profondità di scarica.
Passo 4: porte, interfacce e connessioni
Le porte sono i punti in cui una parte incontra l’ambiente circostante. Una definizione di porta elenca ciò che attraversa il confine, ogni feature con una direzione: out per ciò che il proprietario invia, in per ciò che riceve.
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;
}
Il lato ricevente usa la stessa definizione di porta, coniugata con ~. ~BusPowerPort è l’immagine speculare di BusPowerPort: ogni out diventa in. Una sola definizione di porta descrive entrambi gli estremi di un collegamento, quindi i due estremi non possono divergere.
Una definizione di interfaccia descrive un tipo di connessione con estremi tipizzati. BusLink collega il bus a 12 V, che invia potenza, a un carico che la riceve. Svolge il ruolo della 12 V Power Interface (IFB-1) di EO-1.
Ora aggiungere le porte alle parti e collegarle. Le righe di commento rappresentano le righe dei passi precedenti.
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.arrayInè una connessione semplice: il cablaggio dei pannelli (l’interfaccia IF-20 di EO-1). Dabattery.cellsOutapdu.batteryInè il cablaggio della batteria (IF-21).bind bus = pdu.busOutafferma che la portabusdel sistema di alimentazione e l’uscita della PDU sono la stessa cosa. È così che una parte espone una porta interna sul proprio confine: i carichi si collegano all’EPS, non al suo interno.interface payloadPower : BusLink connect … to …collega due porte tramite un’interfaccia tipizzata, così la connessione porta il significato diBusLink. Le due interfacce del bus sono la Payload Power Line (IF-01) e la Radio Power Line (IF-04) di EO-1.
Una Vista di interconnessione disegna il sistema di alimentazione da questo testo: ogni parte con le sue porte sul bordo, le porte coniugate contrassegnate con ~ e la porta bus collegata sulla cornice.
epsConnections del passo 9: le parti dell’EPS, le loro porte e connessioni, disegnate dal testo.La conseguenza ingegneristica: l’elenco delle interfacce del sottosistema è ora una query, non una tabella separata. Ogni connessione nomina entrambi gli estremi e, quando è tipizzata, ciò che la attraversa. È la materia prima di un documento di controllo delle interfacce, e cambia quando cambia il modello.
Un errore comune è dare a entrambi gli estremi la stessa porta non coniugata. Entrambi gli estremi allora inviano e nessuno riceve:
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;
}
}
Il testo viene analizzato, ma un verificatore che confronta le direzioni avvisa che entrambi gli estremi della connessione inviano voltage. Coniugare l’estremo ricevente, port powerIn : ~BusPowerPort;, risolve il problema.
Passo 5: comportamento con azioni e flussi
La struttura dice che cos’è il sistema; il comportamento dice che cosa fa. Una definizione di azione descrive un comportamento con parametri di ingresso e di uscita. Le definizioni di item descrivono le cose che fluiscono, qui la luce solare e la potenza elettrica nelle sue diverse forme.
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;
}
- I parametri
ineoutsono gli ingressi e le uscite di un’azione. - All’interno di
RunPowerCycle, quattro usi di azione sono i passi di un’orbita: alla luce del sole i pannelli raccolgono potenza e la PDU carica la batteria; in eclissi la batteria restituisce l’energia e la PDU alimenta il bus con essa. flow collect.power to charge.powerdice che l’uscita di un passo è l’ingresso del successivo.first collect then chargeè una successione: un passo termina prima che inizi il successivo. I flussi dicono che cosa si muove; le successioni dicono in quale ordine.startedonesono l’inizio e la fine dell’azione che li contiene.
I passi corrispondono alle funzioni di potenza di EO-1: F3.1 Convert Sunlight to Power, F3.2 Store Battery Energy e F3.3 Regulate Bus Power. Derivare tali funzioni dai requisiti e ordinarle è l’argomento dell’analisi funzionale; le definizioni di azione sono il punto in cui quel lavoro approda in SysML v2.
La Action Flow View qui sotto è disegnata da questo testo insieme all’allocazione del passo 6, che assegna a ogni passo una corsia.
powerCycleFlow: i passi alla luce del sole, poi i passi in eclissi, con la potenza che fluisce tra di essi.La conseguenza ingegneristica: la batteria si trova sul percorso di ogni watt che il bus usa in eclissi. Ciò che la batteria accumula alla luce del sole deve coprire il carico dell’eclissi, ed è esattamente ciò che i requisiti 3.2 e 3.3 vincolano nel passo 7.
Passo 6: allocare il comportamento alla struttura
Finora il comportamento non appartiene ad alcun componente. Un’istruzione perform dice quale parte esegue quale passo:
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 è un uso di Spacecraft in cima al pacchetto: il veicolo spaziale di questo progetto. Il suo sistema di alimentazione esegue RunPowerCycle, e ogni parte dell’EPS esegue i propri passi. part redefines eps raffina il sistema di alimentazione ereditato da Spacecraft invece di aggiungerne un secondo. La PDU esegue due passi, la carica alla luce del sole e l’alimentazione del bus in eclissi, perché un’unica unità svolge entrambi i compiti.
È la forma testuale di un’allocazione funzionale. Da essa uno strumento può elencare le funzioni eseguite da ogni componente, o disegnare il flusso d’azioni con una corsia per parte, come nella vista qui sopra.
Passo 7: requisiti con vincoli
I requisiti vanno in un pacchetto proprio, che importa il progetto. In SysML v2 un requisito è un vincolo su un soggetto: il testo doc dice a parole che cosa serve, e un require constraint dice la stessa cosa in una forma che uno strumento può valutare. I tre requisiti sono i requisiti 3.1, 3.2 e 3.3 di EO-1, con i loro id e la loro formulazione.
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'>è un nome breve: l’identificativo che gli ingegneri citano nelle revisioni. Gli altri elementi del modello fanno riferimento al nome completo,OrbitAveragePower.subject eps : ElectricalPowerSystemnomina ciò di cui tratta il requisito.require constraint { eps.orbitAveragePower >= required }è la condizione che deve valere. Il limite è un parametro, quindi la stessa definizione serve per un veicolo spaziale con un diverso fabbisogno di potenza.powerSpecraccoglie i requisiti di EO-1 e imposta i limiti: 28 W, 77 Wh e 0,3.satisfy powerSpec by eo1.epsafferma che il sistema di alimentazione di EO-1 soddisfa la specifica.
Fare in modo che il testo doc e il vincolo dicano la stessa cosa. I revisori leggono il testo; gli strumenti valutano il vincolo. I collegamenti dal requisito al progetto e al test sono la base della tracciabilità dei requisiti.
Una Vista dei requisiti mostra la specifica come albero, con la parte che la soddisfa e il caso di verifica del passo 8:
requirementTree: i requisiti da 3.1 a 3.3, ciò che li soddisfa e ciò che li verifica.Poiché i vincoli si possono valutare, un verificatore fa più che disegnare la linea satisfy: mette alla prova l’affermazione con i valori del passo 3. Con il modello così com’è scritto, tutti e tre valgono: 28,05 W contro 28 W, 77 Wh contro 77 Wh e una profondità di scarica di 0,24 contro 0,3.
Il primo di questi margini è sottile. Abbassando il rendimento del percorso di alimentazione da 0,6 a 0,59, una variazione inferiore al due per cento, la potenza media orbitale scende a 27,58 W. Il verificatore segnala allora che il requisito 3.1 non è più soddisfatto, con i valori che lo hanno violato:
La conseguenza ingegneristica: il requisito 3.1 contiene già il margine di sistema (la sua motivazione in EO-1 è un carico di 24 W in modalità di acquisizione più il 15%), ma i pannelli soddisfano 3.1 con appena 0,05 W di scarto. Qualsiasi perdita non compresa nella stima, come un degrado più rapido delle celle, richiede più area dei pannelli o un carico minore. Un modello che controlla il requisito a ogni modifica lo mostra quando il numero si sposta, non alla revisione successiva. Per vedere con quale probabilità il margine regge quando gli input sono incerti anziché fissi, si veda l’analisi Monte Carlo nell’ingegneria dei sistemi.
Passo 8: un caso di verifica
Una relazione satisfy è un’affermazione, e il controllo del passo 7 la mette alla prova solo con i numeri del modello stesso. Un caso di verifica dice come l’affermazione viene controllata sull’hardware reale, tramite test, ispezione, analisi o dimostrazione. EO-1 verifica la capacità della batteria con il caso di test 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; }nomina il requisito verificato da questo caso. Questi collegamenti sono la base su cui si costruisce una matrice di verifica: ogni requisito rispetto ai casi che lo verificano.return verdictè il risultato: qui, se la capacità misurata raggiunge i 77 Wh del requisito 3.2.batteryTestè un uso del caso per il sistema di alimentazione di EO-1: il test pianificato, con il soggetto collegato aeo1.eps.
Soddisfacimento e verifica sono tenuti separati di proposito. Il soddisfacimento dice quale elemento di progetto risponde a un requisito; la verifica dice come si sa che lo fa. Nel progetto EO-1, TC-07 è stato superato con 78,3 Wh misurati. I requisiti 3.1 e 3.3 hanno ancora bisogno di casi propri, e una matrice di verifica dei requisiti è il punto in cui emerge questa lacuna.
Passo 9: viste e diagrammi
In SysML v2 un diagramma non è un disegno separato. Una vista è un elemento del modello che dichiara che cosa mostrare (expose) e quali tipi di elementi includere (filter). Uno strumento visualizza la vista e ne conserva il layout; il contenuto proviene sempre dal modello. I tre screenshot qui sopra sono queste tre viste.
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::**;
}
}
La libreria standard definisce i tipi di vista comuni:
| Vista | Mostra | In questo modello |
|---|---|---|
| Vista generale | Qualsiasi elemento e le sue relazioni, come riquadri e linee | requirementTree |
| Vista di interconnessione | Le parti di un assieme con le loro porte e connessioni | epsConnections |
| Action Flow View | I passi di un comportamento, il loro ordine e ciò che fluisce tra di essi | powerCycleFlow |
| Vista di transizione di stato | Stati e transizioni tra di essi | Nessuno |
| Vista di sequenza | Messaggi tra parti nel tempo | Nessuno |
| Vista a griglia | Elementi o relazioni sotto forma di tabella o matrice | Nessuno |
requirementTree è una Vista generale il cui filtro mantiene solo i requisiti e le relazioni satisfy; gli strumenti che conoscono i tipi di diagramma SysML v1, tra cui Holarch, mostrano una vista del genere come requirement diagram. Poiché una vista fa parte del modello, rinominare la batteria modifica ogni diagramma che la mostra, e un revisore può leggere nel testo esattamente che cosa include un diagramma.
Il modello completo
I tre pacchetti insieme. Scaricare il modello del sistema di alimentazione di EO-1 (cubesat-eps.sysml), oppure copiare il testo qui sotto; i due sono identici.
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::**;
}
}
Come sono stati controllati i listati
Ogni listato di questa pagina è stato analizzato e controllato con l’Holarch Language Engine, il motore dell’Editor SysML v2 di Holarch, con la libreria standard SysML v2 caricata. I controlli risolvono ogni nome, confrontano unità e dimensioni, confrontano le direzioni delle porte attraverso le connessioni e valutano i vincoli dei requisiti rispetto ai valori che li soddisfano.
- Il modello completo e il listato autonomo non producono errori né avvisi.
- Ogni estratto compare riga per riga, nell’ordine, nel modello completo.
- I due listati che mostrano errori producono esattamente l’errore e l’avviso descritti accanto a essi.
- Il modello completo con un rendimento del percorso di alimentazione di 0,59 produce esattamente un avviso: requisito 3.1 non soddisfatto.
Per sapere quali costrutti SysML v2 il motore supporta e quali sono le sue lacune note, si veda Copertura del linguaggio SysML v2. Per confrontare gli strumenti sugli stessi punti, si veda che cosa controllare in uno strumento SysML v2; questo modello è abbastanza piccolo da servire come file di prova.
Provarlo in Holarch
- Scaricare
cubesat-eps.sysml, oppure salvare il modello completo con quel nome. - Aprire Modello → Importazione ed esportazione, scegliere In un nuovo progetto SysML v2 e trascinare il file. Si veda importare file in un nuovo progetto.
- Aprire Modello → Editor per leggere e modificare il testo. Ogni pacchetto è un documento. Si veda l’Editor.
- Aprire l’elenco Diagrammi e fare clic su
epsConnections,powerCycleFloworequirementTree. Si veda aprire una vista. - In CubeSatEPS, cambiare
pathEfficiency = 0.6in0.59e attendere un momento. L’Editor mostra l’avviso sulla rigasatisfyin CubeSatEPSRequirements. Annullare con ⌘Z / Ctrl+Z.
Per digitare invece il modello, creare un progetto SysML v2, fare clic su + Nuovo package nell’Editor e scrivere i passi in ordine; il testo analizzato correttamente viene applicato dopo una breve pausa. Si veda primi passi con i progetti SysML v2. L’intero veicolo spaziale EO-1, con i suoi documenti, test e budget, è la demo CubeSat: File di progetto ▾ → Nuovo progetto demo.
Dove andare dopo
- Progetti SysML v2 in Holarch: testo, viste e pagine di ingegneria su un unico modello.
- Riferimento della notazione testuale: che cosa supporta Holarch, i controlli e la libreria standard.
- Riferimento sulle viste: ogni tipo di vista e come modificarvi il modello.
- Requisiti e verifica nei progetti SysML v2: pagine dei requisiti, il Centro test e la RVTM.
- Analisi nei progetti SysML v2: parametrica, budget e studi di trade-off.
- Che cos’è l’MBSE?: perché gli ingegneri tengono il sistema in un modello.