Holarch

SysML v2

Tutorial SysML v2

Nove tutorial guidati per i progetti SysML v2, dal primo pacchetto a porte, azioni, stati, requisiti, verifica, vincoli e varianti, con un pannello dei passaggi che controlla il lavoro.

Come usarlo →

In questa pagina
  1. Come usarlo
    1. Avviare un tutorial SysML v2
    2. Digitare il testo di un passaggio
    3. Suggerimenti
  2. Primi passi
  3. Definitions and Attributes
  4. Ports and Interfaces
  5. Actions and Flows
  6. States and Transitions
  7. Requisiti
  8. Verification and Traceability
  9. Constraints and Calculations
  10. Varianti e configurazioni
  11. Progetti dei tutorial
  12. Correlati

Holarch offre una serie di tutorial guidati per i progetti SysML v2. Ognuno crea un piccolo progetto iniziale SysML v2 e apre un pannello dei passaggi accanto alla pagina. Il pannello controlla il modello mentre si lavora: un passaggio diventa verde quando il modello contiene ciò che il passaggio richiede. Questa pagina elenca ogni passaggio come testo, quindi è possibile seguirli anche da qui.

Il primo tutorial usa la WS-1 Weather Station, come i tutorial LML. Gli altri costruiscono parti di un'auto ibrida, il modello della demo Hybrid Car: tipi di valore e componenti, le porte e le interfacce del gruppo propulsore, un ciclo di guida, gli stati del gruppo propulsore, i requisiti dell'auto, la loro verifica, i controlli sui valori della berlina e la linea di prodotti. Ogni tutorial ha il proprio progetto iniziale, quindi è possibile seguirli in qualsiasi ordine. Ogni progetto iniziale e ogni tutorial completato si controllano con 0 problemi.

TutorialTempoSi impara a
Primi passi15 minscrivere testo SysML v2, vederlo come albero e come vista, disegnare nella vista e aggiungere un requisito
Definitions and Attributes20 minscrivere enumerazioni, tipi di valore e definizioni astratte, specializzare con valori e unità, e usare il completamento, Inserisci e la ridenominazione
Ports and Interfaces20 mindefinire porte e interfacce, coniugare le porte, collegare le parti e disegnare un'interfaccia in una Vista di interconnessione
Actions and Flows20 minscrivere definizioni di azione e un ciclo di guida con una biforcazione, flussi e un ricongiungimento, aggiungere corsie e costruire passi nell'FFBD
States and Transitions20 minscrivere segnali e una macchina a stati con trigger, guardie e azioni di stato, e disegnare una transizione temporizzata
Requisiti20 minscrivere limiti, definizioni e usi di requisiti, soddisfarli e vedere un requisito non rispettato
Verification and Traceability15 minscrivere un caso di verifica, tracciare un passo nella Matrice di tracciabilità e derivare un requisito
Constraints and Calculations20 minscrivere vincoli e calcoli, collegare valori in una Vista parametrica, eseguire un caso di analisi e contrassegnare valori TBD e TBR
Varianti e configurazioni15 minscrivere variazioni e varianti, una linea di prodotti con una regola, configurazioni e una parola chiave propria

Come usarlo

Avviare un tutorial SysML v2

  1. Aprire Guida → Tutorial nella barra, oppure premere ⌘K / Ctrl+K e digitare tutorial. Fuori da un progetto, la pagina Tutorial elenca prima i tutorial LML, poi Tutorial per progetti SysML v2. All'interno di un progetto SysML v2 elenca solo i tutorial SysML v2.
  2. Fare clic su Inizia su una scheda. Holarch crea il progetto, per esempio Tutorial: SysML v2 Ports and Interfaces (Hybrid Car), e lo apre con il pannello dei passaggi a destra.

Il pannello dei passaggi funziona come nei tutorial LML: Mostra evidenzia il controllo di cui un passaggio ha bisogno, Vai lì apre la pagina, Ulteriori informazioni apre l'argomento della Guida, e Ricomincia…, Segna come completato e × funzionano allo stesso modo. Vedere Tutorial.

Digitare il testo di un passaggio

La maggior parte dei passaggi fornisce testo SysML da digitare in Modello → Editor. Il passaggio indica dove vanno le righe, per esempio “prima dell'ultima parentesi graffa di chiusura del package”. Il testo viene applicato al modello quando si fa una pausa nella digitazione; lo stato sotto l'editor lo conferma e il passaggio diventa verde.

  • Digitare le righe come indicato. Il rientro non conta per il modello; l'Editor mantiene quello dell'utente.
  • Una sottolineatura rossa segnala un errore: puntarla per leggere il messaggio. Il testo con un errore di sintassi resta una bozza e non viene applicato finché non lo si corregge.
  • ⌘Z / Ctrl+Z annulla l'ultima modifica applicata.

Suggerimenti

  • La prima volta, seguire i tutorial in ordine: ognuno spiega il testo che usa, e quelli successivi presuppongono i concetti precedenti (definizioni e usi, :> e :>>).
  • Un passaggio che resta aperto di solito ha un errore di battitura in un nome. Confrontare il proprio testo con le righe del passaggio; in SysML v2 i nomi distinguono tra maiuscole e minuscole.
  • I tutorial insegnano lo stesso linguaggio di Nozioni di base su SysML v2; la pagina Notazione testuale contiene i dettagli.

Primi passi

Scrivere un primo modello della Weather Station: aprire il testo, aggiungere una definizione di parte con un valore e un'unità, usarla in un'altra definizione, vedere il modello nel Browser e in una Vista generale, disegnare una parte nella vista e vederla comparire nel testo, aggiungere un requisito con satisfy ed esportare il modello come file .sysml. I passaggi sono descritti in Primi passi con i progetti SysML v2.

Definitions and Attributes

Il progetto iniziale contiene il package Vehicles con una definizione di parte, Car.

  1. Aprire il package. Fare clic su Modello → Editor. Ogni dichiarazione è una parola chiave e un nome, seguiti da un corpo tra parentesi graffe o da un punto e virgola.
  2. Scrivere un'enumerazione. Sopra part def Car {, aggiungere enum def DriveMode { enum economy; enum normal; enum sport; } (un valore per riga).
  3. Definire un tipo di valore. Sotto di essa, aggiungere attribute def TirePressure :> ScalarValue;. :> significa “specializza”.
  4. Scrivere una definizione astratta. Aggiungere abstract part def Component con un commento doc e gli attributi mass : MassValue, partNumber : String e power : PowerValue. // inizia una nota che resta solo nel testo.
  5. Lasciare che il controllo trovi un errore. Aggiungere part def Battery :> Component con attribute redefines mass = 45 [kg]; e, di proposito, attribute redefines power = 60 [kg];. Il controllo sottolinea l'unità: i chilogrammi non sono una potenza.
  6. Correggere l'unità. Cambiarla in 60 [W].
  7. Completare un nome. Nella batteria, digitare attribute capacity : Ener, accettare EnergyValue dall'elenco di completamento con Enter e terminare con ;.
  8. Cercarlo nella Libreria standard. Fare clic su Impostazioni → Libreria standard in fondo alla barra e digitare EnergyValue nella casella di ricerca.
  9. Inserire una definizione. Nell'Editor, premere ⌃⇧Space / Ctrl+Shift+Space (o fare clic su Inserisci ▾) su una riga vuota, scegliere Definizione di part e completare part def Engine :> Component con attribute redefines mass = 110 [kg]; e attribute cylinders : Integer;.
  10. Usare le definizioni. In Car, aggiungere attribute mode : DriveMode;, part battery : Battery; e part engine : Engine;.
  11. Rinominare ovunque. Posizionare il cursore su cylinders, premere F2 e rinominarlo in cylinderCount.

Ports and Interfaces

Il progetto iniziale contiene i componenti del gruppo propulsore con le loro porte di coppia e di potenza, le definizioni di porta TorquePort e PowerPort e le definizioni di interfaccia Shaft e HighVoltageBus.

  1. Definire una porta. Sopra port def TorquePort, aggiungere port def FuelPort con out attribute flowRate : Real; e attribute kind : FuelKind;. out significa che il valore esce dalla parte che possiede la porta.
  2. Assegnare le porte alle parti. Aggiungere port fuelOut : FuelPort; a FuelTank e port fuelIn : ~FuelPort; a Engine. ~ coniuga la porta: ingresso e uscita sono invertiti.
  3. Definire un'interfaccia. Aggiungere interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }.
  4. Costruire il gruppo propulsore. Alla fine del package, aggiungere part def Powertrain con le parti tank, engine, motor, battery e transmission, una porta output : TorquePort e bind output = transmission.output;.
  5. Collegare due parti. Nel gruppo propulsore, aggiungere interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn;.
  6. Aggiungere gli alberi di trasmissione. Aggiungere interface engineShaft : Shaft connect engine.output to transmission.engineIn; e interface motorShaft : Shaft connect motor.output to transmission.motorIn;.
  7. Creare una Vista di interconnessione. Fare clic su Architettura → Viste di interconnessione, poi su + Nuovo diagramma. Scegliere Powertrain in Mostra e fare clic su Crea.
  8. Disegnare un'interfaccia. Trascinare dalla maniglia della porta powerOut della batteria alla porta powerIn del motore e rilasciare su Interface : HighVoltageBus.
  9. Assegnare un nome all'interfaccia. Selezionare la nuova linea e inserire hvBus come Nome nell'ispettore.
  10. Vederla nel testo. Fare clic su Modello → Editor: l'interfaccia si trova nel gruppo propulsore, con nome, tipo ed estremità.

Actions and Flows

Il progetto iniziale contiene il package VehicleBehavior con gli item Fuel e Torque, le funzioni ProduceTorque (F.2) e DriveWheels (F.3) e tre definizioni di parte.

  1. Definire una funzione. Aggiungere action def <'F.1'> SupplyFuel con in attribute fuelDemand : Real; e out item fuel : Fuel;. Il nome breve tra parentesi angolari è il numero della funzione.
  2. Scrivere il ciclo di guida. Aggiungere action def <'F'> DriveCycle con first start then split;, fork split;, then supply;, then produce; e i passi action supply : SupplyFuel e action produce : ProduceTorque, ciascuno con una duration.
  3. Aggiungere un flusso. Nel ciclo di guida, aggiungere flow of Fuel from supply.fuel to produce.fuel;.
  4. Ricongiungere i rami. Aggiungere first supply then ready;, first produce then ready;, join ready;, then action drive : DriveWheels { … }, then done; e flow produce.torque to drive.torque;.
  5. Creare una Action Flow View. Fare clic su Comportamento → Flussi di azioni, poi su + Nuovo diagramma, e scegliere DriveCycle in Mostra.
  6. Indicare chi esegue ogni passo. Aggiungere part def DrivenCar con perform action trip : DriveCycle; e le parti tank, engine e transmission, ciascuna con perform trip.supply;, perform trip.produce; o perform trip.drive;. La vista ottiene una corsia per ogni parte.
  7. Aprire Analisi funzionale. Fare clic su Comportamento → Analisi funzionale, fare clic su Scegli… e selezionare DriveCycle.
  8. Dichiarare un'altra azione. Aggiungere action def EmergencyShutdown;.
  9. Costruire i passi nell'FFBD. Fare clic su Comportamento → FFBD, poi su + Nuovo diagramma, e scegliere EmergencyShutdown. Nel pannello Aggiungi, digitare Open Contactors e premere Enter, poi Cut Fuel.
  10. Vedere i passi nel testo. Fare clic su Modello → Editor: l'FFBD ha scritto i passi e le loro successioni.

States and Transitions

Il progetto iniziale contiene il package PowertrainBehavior con un part def Car vuoto.

  1. Definire i segnali. Aggiungere attribute def StartRequest;, e allo stesso modo StopRequest, PlugIn e Unplug.
  2. Scrivere una definizione di stato. Aggiungere state def PowertrainStates con in attribute charge : Real;, entry; then off; e gli stati off, electric e hybrid.
  3. Aggiungere transizioni. Dopo state off;, aggiungere accept StartRequest if charge > 20 then electric; e accept StartRequest then hybrid;.
  4. Assegnare azioni a uno stato. Sostituire state electric; con un corpo che contiene entry action spinUpMotor;, do action driveElectric; e exit action holdMotor;.
  5. Uscire dallo stato elettrico. Dopo di esso, aggiungere if charge < 15 then hybrid; e accept StopRequest then off;; aggiungere accept StopRequest then off; anche dopo state hybrid;.
  6. Aggiungere uno stato con transizioni con nome. Aggiungere state charging { do action chargeBattery; }, transition plugIn first off accept PlugIn then charging; e transition unplugged first charging accept Unplug then off;.
  7. Creare una Vista di transizione di stato. Fare clic su Comportamento → Macchine a stati, poi su + Nuovo diagramma, e scegliere PowertrainStates in Mostra.
  8. Disegnare una transizione temporizzata. Trascinare dalla maniglia di charging a off e rilasciare su Transizione. Nel pannello della transizione, inserire il Nome charged e il Trigger after 30 [min].
  9. Vederla nel testo. Fare clic su Modello → Editor: la transizione è scritta come transizione con nome.
  10. Far esibire gli stati all'auto. In Car, aggiungere exhibit state powertrainStates : PowertrainStates;.

Requisiti

Il progetto iniziale contiene il package VehicleRequirements con una piccola copia del progetto: Battery, Car e la sedan della flotta con una massa in ordine di marcia di 1580 kg.

  1. Dare un nome ai limiti. Aggiungere attribute maxCurbMass : MassValue = 1650 [kg]; e attribute minBatteryCapacity : EnergyValue = 1.2 [kW*h];.
  2. Scrivere una definizione di requisito. Aggiungere requirement def <'VR-1'> CurbMass con un enunciato doc, subject car : Car;, attribute limit : MassValue; e require constraint { car.curbMass <= limit }.
  3. Inserire un requisito. Premere ⌃⇧Space / Ctrl+Shift+Space su una riga vuota, scegliere Definizione di requisito e scrivere VR-3 BatteryCapacity con il soggetto battery : Battery e require constraint { battery.capacity >= minBatteryCapacity }.
  4. Annidare i requisiti in una specifica. Aggiungere requirement carSpec con subject car : Car; e requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }.
  5. Indicare cosa li soddisfa. Aggiungere satisfy carSpec by fleet.sedan; e satisfy requirement batterySpec : BatteryCapacity by fleet.sedan.battery;.
  6. Violare un requisito. Cambiare la massa in ordine di marcia della berlina in 1700 [kg]. L'Editor segnala il satisfy: la berlina non rispetta più VR-1.1.
  7. Rispettarlo di nuovo. Premere ⌘Z / Ctrl+Z, oppure riportarla a 1580 [kg].
  8. Vedere la tabella dei requisiti. Fare clic su Esigenze e requisiti → Requisiti.
  9. Creare una Vista dei requisiti. Nella pagina Diagrammi, fare clic su + Nuovo diagramma, scegliere Vista dei requisiti e carSpec in Mostra.
  10. Controllare gli enunciati. Fare clic su Esigenze e requisiti → Qualità e fare clic su Controlla qualità.

Verification and Traceability

Il progetto iniziale contiene il requisito sulla massa in ordine di marcia e la specifica dell'auto, un ciclo di guida con i passi cruise e brake, VR-6 batteryMassLimit e VR-7 stopFromCruise.

  1. Scrivere un caso di verifica. Aggiungere verification def <'VC-1'> CurbMassTest con subject car : Car;, objective massObjective { verify carSpec.sedanMass; } e return verdict : Boolean = car.curbMass <= maxCurbMass;.
  2. Applicarlo alla berlina. Aggiungere verification <'VC-1.1'> sedanWeighing : CurbMassTest { subject car = fleet.sedan; }.
  3. Aprire i casi di verifica. Fare clic su Verifica → Casi di verifica. Passi, risultati e stato sono dati di Holarch accanto al modello. Nella riga di Sedan Weighing, fare clic su + Passi, poi su + Aggiungi passo, digitare Weigh the car sotto Action e fare clic su Applica. Poi fare clic su Superati tra i suoi pulsanti di stato.
  4. Leggere la RVTM. Fare clic su Verifica → RVTM.
  5. Tracciare un passo verso un requisito. Fare clic su Verifica → Matrice di tracciabilità, mostrare i requisiti come righe e le azioni come colonne, fare clic sulla cella di stopFromCruise e brake e scegliere satisfied by.
  6. Derivare un requisito. Aggiungere private import RequirementDerivation::*; e connection batteryMassDerivation : Derivation connect carSpec.sedanMass to batteryMassLimit;.
  7. Eseguire i controlli del modello. Fare clic su Verifica → Controlli del modello.

Constraints and Calculations

Il progetto iniziale contiene il package VehicleAnalysis con il motore, la batteria, l'auto e i valori della berlina, e gli obiettivi maxCurbMass e minPowerToWeight.

  1. Scrivere una definizione di vincolo. Aggiungere constraint def MassLimit con in mass : MassValue;, in limit : MassValue; e l'espressione mass <= limit.
  2. Scrivere un calcolo. Aggiungere calc def PowerToWeight con i parametri power e mass e return ratio = power / mass;.
  3. Collegare i valori della berlina. Aggiungere constraint sedanMassCheck : MassLimit { in mass = fleet.sedan.curbMass; in limit = maxCurbMass; }.
  4. Creare una Vista parametrica. Nella pagina Diagrammi, fare clic su + Nuovo diagramma, scegliere Vista parametrica e VehicleAnalysis in Mostra. Il controllo è superato: 1580 kg rientra in 1650 kg.
  5. Far fallire il controllo. Cambiare la massa in ordine di marcia della berlina in 1700 [kg]; la vista mostra il controllo fallito.
  6. Farlo superare di nuovo. Annullare, oppure riportarla a 1580 [kg]. Risolvi tutto controlla di nuovo ogni vincolo.
  7. Eseguire un caso di analisi. Aggiungere analysis def PowerToWeightAnalysis con un obiettivo che richiede ratio >= minPowerToWeight, e analysis sedanPowerToWeight : PowerToWeightAnalysis { subject car = fleet.sedan; }.
  8. Contrassegnare i valori aperti. Aggiungere private import HolarchMetadata::*; e il requisito VR-5 ChargeTime con #TBR sul suo limite di tempo e @TBD con un responsabile, una scadenza e una motivazione sulla potenza del caricatore. TBD e TBR provengono dalla libreria HolarchMetadata di Holarch, non dalla libreria standard di SysML v2; specializzano i metadati standard StatusInfo.
  9. Aprire il registro TBD/TBR. Fare clic su Esigenze e requisiti → TBD/TBR. Il tempo di ricarica è elencato con il responsabile e la scadenza dei suoi metadati @TBD. Il registro è di sola lettura: modificare il responsabile o la data nei metadati nell'Editor.
  10. Aggregare la massa. Fare clic su Architettura → Budget e TPM e selezionare la parte radice sedan.

Varianti e configurazioni

Il progetto iniziale contiene Component, Battery, Controller, Car e Powertrain.

  1. Importare il package di variabilità. Aggiungere private import HolarchVariability::*;.
  2. Scrivere una variazione. Su una riga vuota, premere ⌃⇧Space / Ctrl+Shift+Space (o fare clic su Inserisci ▾), scegliere Variazione e completare variation part def BatteryPack :> Battery con le varianti standardPack (1,4 kWh) e largePack (12 kWh, 120 kg).
  3. Scrivere la linea di prodotti. Aggiungere part def CarLine :> Car con part pack : BatteryPack;, una variation part charger con le varianti noCharger e wallbox, e assert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack }.
  4. Avviare una configurazione. Scegliere Inserisci ▾ → Configurazione e compilare part plugInHybrid : CarLine { @HolarchConfiguration; }. L'Editor segnala i punti di variazione ancora aperti.
  5. Scegliere le varianti. In plugInHybrid, scegliere Inserisci ▾ → Scelta della variante per ogni punto e compilare part :>> pack = BatteryPack::largePack; e part :>> charger = charger::wallbox;.
  6. Aggiungere una seconda configurazione. Aggiungere selfChargingHybrid allo stesso modo, con il pacco standard e senza caricatore.
  7. Definire una parola chiave propria. Aggiungere metadata def <safetyCritical> SafetyCritical.
  8. Usare la parola chiave. In Powertrain, scrivere #safetyCritical part controller : Controller;.
  9. Vedere la linea di prodotti. Creare una Vista generale di Vehicles: il pacco batteria è contrassegnato come variation.

Progetti dei tutorial

I progetti dei tutorial SysML v2 seguono le stesse regole degli altri progetti dei tutorial: non contano per i progetti attivi del piano, contengono fino a 300 elementi ed è possibile averne uno per tutorial. Vedere Tutorial.

SysML® e OMG® sono marchi registrati di Object Management Group, Inc. negli Stati Uniti e in altri paesi.