Holarch

Guia · SysML v2

Tutorial de SysML v2: modele o sistema de potência de um CubeSat na notação textual

Ouvir este guia 24 min

Este tutorial de SysML v2 constrói um modelo pequeno e completo passo a passo: o sistema de energia elétrica do CubeSat EO-1, com suas partes, grandezas e unidades, portas e conexões, um ciclo de sol e eclipse, requisitos que uma ferramenta pode checar, um caso de verificação e visões. Toda listagem nesta página é texto SysML v2 checado com um motor de linguagem, e cada etapa principal mostra o diagrama que o texto produz.

Nesta página
  1. O que você vai construir
  2. Primeira ideia: definições e usages
  3. Etapa 1: um pacote e seus imports
  4. Etapa 2: definições de partes e atributos com unidades
  5. Etapa 3: a montagem, com valores
  6. Etapa 4: portas, interfaces e conexões
  7. Etapa 5: comportamento com ações e flows
  8. Etapa 6: alocar o comportamento à estrutura
  9. Etapa 7: requisitos com restrições
  10. Etapa 8: um caso de verificação
  11. Etapa 9: visões e diagramas
  12. O modelo completo
  13. Como as listagens foram checadas
  14. Experimente no Holarch
  15. Para onde ir a seguir

O que você vai construir

O EO-1 é um CubeSat 6U de observação da Terra em uma órbita heliossíncrona de 500 km. Ele é o exemplo comum destes guias; o projeto de exemplo de MBSE acompanha a espaçonave inteira, das necessidades à verificação. Este tutorial pega um subsistema, o sistema de energia elétrica (EPS), e o escreve em texto SysML v2.

O EPS tem três partes. Dois painéis solares desdobráveis transformam luz solar em energia. Um pacote de baterias de íons de lítio armazena energia para o eclipse. Uma unidade de distribuição de energia (PDU) rastreia o ponto de potência máxima dos painéis, carrega a bateria e regula o barramento de 12 V. Duas cargas nesse barramento também estão no modelo: a câmera da carga útil e o transmissor em banda S.

Os números vêm do modelo EO-1:

ItemValorOnde é usado
Painéis solares: área das células, eficiência das células, potência de pico0,2 m², 0,295, 75,4 WEtapa 3
Eficiência do caminho de energia; fração iluminada da órbita0.6; 0.62Etapa 3
Pacote de baterias: capacidade; energia consumida no eclipse de 36 minutos77 Wh; 18,5 WhEtapa 3
Massa: painéis, bateria, PDU0,45 kg, 0,62 kg, 0,28 kgEtapa 3
Consumo médio por órbita: câmera, transmissor em banda S6,2 W, 3,4 WEtapa 3
Requisito 3.1 Orbit Average Powerpelo menos 28 W no fim de vidaEtapa 7
Requisito 3.2 Battery Capacitypelo menos 77 Wh no início de vidaEtapas 7 e 8
Requisito 3.3 Depth of Dischargeno máximo 30% por órbitaEtapa 7
Caso de teste TC-07 Battery Capacity Testdescarga a C/2 em uma câmara a 20 °CEtapa 8

O modelo tem três pacotes:

PacoteContémEtapas
CubeSatEPSPortas, partes, um cálculo, as montagens com seus valores e o comportamento1 a 6
CubeSatEPSRequirementsRequisitos 3.1 a 3.3 e o caso de verificação TC-077 e 8
CubeSatEPSViewsVisões que selecionam partes do modelo para diagramas9

Nenhuma ferramenta específica é necessária para acompanhar: o texto é SysML v2 puro e carrega em qualquer ferramenta que leia a notação textual. O modelo completo está no fim da página e para download, e a última seção mostra como carregá-lo no Holarch.

Primeira ideia: definições e usages

A SysML v2 separa uma definição de um usage. Uma definição diz o que um tipo de coisa é: part def BatteryPack descreve todo pacote de baterias deste projeto, com seus atributos e portas. Um usage é uma dessas coisas em um contexto: part battery : BatteryPack dentro do sistema de energia é a única bateria do EPS do EO-1, conectada à sua PDU.

O mesmo par percorre a linguagem inteira: attribute def e attribute, port def e port, action def e action, requirement def e requirement. Uma palavra-chave seguida de def declara um tipo; a mesma palavra-chave sem def usa um. Valores específicos normalmente ficam nos usages, porque é no usage que uma decisão de projeto é tomada.

Quem conhece a SysML v1 pode comparar uma definição com um bloco e um usage com uma part property. Na SysML v2 a ideia vale para todo tipo de elemento, e os usages se aninham e refinam uns aos outros em qualquer profundidade. SysML v1 vs SysML v2 compara as duas linguagens construção por construção.

Etapa 1: um pacote e seus imports

Um pacote é um namespace: ele agrupa elementos e lhes dá nomes qualificados como CubeSatEPS::BatteryPack. Comece com um pacote vazio e os imports de biblioteca de que ele precisa.

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 /* … */ anexa documentação ao pacote. Ao contrário de um comentário //, ela faz parte do modelo, e as ferramentas a mostram com o elemento.
  • ScalarValues fornece tipos básicos como Real, Integer, Boolean e String.
  • ISQ fornece tipos de grandeza do Sistema Internacional de Grandezas, como MassValue, PowerValue e EnergyValue.
  • SI fornece unidades SI como kg, V, W e h.
  • private mantém os nomes importados dentro deste pacote, então um pacote que importa CubeSatEPS não os recebe por meio dele.

Sem os imports, um nome como MassValue não pode ser resolvido, e um verificador o relata como desconhecido.

Etapa 2: definições de partes e atributos com unidades

Cada componente recebe uma definição de parte com atributos tipados. Tipar um atributo por uma grandeza em vez de por Real registra o que ele mede: uma massa, uma potência, uma energia. Uma ferramenta pode então checar a consistência das dimensões de cada valor e de cada expressão.

  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;
  }

Essas linhas vão dentro das chaves do pacote. As duas eficiências ficam como Real simples porque são razões sem unidade.

Ainda não há valores. Uma definição descreve todo pacote de baterias desse tipo; os números vêm com a própria bateria do EO-1 na próxima etapa.

Etapa 3: a montagem, com valores

O sistema de energia também é uma definição de parte, feita de part usages: os painéis solares, a bateria e a PDU. Cada usage dá valores aos atributos que herda de sua definição. Um cálculo reutilizável transforma a potência de pico do painel na potência média por órbita contra a qual o requisito 3.1 é escrito.

  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 : BatteryPack declara um usage chamado battery, tipado pela definição BatteryPack.
  • attribute redefines capacity = 77 [W*h] dá um valor ao capacity herdado. A forma curta :>> capacity = 77 [W*h]; significa o mesmo. Sem redefines, a linha declararia um segundo atributo que só compartilha o nome, e o capacity herdado continuaria sem valor.
  • 77 [W*h] é uma grandeza: um número e uma unidade. As unidades se combinam com *, / e ^, então watts-hora são W*h e metros quadrados m^2.
  • calc def OrbitAverage é um cálculo com entradas e um resultado tipado. OrbitAverage(…) o chama com os valores dos painéis, então a fórmula é escrita uma vez e todo uso dela acompanha uma mudança.
  • depthOfDischarge divide uma energia por uma energia. As unidades se cancelam, e o resultado é uma razão simples.
  • Spacecraft põe o sistema de energia ao lado das duas cargas que este tutorial acompanha. O resto do EO-1 (controle de atitude, o computador de bordo, a estrutura) fica de fora para manter o modelo curto.

Os valores não são só armazenados; uma ferramenta os avalia. Com os números acima:

AtributoExpressãoResultado
orbitAveragePower75,4 W × 0,62 × 0,628,05 W
depthOfDischarge18,5 Wh ÷ 77 Wh0.24
totalMass0,45 kg + 0,62 kg + 0,28 kg1,35 kg

A própria potência de pico tem uma origem que você pode checar: 0,2 m² de células com eficiência de 0,295 sob 1361 W/m² de luz solar, com ângulo de incidência de 0,35 rad (cos 0,35 = 0,939), dão 75,4 W. A fração iluminada decorre da órbita: uma órbita de 500 km leva cerca de 94,6 minutos, 36 deles em eclipse, o que deixa 0,62 da órbita sob luz solar.

Como todo valor carrega uma unidade, um erro de dimensão aparece assim que o modelo é checado. Um erro comum em modelos de energia é escrever a capacidade de uma bateria em watts em vez de watts-hora:

package UnitCheck {
  private import ISQ::*;
  private import SI::*;

  part def BatteryPack {
    attribute capacity : EnergyValue;
  }

  part battery : BatteryPack {
    attribute redefines capacity = 77 [W];
  }
}

Um verificador que avalia unidades rejeita o valor: uma potência não é uma energia. No Holarch, o Editor marca a linha com um erro de dimensão. Em uma planilha, o mesmo deslize passaria despercebido para a profundidade de descarga.

Etapa 4: portas, interfaces e conexões

Portas são os pontos em que uma parte encontra o seu entorno. Uma definição de porta lista o que cruza a fronteira, cada feature com uma direção: out para o que o dono envia, in para o que ele recebe.

  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;
  }

O lado receptor usa a mesma definição de porta, conjugada com ~. ~BusPowerPort é a imagem espelhada de BusPowerPort: todo out vira in. Uma só definição de porta descreve as duas extremidades de um vínculo, então as duas extremidades não podem se desencontrar.

Uma definição de interface descreve um tipo de conexão com extremidades tipadas. BusLink conecta o barramento de 12 V, que envia energia, a uma carga que a recebe. Ela faz o papel da 12 V Power Interface (IFB-1) do EO-1.

Agora acrescente as portas às partes e conecte-as. As linhas de comentário representam as linhas das etapas anteriores.

  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 é uma conexão simples: o chicote dos painéis (a interface IF-20 do EO-1). battery.cellsOut para pdu.batteryIn é o chicote da bateria (IF-21).
  • bind bus = pdu.busOut declara que a própria porta bus do sistema de energia e a saída da PDU são a mesma coisa. É assim que uma parte expõe uma porta interna na sua fronteira: as cargas se conectam ao EPS, não ao seu interior.
  • interface payloadPower : BusLink connect … to … conecta duas portas por uma interface tipada, então a conexão carrega o significado de BusLink. As duas interfaces de barramento são a Payload Power Line (IF-01) e a Radio Power Line (IF-04) do EO-1.

Uma Visão de interconexão desenha o sistema de energia a partir deste texto: cada parte com suas portas na borda, as portas conjugadas marcadas com ~ e a porta bus ligada na moldura.

A visão epsConnections da etapa 9: as partes do EPS, suas portas e conexões, desenhadas a partir do texto.

A consequência de engenharia: a lista de interfaces do subsistema agora é uma consulta, não uma tabela separada. Toda conexão nomeia as duas extremidades e, quando é tipada, o que a cruza. Essa é a matéria-prima de um documento de controle de interfaces, e ela muda quando o modelo muda.

Um erro comum é dar às duas extremidades a mesma porta, sem conjugação. As duas extremidades então enviam e nenhuma recebe:

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;
  }
}

O texto é analisado sem erros, mas um verificador que compara direções avisa que as duas extremidades da conexão enviam voltage. Conjugar a extremidade receptora, port powerIn : ~BusPowerPort;, resolve o problema.

Etapa 5: comportamento com ações e flows

A estrutura diz o que o sistema é; o comportamento diz o que ele faz. Uma definição de ação descreve um comportamento com parâmetros de entrada e saída. Definições de item descrevem as coisas que fluem, aqui a luz solar e a energia elétrica em suas diferentes formas.

  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;
  }
  • Os parâmetros in e out são as entradas e saídas de uma ação.
  • Dentro de RunPowerCycle, quatro action usages são as etapas de uma órbita: sob luz solar os painéis coletam energia e a PDU carrega a bateria; em eclipse a bateria devolve a energia e a PDU alimenta o barramento com ela.
  • flow collect.power to charge.power diz que a saída de uma etapa é a entrada da próxima.
  • first collect then charge é uma succession: uma etapa termina antes de a próxima começar. Os flows dizem o que se move; as successions dizem em que ordem. start e done são o começo e o fim da ação que os contém.

As etapas correspondem às funções de energia do EO-1: F3.1 Convert Sunlight to Power, F3.2 Store Battery Energy e F3.3 Regulate Bus Power. Derivar essas funções dos requisitos e ordená-las é o assunto da análise funcional; as definições de ação são onde esse trabalho chega na SysML v2.

A Action Flow View abaixo é desenhada a partir deste texto junto com a alocação da etapa 6, que dá a cada etapa uma raia.

A visão powerCycleFlow: as etapas sob luz solar, depois as etapas em eclipse, com a energia que flui entre elas.

A consequência de engenharia: a bateria está no caminho de cada watt que o barramento usa em eclipse. O que a bateria armazena sob luz solar precisa cobrir a carga do eclipse, que é exatamente o que os requisitos 3.2 e 3.3 restringem na etapa 7.

Etapa 6: alocar o comportamento à estrutura

Até aqui, o comportamento não pertence a nenhum componente. Uma declaração perform diz qual parte executa qual etapa:

  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 é um usage de Spacecraft no topo do pacote: a espaçonave deste projeto. Seu sistema de energia executa RunPowerCycle, e cada parte do EPS executa suas etapas. part redefines eps refina o sistema de energia herdado de Spacecraft em vez de acrescentar um segundo. A PDU executa duas etapas, carregar sob luz solar e alimentar o barramento em eclipse, porque uma só unidade faz os dois trabalhos.

Essa é a forma textual de uma alocação funcional. A partir dela, uma ferramenta pode listar as funções que cada componente executa, ou desenhar o fluxo de ações com uma raia por parte, como na visão acima.

Etapa 7: requisitos com restrições

Os requisitos vão para um pacote próprio, que importa o projeto. Na SysML v2, um requisito é uma restrição sobre um subject: o texto doc diz em palavras o que é necessário, e um require constraint diz o mesmo de uma forma que uma ferramenta pode avaliar. Os três requisitos são os requisitos 3.1, 3.2 e 3.3 do EO-1, com seus próprios ids e redação.

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'> é um nome curto: o identificador que os engenheiros citam nas revisões. Outros elementos do modelo se referem ao nome completo, OrbitAveragePower.
  • subject eps : ElectricalPowerSystem nomeia aquilo de que o requisito trata.
  • require constraint { eps.orbitAveragePower >= required } é a condição que deve valer. O limite é um parâmetro, então a mesma definição serve para uma espaçonave com outra necessidade de energia.
  • powerSpec reúne os requisitos do EO-1 e define os limites: 28 W, 77 Wh e 0.3.
  • satisfy powerSpec by eo1.eps afirma que o sistema de energia do EO-1 atende à especificação.

Mantenha o texto doc e a restrição dizendo a mesma coisa. Os revisores leem o texto; as ferramentas avaliam a restrição. Os vínculos do requisito com o projeto e com os testes são a base da rastreabilidade de requisitos.

Uma Visão de requisitos mostra a especificação como uma árvore, com a parte que a satisfaz e o caso de verificação da etapa 8:

A visão requirementTree: os requisitos 3.1 a 3.3, o que os satisfaz e o que os verifica.

Como as restrições podem ser avaliadas, um verificador faz mais que desenhar a linha satisfy: ele testa a afirmação contra os valores da etapa 3. Com o modelo como está escrito, as três valem: 28,05 W contra 28 W, 77 Wh contra 77 Wh e uma profundidade de descarga de 0,24 contra 0,3.

A primeira dessas margens é estreita. Reduza a eficiência do caminho de energia de 0,6 para 0,59, uma mudança de menos de dois por cento, e a potência média por órbita cai para 27,58 W. O verificador então relata que o requisito 3.1 não é mais atendido, com os valores que o quebraram:

A checagem do requisito depois que um valor de projeto mudou: o aviso nomeia o requisito, a parte, a restrição e os valores.

A consequência de engenharia: o requisito 3.1 já carrega a margem do sistema (sua justificativa no EO-1 é uma carga de 24 W no modo de imageamento mais 15%), mas os painéis atendem ao próprio 3.1 com só 0,05 W de folga. Qualquer perda que não estava na estimativa, como uma degradação mais rápida das células, exige mais área de painel ou uma carga menor. Um modelo que checa o requisito a cada mudança mostra isso quando o número se move, não na próxima revisão. Para ver qual a probabilidade de a margem se manter quando as entradas são incertas em vez de fixas, veja Análise de Monte Carlo em engenharia de sistemas.

Etapa 8: um caso de verificação

Um relacionamento satisfy é uma afirmação, e a checagem da etapa 7 só a testa contra os números do próprio modelo. Um caso de verificação diz como a afirmação é checada no hardware real, por teste, inspeção, análise ou demonstração. O EO-1 verifica a capacidade da bateria com o caso de teste 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; } nomeia o requisito que este caso verifica. Esses vínculos são a base de uma matriz de verificação: cada requisito contra os casos que o verificam.
  • return verdict é o resultado: aqui, se a capacidade medida chega aos 77 Wh do requisito 3.2.
  • batteryTest é um usage do caso para o sistema de energia do EO-1: o teste planejado, com seu subject ligado a eo1.eps.

Satisfação e verificação são mantidas separadas de propósito. A satisfação diz qual elemento do projeto responde a um requisito; a verificação diz como você sabe que ele responde. No projeto EO-1, o TC-07 foi aprovado com 78,3 Wh medidos. Os requisitos 3.1 e 3.3 ainda precisam de casos próprios, e uma matriz de verificação de requisitos é onde essa lacuna aparece.

Etapa 9: visões e diagramas

Na SysML v2, um diagrama não é um desenho separado. Uma visão é um elemento do modelo que declara o que mostrar (expose) e quais tipos de elemento incluir (filter). Uma ferramenta renderiza a visão e guarda seu layout; o conteúdo sempre vem do modelo. As três capturas de tela acima são essas três visões.

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::**;
  }
}

A biblioteca padrão define os tipos de visão comuns:

VisãoMostraNeste modelo
Visão geralQuaisquer elementos e seus relacionamentos, como caixas e linhasrequirementTree
Visão de interconexãoAs partes de uma montagem com suas portas e conexõesepsConnections
Action Flow ViewAs etapas de um comportamento, sua ordem e o que flui entre elaspowerCycleFlow
Visão de transição de estadosOs estados e as transições entre elesNenhum
Visão de sequênciaMensagens entre partes ao longo do tempoNenhum
Visão em gradeElementos ou relacionamentos como tabela ou matrizNenhum

requirementTree é uma Visão geral cujo filtro mantém só requisitos e relacionamentos satisfy; as ferramentas que conhecem os tipos de diagrama da SysML v1, entre elas o Holarch, mostram uma visão assim como um diagrama de requisitos. Como uma visão faz parte do modelo, renomear a bateria muda todos os diagramas que a mostram, e um revisor pode ler no texto exatamente o que um diagrama inclui.

O modelo completo

Os três pacotes juntos. Baixe o modelo do sistema de energia do EO-1 (cubesat-eps.sysml), ou copie o texto abaixo; os dois são iguais.

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::**;
  }
}

Como as listagens foram checadas

Toda listagem nesta página foi analisada e checada com o Holarch Language Engine, o motor por trás do Editor SysML v2 do Holarch, com a biblioteca padrão da SysML v2 carregada. As checagens resolvem cada nome, comparam unidades e dimensões, comparam as direções das portas entre conexões e avaliam as restrições dos requisitos contra os valores que as satisfazem.

  • O modelo completo e a listagem independente não dão erros nem avisos.
  • Cada trecho aparece linha por linha, em ordem, no modelo completo.
  • As duas listagens que mostram erros dão exatamente o erro e o aviso descritos ao lado delas.
  • O modelo completo com uma eficiência do caminho de energia de 0,59 dá exatamente um aviso: requisito 3.1 não atendido.

Para saber quais construções SysML v2 o motor suporta e suas lacunas conhecidas, veja Cobertura da linguagem SysML v2. Para comparar ferramentas nos mesmos pontos, veja o que checar em uma ferramenta SysML v2; este modelo é pequeno o bastante para servir como arquivo de teste.

Experimente no Holarch

  1. Baixe cubesat-eps.sysml, ou salve o modelo completo com esse nome.
  2. Abra Modelo → Importar e exportar, escolha Em um projeto SysML v2 novo e solte o arquivo. Veja importar arquivos em um projeto novo.
  3. Abra Modelo → Editor para ler e mudar o texto. Cada pacote é um documento. Veja o Editor.
  4. Abra a lista Diagramas e clique em epsConnections, powerCycleFlow ou requirementTree. Veja abrir uma visão.
  5. Em CubeSatEPS, mude pathEfficiency = 0.6 para 0.59 e faça uma pausa. O Editor mostra o aviso na linha satisfy em CubeSatEPSRequirements. Desfaça com ⌘Z / Ctrl+Z.

Para digitar o modelo em vez disso, crie um projeto SysML v2, clique em + Novo package no Editor e escreva as etapas em ordem; o texto que é analisado sem erros é aplicado após uma breve pausa. Veja primeiros passos com projetos SysML v2. A espaçonave EO-1 inteira, com seus documentos, testes e orçamentos, é a demonstração CubeSat: Arquivos de projeto ▾ → Novo projeto de demonstração.

Para onde ir a seguir