Holarch

SysML v2

Tutoriais de SysML v2

Nove tutoriais guiados para projetos SysML v2, do primeiro pacote a portas, ações, estados, requisitos, verificação, restrições e variantes, com um painel de etapas que confere seu trabalho.

Como usá-lo →

Nesta página
  1. Como usá-lo
    1. Iniciar um tutorial de SysML v2
    2. Digitar o texto de uma etapa
    3. Dicas
  2. Primeiros passos
  3. Definições e atributos
  4. Portas e interfaces
  5. Ações e fluxos
  6. Estados e transições
  7. Requisitos
  8. Verificação e rastreabilidade
  9. Restrições e cálculos
  10. Variantes e configurações
  11. Projetos de tutorial
  12. Relacionado

O Holarch tem uma trilha de tutoriais guiados para projetos SysML v2. Cada um cria um pequeno projeto inicial SysML v2 e abre um painel de etapas ao lado da página. O painel confere o modelo enquanto você trabalha: uma etapa fica verde quando o modelo tem o que ela pede. Esta página lista todas as etapas como texto, para que você também possa acompanhar por aqui.

O primeiro tutorial usa a WS-1 Weather Station, como os tutoriais de LML. Os outros constroem partes de um carro híbrido, o modelo da demonstração Hybrid Car: tipos de valor e componentes, as portas e interfaces do trem de força, um ciclo de condução, os estados do trem de força, os requisitos do carro, sua verificação, as checagens dos valores do sedã e a linha de produtos. Cada tutorial tem seu próprio projeto inicial, então você pode fazê-los em qualquer ordem. Todos os projetos iniciais e todos os tutoriais concluídos passam na checagem com 0 problemas.

TutorialTempoVocê aprende a
Primeiros passos15 minescrever texto SysML v2, vê-lo como árvore e como visão, desenhar na visão e adicionar um requisito
Definições e atributos20 minescrever enumerações, tipos de valor e definições abstratas, especializar com valores e unidades, e usar o preenchimento automático, Inserir e renomear
Portas e interfaces20 mindefinir portas e interfaces, conjugar portas, conectar parts e desenhar uma interface em uma Visão de interconexão
Ações e fluxos20 minescrever definições de ação e um ciclo de condução com uma bifurcação, fluxos e uma junção, adicionar raias e construir etapas no FFBD
Estados e transições20 minescrever sinais e uma máquina de estados com gatilhos, guardas e ações de estado, e desenhar uma transição temporizada
Requisitos20 minescrever limites, definições e usos de requisitos, satisfazê-los e ver um requisito que não é atendido
Verificação e rastreabilidade15 minescrever um caso de verificação, rastrear uma etapa na Matriz de rastreabilidade e derivar um requisito
Restrições e cálculos20 minescrever restrições e cálculos, vincular valores em uma Visão paramétrica, executar um caso de análise e marcar valores TBD e TBR
Variantes e configurações15 minescrever variações e variantes, uma linha de produtos com uma regra, configurações e uma palavra-chave própria

Como usá-lo

Iniciar um tutorial de SysML v2

  1. Abra Ajuda → Tutoriais na barra lateral ou pressione ⌘K / Ctrl+K e digite tutorial. Fora de um projeto, a página Tutoriais lista primeiro os tutoriais de LML e depois Tutoriais para projetos SysML v2. Dentro de um projeto SysML v2, ela lista apenas os tutoriais de SysML v2.
  2. Clique em Iniciar em um cartão. O Holarch cria o projeto, por exemplo Tutorial: SysML v2 Ports and Interfaces (Hybrid Car), e o abre com o painel de etapas à direita.

O painel de etapas funciona como nos tutoriais de LML: Mostrar destaca o controle de que uma etapa precisa, Ir até lá abre a página, Saiba mais abre o tópico da Ajuda, e Reiniciar…, Marcar como concluído e × funcionam da mesma forma. Consulte Tutoriais.

Digitar o texto de uma etapa

A maioria das etapas dá texto SysML para digitar em Modelo → Editor. A etapa diz onde as linhas entram, por exemplo "antes da última chave de fechamento do pacote". O texto é aplicado ao modelo quando você para de digitar; o status abaixo do editor informa isso, e a etapa fica verde.

  • Digite as linhas como mostradas. A indentação não importa para o modelo; o Editor mantém a sua.
  • Um sublinhado vermelho marca um erro: aponte para ele para ler a mensagem. Um texto com erro de sintaxe permanece como rascunho e não é aplicado até que você o corrija.
  • ⌘Z / Ctrl+Z desfaz a última alteração aplicada.

Dicas

  • Na primeira vez, faça os tutoriais em ordem: cada um explica o texto que usa, e os seguintes pressupõem as ideias anteriores (definições e usos, :> e :>>).
  • Uma etapa que continua aberta geralmente tem um erro de digitação em um nome. Compare seu texto com as linhas da etapa; no SysML v2, os nomes diferenciam maiúsculas de minúsculas.
  • Os tutoriais ensinam a mesma linguagem de Noções básicas de SysML v2; a página Notação textual traz os detalhes.

Primeiros passos

Escreva um primeiro modelo da Weather Station: abra o texto, adicione uma definição de part com um valor e uma unidade, use-a em outra definição, veja o modelo no Navegador e em uma Visão geral, desenhe uma part na visão e veja-a aparecer no texto, adicione um requisito com satisfy e exporte o modelo como arquivo .sysml. As etapas são descritas em Primeiros passos com projetos SysML v2.

Definições e atributos

O projeto inicial tem o pacote Vehicles com uma definição de part, Car.

  1. Abra o pacote. Clique em Modelo → Editor. Toda declaração é uma palavra-chave e um nome, seguidos de um corpo entre chaves ou de um ponto e vírgula.
  2. Escreva uma enumeração. Acima de part def Car {, adicione enum def DriveMode { enum economy; enum normal; enum sport; } (um valor por linha).
  3. Defina um tipo de valor. Abaixo dela, adicione attribute def TirePressure :> ScalarValue;. :> significa especializa.
  4. Escreva uma definição abstrata. Adicione abstract part def Component com um comentário doc e os atributos mass : MassValue, partNumber : String e power : PowerValue. // inicia uma nota que fica apenas no texto.
  5. Deixe o checador encontrar um erro. Adicione part def Battery :> Component com attribute redefines mass = 45 [kg]; e, de propósito, attribute redefines power = 60 [kg];. O checador sublinha a unidade: quilogramas não são uma potência.
  6. Corrija a unidade. Mude-a para 60 [W].
  7. Complete um nome. Na bateria, digite attribute capacity : Ener, aceite EnergyValue na lista de preenchimento com Enter e termine com ;.
  8. Consulte-o na Biblioteca padrão. Clique em Ajustes → Biblioteca padrão na parte inferior da barra lateral e digite EnergyValue na caixa de busca.
  9. Insira uma definição. No Editor, pressione ⌃⇧Space / Ctrl+Shift+Space (ou clique em Inserir ▾) em uma linha vazia, escolha Definição de part e complete part def Engine :> Component com attribute redefines mass = 110 [kg]; e attribute cylinders : Integer;.
  10. Use as definições. Em Car, adicione attribute mode : DriveMode;, part battery : Battery; e part engine : Engine;.
  11. Renomeie em todos os lugares. Coloque o cursor em cylinders, pressione F2 e renomeie para cylinderCount.

Portas e interfaces

O projeto inicial tem os componentes do trem de força com suas portas de torque e de potência, as definições de port TorquePort e PowerPort e as definições de interface Shaft e HighVoltageBus.

  1. Defina uma porta. Acima de port def TorquePort, adicione port def FuelPort com out attribute flowRate : Real; e attribute kind : FuelKind;. out significa que o valor sai da part que possui a porta.
  2. Dê portas às parts. Adicione port fuelOut : FuelPort; a FuelTank e port fuelIn : ~FuelPort; a Engine. ~ conjuga a porta: entrada e saída ficam invertidas.
  3. Defina uma interface. Adicione interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }.
  4. Monte o trem de força. No fim do pacote, adicione part def Powertrain com as parts tank, engine, motor, battery e transmission, uma porta output : TorquePort e bind output = transmission.output;.
  5. Conecte duas parts. No trem de força, adicione interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn;.
  6. Adicione os eixos. Adicione interface engineShaft : Shaft connect engine.output to transmission.engineIn; e interface motorShaft : Shaft connect motor.output to transmission.motorIn;.
  7. Crie uma Visão de interconexão. Clique em Arquitetura → Visões de interconexão e depois em + Novo diagrama. Escolha Powertrain em Mostra e clique em Criar.
  8. Desenhe uma interface. Arraste da alça da porta powerOut da bateria até a porta powerIn do motor e solte em Interface : HighVoltageBus.
  9. Dê nome à interface. Selecione a nova linha e digite hvBus como seu Nome no inspetor.
  10. Veja-a no texto. Clique em Modelo → Editor: a interface está no trem de força, com seu nome, tipo e extremidades.

Ações e fluxos

O projeto inicial tem o pacote VehicleBehavior com os itens Fuel e Torque, as funções ProduceTorque (F.2) e DriveWheels (F.3) e três definições de part.

  1. Defina uma função. Adicione action def <'F.1'> SupplyFuel com in attribute fuelDemand : Real; e out item fuel : Fuel;. O nome curto entre os sinais de menor e maior é o número da função.
  2. Escreva o ciclo de condução. Adicione action def <'F'> DriveCycle com first start then split;, fork split;, then supply;, then produce; e as etapas action supply : SupplyFuel e action produce : ProduceTorque, cada uma com uma duration.
  3. Adicione um fluxo. No ciclo de condução, adicione flow of Fuel from supply.fuel to produce.fuel;.
  4. Junte os ramos. Adicione first supply then ready;, first produce then ready;, join ready;, then action drive : DriveWheels { … }, then done; e flow produce.torque to drive.torque;.
  5. Crie uma Visão de fluxo de ações. Clique em Comportamento → Fluxos de ações e depois em + Novo diagrama, e escolha DriveCycle em Mostra.
  6. Diga quem executa cada etapa. Adicione part def DrivenCar com perform action trip : DriveCycle; e as parts tank, engine e transmission, cada uma com perform trip.supply;, perform trip.produce; ou perform trip.drive;. A visão ganha uma raia por part.
  7. Abra a Análise funcional. Clique em Comportamento → Análise funcional, clique em Escolher… e escolha DriveCycle.
  8. Declare outra ação. Adicione action def EmergencyShutdown;.
  9. Construa etapas no FFBD. Clique em Comportamento → FFBD e depois em + Novo diagrama, e escolha EmergencyShutdown. No painel Adicionar, digite Open Contactors e pressione Enter, depois Cut Fuel.
  10. Veja as etapas no texto. Clique em Modelo → Editor: o FFBD escreveu as etapas e suas sucessões.

Estados e transições

O projeto inicial tem o pacote PowertrainBehavior com uma part def Car vazia.

  1. Defina os sinais. Adicione attribute def StartRequest;, StopRequest, PlugIn e Unplug da mesma forma.
  2. Escreva uma definição de estado. Adicione state def PowertrainStates com in attribute charge : Real;, entry; then off; e os estados off, electric e hybrid.
  3. Adicione transições. Depois de state off;, adicione accept StartRequest if charge > 20 then electric; e accept StartRequest then hybrid;.
  4. Dê ações a um estado. Substitua state electric; por um corpo contendo entry action spinUpMotor;, do action driveElectric; e exit action holdMotor;.
  5. Saia do estado elétrico. Depois dele, adicione if charge < 15 then hybrid; e accept StopRequest then off;; adicione também accept StopRequest then off; depois de state hybrid;.
  6. Adicione um estado com transições nomeadas. Adicione state charging { do action chargeBattery; }, transition plugIn first off accept PlugIn then charging; e transition unplugged first charging accept Unplug then off;.
  7. Crie uma Visão de transição de estados. Clique em Comportamento → Máquinas de estados e depois em + Novo diagrama, e escolha PowertrainStates em Mostra.
  8. Desenhe uma transição temporizada. Arraste da alça de charging até off e solte em Transição. No painel da transição, digite o Nome charged e o Gatilho after 30 [min].
  9. Veja-a no texto. Clique em Modelo → Editor: a transição está escrita como uma transição nomeada.
  10. Faça o carro exibir os estados. Em Car, adicione exhibit state powertrainStates : PowertrainStates;.

Requisitos

O projeto inicial tem o pacote VehicleRequirements com uma pequena cópia do projeto: Battery, Car e o sedan da frota, com massa em ordem de marcha de 1580 kg.

  1. Dê nome aos limites. Adicione attribute maxCurbMass : MassValue = 1650 [kg]; e attribute minBatteryCapacity : EnergyValue = 1.2 [kW*h];.
  2. Escreva uma definição de requisito. Adicione requirement def <'VR-1'> CurbMass com uma declaração doc, subject car : Car;, attribute limit : MassValue; e require constraint { car.curbMass <= limit }.
  3. Insira um requisito. Pressione ⌃⇧Space / Ctrl+Shift+Space em uma linha vazia, escolha Definição de requisito e escreva VR-3 BatteryCapacity com o sujeito battery : Battery e require constraint { battery.capacity >= minBatteryCapacity }.
  4. Aninhe requisitos em uma especificação. Adicione requirement carSpec com subject car : Car; e requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }.
  5. Diga o que os satisfaz. Adicione satisfy carSpec by fleet.sedan; e satisfy requirement batterySpec : BatteryCapacity by fleet.sedan.battery;.
  6. Quebre um requisito. Mude a massa em ordem de marcha do sedã para 1700 [kg]. O Editor marca o satisfy: o sedã não atende mais ao VR-1.1.
  7. Volte a atendê-lo. Pressione ⌘Z / Ctrl+Z ou mude de volta para 1580 [kg].
  8. Veja a tabela de requisitos. Clique em Necessidades e requisitos → Requisitos.
  9. Crie uma Visão de requisitos. Na página Diagramas, clique em + Novo diagrama, escolha Visão de requisitos e carSpec em Mostra.
  10. Cheque as declarações. Clique em Necessidades e requisitos → Qualidade e clique em Checar qualidade.

Verificação e rastreabilidade

O projeto inicial tem o requisito de massa em ordem de marcha e a especificação do carro, um ciclo de condução com as etapas cruise e brake, VR-6 batteryMassLimit e VR-7 stopFromCruise.

  1. Escreva um caso de verificação. Adicione verification def <'VC-1'> CurbMassTest com subject car : Car;, objective massObjective { verify carSpec.sedanMass; } e return verdict : Boolean = car.curbMass <= maxCurbMass;.
  2. Aplique-o ao sedã. Adicione verification <'VC-1.1'> sedanWeighing : CurbMassTest { subject car = fleet.sedan; }.
  3. Abra os casos de verificação. Clique em Verificação → Casos de verificação. Etapas, resultados e status são dados do Holarch ao lado do modelo. Na linha de Sedan Weighing, clique em + Etapas, depois em + Adicionar etapa, digite Weigh the car em Ação e clique em Aplicar. Em seguida, clique em Aprovados nos botões de status.
  4. Leia a RVTM. Clique em Verificação → RVTM.
  5. Rastreie uma etapa até um requisito. Clique em Verificação → Matriz de rastreabilidade, mostre os requisitos como linhas e as ações como colunas, clique na célula de stopFromCruise e brake e escolha satisfied by.
  6. Derive um requisito. Adicione private import RequirementDerivation::*; e connection batteryMassDerivation : Derivation connect carSpec.sedanMass to batteryMassLimit;.
  7. Execute as checagens do modelo. Clique em Verificação → Checagens do modelo.

Restrições e cálculos

O projeto inicial tem o pacote VehicleAnalysis com o motor, a bateria, o carro e os valores do sedã, e as metas maxCurbMass e minPowerToWeight.

  1. Escreva uma definição de restrição. Adicione constraint def MassLimit com in mass : MassValue;, in limit : MassValue; e a expressão mass <= limit.
  2. Escreva um cálculo. Adicione calc def PowerToWeight com os parâmetros power e mass e return ratio = power / mass;.
  3. Vincule os valores do sedã. Adicione constraint sedanMassCheck : MassLimit { in mass = fleet.sedan.curbMass; in limit = maxCurbMass; }.
  4. Crie uma Visão paramétrica. Na página Diagramas, clique em + Novo diagrama, escolha Visão paramétrica e VehicleAnalysis em Mostra. A checagem passa: 1580 kg está dentro de 1650 kg.
  5. Faça a checagem falhar. Mude a massa em ordem de marcha do sedã para 1700 [kg]; a visão mostra a checagem falhando.
  6. Faça-a passar de novo. Desfaça ou mude de volta para 1580 [kg]. Resolver tudo checa todas as restrições de novo.
  7. Execute um caso de análise. Adicione analysis def PowerToWeightAnalysis com um objetivo que exige ratio >= minPowerToWeight, e analysis sedanPowerToWeight : PowerToWeightAnalysis { subject car = fleet.sedan; }.
  8. Marque valores em aberto. Adicione private import HolarchMetadata::*; e o requisito VR-5 ChargeTime com #TBR no seu limite de tempo e @TBD com um responsável, um prazo e uma justificativa na potência do carregador. TBD e TBR vêm da biblioteca HolarchMetadata do Holarch, não da biblioteca padrão do SysML v2; eles especializam os metadados padrão StatusInfo.
  9. Abra o registro de TBD/TBR. Clique em Necessidades e requisitos → TBD/TBR. O tempo de carga aparece com o responsável e o prazo dos seus metadados @TBD. O registro é somente leitura: altere o responsável ou a data nos metadados, no Editor.
  10. Totalize a massa. Clique em Arquitetura → Orçamentos e TPMs e selecione a part raiz sedan.

Variantes e configurações

O projeto inicial tem Component, Battery, Controller, Car e Powertrain.

  1. Importe o pacote de variabilidade. Adicione private import HolarchVariability::*;.
  2. Escreva uma variação. Em uma linha vazia, pressione ⌃⇧Space / Ctrl+Shift+Space (ou clique em Inserir ▾), escolha Variação e complete variation part def BatteryPack :> Battery com as variantes standardPack (1.4 kWh) e largePack (12 kWh, 120 kg).
  3. Escreva a linha de produtos. Adicione part def CarLine :> Car com part pack : BatteryPack;, uma variation part charger com as variantes noCharger e wallbox, e assert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack }.
  4. Inicie uma configuração. Escolha Inserir ▾ → Configuração e preencha part plugInHybrid : CarLine { @HolarchConfiguration; }. O Editor aponta os pontos de variação ainda em aberto.
  5. Escolha as variantes. Em plugInHybrid, escolha Inserir ▾ → Escolha de variante para cada ponto e preencha part :>> pack = BatteryPack::largePack; e part :>> charger = charger::wallbox;.
  6. Adicione uma segunda configuração. Adicione selfChargingHybrid da mesma forma, com o pack padrão e sem carregador.
  7. Defina uma palavra-chave própria. Adicione metadata def <safetyCritical> SafetyCritical.
  8. Use a palavra-chave. Em Powertrain, escreva #safetyCritical part controller : Controller;.
  9. Veja a linha de produtos. Crie uma Visão geral de Vehicles: o pack de bateria aparece marcado como variação.

Projetos de tutorial

Os projetos de tutorial de SysML v2 seguem as mesmas regras dos outros projetos de tutorial: não contam para os projetos ativos do seu plano, comportam até 300 itens, e você pode ter um por tutorial. Consulte Tutoriais.

SysML® e OMG® são marcas registradas da Object Management Group, Inc. nos Estados Unidos e em outros países.