Guía · SysML v2
Tutorial de SysML v2: modelar el sistema de potencia de un CubeSat en la notación textual
Escuchar esta guía (audio en inglés) 24 min
Este tutorial de SysML v2 construye paso a paso un modelo pequeño y completo: el sistema de potencia eléctrica del CubeSat EO-1, con sus partes, magnitudes y unidades, puertos y conexiones, un ciclo de luz solar y eclipse, requisitos que una herramienta puede comprobar, un caso de verificación y vistas. Cada listado de esta página es texto SysML v2 comprobado con un motor de lenguaje, y cada paso clave muestra el diagrama que produce el texto.
En esta página
- Qué va a construir
- Primera idea: definiciones y usos
- Paso 1: un paquete y sus importaciones
- Paso 2: definiciones de parte y atributos con unidades
- Paso 3: el conjunto, con valores
- Paso 4: puertos, interfaces y conexiones
- Paso 5: comportamiento con acciones y flujos
- Paso 6: asignar el comportamiento a la estructura
- Paso 7: requisitos con restricciones
- Paso 8: un caso de verificación
- Paso 9: vistas y diagramas
- El modelo completo
- Cómo se comprobaron los listados
- Pruébelo en Holarch
- Siguientes pasos
Qué va a construir
EO-1 es un CubeSat 6U de observación de la Tierra en una órbita heliosíncrona de 500 km. Es el ejemplo común de estas guías; el proyecto de ejemplo de MBSE sigue la nave completa desde las necesidades hasta la verificación. Este tutorial toma un subsistema, el sistema de potencia eléctrica (EPS), y lo escribe en texto SysML v2.
El EPS tiene tres partes. Dos paneles solares desplegables convierten la luz solar en potencia. Un paquete de baterías de iones de litio almacena energía para el eclipse. Una unidad de distribución de potencia (PDU) sigue el punto de máxima potencia de los paneles, carga la batería y regula el bus de 12 V. En el modelo también hay dos cargas de ese bus: la cámara de la carga útil y el transmisor de banda S.
Las cifras proceden del modelo de EO-1:
| Elemento | Valor | Dónde se usa |
|---|---|---|
| Paneles solares: superficie de células, eficiencia de las células, potencia de pico | 0,2 m², 0,295, 75,4 W | Paso 3 |
| Rendimiento de la cadena de potencia; fracción iluminada de la órbita | 0.6; 0.62 | Paso 3 |
| Paquete de baterías: capacidad; energía consumida en el eclipse de 36 minutos | 77 Wh; 18,5 Wh | Paso 3 |
| Masa: paneles, batería, PDU | 0,45 kg, 0,62 kg, 0,28 kg | Paso 3 |
| Consumo medio orbital: cámara, transmisor de banda S | 6,2 W, 3,4 W | Paso 3 |
| Requisito 3.1 Orbit Average Power | al menos 28 W al final de la vida útil | Paso 7 |
| Requisito 3.2 Battery Capacity | al menos 77 Wh al principio de la vida útil | Pasos 7 y 8 |
| Requisito 3.3 Depth of Discharge | como máximo un 30 % por órbita | Paso 7 |
| Caso de prueba TC-07 Battery Capacity Test | descarga a C/2 en una cámara a 20 °C | Paso 8 |
El modelo tiene tres paquetes:
| Paquete | Contiene | Pasos |
|---|---|---|
CubeSatEPS | Puertos, partes, un cálculo, los conjuntos con sus valores y el comportamiento | 1 a 6 |
CubeSatEPSRequirements | Los requisitos 3.1 a 3.3 y el caso de verificación TC-07 | 7 y 8 |
CubeSatEPSViews | Vistas que seleccionan partes del modelo para los diagramas | 9 |
No hace falta ninguna herramienta concreta para seguir el tutorial: el texto es SysML v2 sin más y se carga en cualquier herramienta que lea la notación textual. El modelo completo está al final de la página y como descarga, y la última sección muestra cómo cargarlo en Holarch.
Primera idea: definiciones y usos
SysML v2 separa una definición de un uso. Una definición dice qué es un tipo de cosa: part def BatteryPack describe todos los paquetes de baterías de este diseño, con sus atributos y puertos. Un uso es una de esas cosas en un contexto: part battery : BatteryPack dentro del sistema de potencia es la única batería del EPS de EO-1, conectada a su PDU.
La misma pareja recorre todo el lenguaje: attribute def y attribute, port def y port, action def y action, requirement def y requirement. Una palabra clave seguida de def declara un tipo; la misma palabra clave sin def usa uno. Los valores concretos suelen ir en los usos, porque un uso es donde se toma una decisión de diseño.
Quien conozca SysML v1 puede comparar una definición con un bloque y un uso con una propiedad de parte. En SysML v2 la idea se aplica a todos los tipos de elemento, y los usos se anidan y se refinan unos a otros a cualquier profundidad. SysML v1 frente a SysML v2 compara los dos lenguajes construcción por construcción.
Paso 1: un paquete y sus importaciones
Un paquete es un espacio de nombres: agrupa elementos y les da nombres cualificados como CubeSatEPS::BatteryPack. Empiece con un paquete vacío y las importaciones de biblioteca que necesita.
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 /* … */añade documentación al paquete. A diferencia de un comentario//, forma parte del modelo, y las herramientas la muestran con el elemento.ScalarValuesproporciona tipos básicos comoReal,Integer,BooleanyString.ISQproporciona tipos de magnitud del Sistema Internacional de Magnitudes, comoMassValue,PowerValueyEnergyValue.SIproporciona unidades SI comokg,V,Wyh.privatemantiene los nombres importados dentro de este paquete, de modo que un paquete que importeCubeSatEPSno los recibe a través de él.
Sin las importaciones, un nombre como MassValue no puede resolverse, y un comprobador lo notifica como desconocido.
Paso 2: definiciones de parte y atributos con unidades
Cada componente recibe una definición de parte con atributos tipados. Tipar un atributo con una magnitud en lugar de con Real registra lo que mide: una masa, una potencia, una energía. Así una herramienta puede comprobar que cada valor y cada expresión tienen dimensiones coherentes.
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;
}
Estas líneas van dentro de las llaves del paquete. Las dos eficiencias siguen siendo Real porque son cocientes sin unidad.
Todavía no hay valores. Una definición describe todos los paquetes de baterías de este tipo; las cifras llegan con la batería propia de EO-1 en el paso siguiente.
Paso 3: el conjunto, con valores
El sistema de potencia también es una definición de parte, formada por usos de parte: los paneles solares, la batería y la PDU. Cada uso da valores a los atributos que hereda de su definición. Un cálculo reutilizable convierte la potencia de pico del panel en la potencia media orbital frente a la que está redactado el 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 : BatteryPackdeclara un uso llamadobattery, tipado por la definiciónBatteryPack.attribute redefines capacity = 77 [W*h]da un valor alcapacityheredado. La forma abreviada:>> capacity = 77 [W*h];significa lo mismo. Sinredefines, la línea declararía un segundo atributo que solo comparte el nombre, y elcapacityheredado seguiría sin valor.77 [W*h]es una magnitud: un número y una unidad. Las unidades se combinan con*,/y^, así que los vatios hora sonW*hy los metros cuadradosm^2.calc def OrbitAveragees un cálculo con entradas y un resultado tipado.OrbitAverage(…)lo invoca con los valores de los paneles, así que la fórmula se escribe una sola vez y cada uso suyo sigue cualquier cambio.depthOfDischargedivide una energía entre una energía. Las unidades se anulan, y el resultado es un simple cociente.Spacecraftpone el sistema de potencia junto a las dos cargas que sigue este tutorial. El resto de EO-1 (control de actitud, ordenador de vuelo, estructura) se deja fuera para que el modelo sea breve.
Los valores no solo se almacenan; una herramienta los evalúa. Con las cifras anteriores:
| Atributo | Expresión | Resultado |
|---|---|---|
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 propia potencia de pico tiene una fuente que se puede comprobar: 0,2 m² de células con una eficiencia de 0,295 bajo 1361 W/m² de luz solar, con un ángulo de incidencia de 0,35 rad (cos 0,35 = 0,939), dan 75,4 W. La fracción iluminada se deduce de la órbita: una órbita de 500 km dura unos 94,6 minutos, 36 de ellos en eclipse, lo que deja 0,62 de la órbita a la luz del sol.
Como cada valor lleva una unidad, un error de dimensión aparece en cuanto se comprueba el modelo. Uno habitual en los modelos de potencia es escribir la capacidad de una batería en vatios en lugar de en vatios hora:
package UnitCheck {
private import ISQ::*;
private import SI::*;
part def BatteryPack {
attribute capacity : EnergyValue;
}
part battery : BatteryPack {
attribute redefines capacity = 77 [W];
}
}
Un comprobador que evalúa unidades rechaza el valor: una potencia no es una energía. En Holarch, el Editor marca la línea con un error de dimensión. En una hoja de cálculo, el mismo descuido pasaría desapercibido hasta la profundidad de descarga.
Paso 4: puertos, interfaces y conexiones
Los puertos son los puntos en los que una parte se encuentra con su entorno. Una definición de puerto enumera lo que cruza el límite, cada característica con una dirección: out para lo que envía el propietario, in para lo que recibe.
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;
}
El lado receptor usa la misma definición de puerto, conjugada con ~. ~BusPowerPort es la imagen especular de BusPowerPort: cada out pasa a ser in. Una sola definición de puerto describe ambos extremos de un enlace, así que los dos extremos no pueden divergir.
Una definición de interfaz describe un tipo de conexión con extremos tipados. BusLink conecta el bus de 12 V, que envía potencia, con una carga que la recibe. Desempeña el papel de la interfaz 12 V Power Interface (IFB-1) de EO-1.
Ahora añada los puertos a las partes y conéctelos. Las líneas de comentario representan las líneas de los pasos 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.arrayInes una conexión simple: el mazo de cables de los paneles (la interfaz IF-20 de EO-1).battery.cellsOutapdu.batteryInes el mazo de cables de la batería (IF-21).bind bus = pdu.busOutindica que el puertobuspropio del sistema de potencia y la salida de la PDU son lo mismo. Así es como una parte expone un puerto interno en su límite: las cargas se conectan al EPS, no a su interior.interface payloadPower : BusLink connect … to …conecta dos puertos a través de una interfaz tipada, de modo que la conexión lleva el significado deBusLink. Las dos interfaces del bus son Payload Power Line (IF-01) y Radio Power Line (IF-04) de EO-1.
Una vista de interconexión dibuja el sistema de potencia a partir de este texto: cada parte con sus puertos en el borde, los puertos conjugados marcados con ~ y el puerto enlazado bus en el marco.
epsConnections del paso 9: las partes del EPS, sus puertos y conexiones, dibujados a partir del texto.La consecuencia de ingeniería: la lista de interfaces del subsistema es ahora una consulta, no una tabla aparte. Cada conexión nombra ambos extremos y, cuando está tipada, lo que la cruza. Esa es la materia prima de un documento de control de interfaces, y cambia cuando cambia el modelo.
Un error habitual es dar a ambos extremos el mismo puerto sin conjugar. Entonces ambos extremos envían y ninguno recibe:
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;
}
}
El texto se analiza, pero un comprobador que compara direcciones avisa de que ambos extremos de la conexión envían voltage. Conjugar el extremo receptor, port powerIn : ~BusPowerPort;, lo corrige.
Paso 5: comportamiento con acciones y flujos
La estructura dice qué es el sistema; el comportamiento dice qué hace. Una definición de acción describe un comportamiento con parámetros de entrada y de salida. Las definiciones de ítem describen las cosas que fluyen, aquí la luz solar y la potencia eléctrica en sus distintas 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;
}
- Los parámetros
inyoutson las entradas y salidas de una acción. - Dentro de
RunPowerCycle, cuatro usos de acción son los pasos de una órbita: a la luz del sol, los paneles captan potencia y la PDU carga la batería; en eclipse, la batería devuelve la energía y la PDU alimenta el bus con ella. flow collect.power to charge.powerdice que la salida de un paso es la entrada del siguiente.first collect then chargees una sucesión: un paso termina antes de que empiece el siguiente. Los flujos dicen qué se mueve; las sucesiones dicen en qué orden.startydoneson el principio y el final de la acción que los contiene.
Los pasos coinciden con las funciones de potencia de EO-1: F3.1 Convert Sunlight to Power, F3.2 Store Battery Energy y F3.3 Regulate Bus Power. Derivar esas funciones de los requisitos y ordenarlas es el tema del análisis funcional; las definiciones de acción son el lugar donde ese trabajo se plasma en SysML v2.
La vista de flujo de acciones de abajo se dibuja a partir de este texto junto con la asignación del paso 6, que da a cada paso una calle.
powerCycleFlow: los pasos a la luz del sol y después los pasos en eclipse, con la potencia que fluye entre ellos.La consecuencia de ingeniería: la batería está en el camino de cada vatio que usa el bus en eclipse. Lo que la batería almacena a la luz del sol debe cubrir la carga del eclipse, que es exactamente lo que limitan los requisitos 3.2 y 3.3 en el paso 7.
Paso 6: asignar el comportamiento a la estructura
Hasta ahora, el comportamiento no pertenece a ningún componente. Una instrucción perform dice qué parte lleva a cabo qué paso:
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 es un uso de Spacecraft en el nivel superior del paquete: la nave de este diseño. Su sistema de potencia realiza RunPowerCycle, y cada parte del EPS realiza sus pasos. part redefines eps refina el sistema de potencia heredado de Spacecraft en lugar de añadir un segundo. La PDU realiza dos pasos, cargar a la luz del sol y alimentar el bus en eclipse, porque una sola unidad hace ambos trabajos.
Esta es la forma textual de una asignación funcional. A partir de ella, una herramienta puede enumerar las funciones que realiza cada componente, o dibujar el flujo de acciones con una calle por parte, como en la vista anterior.
Paso 7: requisitos con restricciones
Los requisitos van en su propio paquete, que importa el diseño. En SysML v2 un requisito es una restricción sobre un sujeto: el texto doc dice con palabras lo que se necesita, y un require constraint dice lo mismo de una forma que una herramienta puede evaluar. Los tres requisitos son los requisitos 3.1, 3.2 y 3.3 de EO-1, con sus propios id. y su redacción.
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'>es un nombre corto: el identificador que los ingenieros citan en las revisiones. Otros elementos del modelo hacen referencia al nombre completo,OrbitAveragePower.subject eps : ElectricalPowerSystemnombra aquello de lo que trata el requisito.require constraint { eps.orbitAveragePower >= required }es la condición que debe cumplirse. El límite es un parámetro, así que la misma definición sirve para una nave con otra necesidad de potencia.powerSpecreúne los requisitos de EO-1 y fija los límites: 28 W, 77 Wh y 0,3.satisfy powerSpec by eo1.epsafirma que el sistema de potencia de EO-1 cumple la especificación.
Mantenga el texto doc y la restricción diciendo lo mismo. Los revisores leen el texto; las herramientas evalúan la restricción. Los vínculos del requisito al diseño y a las pruebas son la base de la trazabilidad de requisitos.
Una vista de requisitos muestra la especificación como árbol, con la parte que la satisface y el caso de verificación del paso 8:
requirementTree: los requisitos 3.1 a 3.3, lo que los satisface y lo que los verifica.Como las restricciones pueden evaluarse, un comprobador hace algo más que dibujar la línea satisfy: pone a prueba la afirmación frente a los valores del paso 3. Con el modelo tal como está escrito, las tres se cumplen: 28,05 W frente a 28 W, 77 Wh frente a 77 Wh y una profundidad de descarga de 0,24 frente a 0,3.
El primero de esos márgenes es estrecho. Baje el rendimiento de la cadena de potencia de 0,6 a 0,59, un cambio de menos del dos por ciento, y la potencia media orbital cae a 27,58 W. El comprobador notifica entonces que el requisito 3.1 ya no se cumple, con los valores que lo incumplieron:
La consecuencia de ingeniería: el requisito 3.1 ya incluye el margen del sistema (su justificación en EO-1 es una carga de 24 W en modo de toma de imágenes más un 15 %), pero los paneles cumplen el propio 3.1 con solo 0,05 W de sobra. Cualquier pérdida que no estuviera en la estimación, como una degradación más rápida de las células, exige más superficie de panel o una carga menor. Un modelo que comprueba el requisito en cada cambio lo muestra cuando la cifra se mueve, no en la siguiente revisión. Para ver qué probabilidad hay de que el margen se mantenga cuando las entradas son inciertas en lugar de fijas, consulte el análisis de Monte Carlo en ingeniería de sistemas.
Paso 8: un caso de verificación
Una relación satisfy es una afirmación, y la comprobación del paso 7 solo la pone a prueba frente a las cifras del propio modelo. Un caso de verificación dice cómo se comprueba la afirmación en el hardware real, mediante prueba, inspección, análisis o demostración. EO-1 verifica la capacidad de su batería con el caso de prueba 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; }nombra el requisito que verifica este caso. Estos vínculos son la base de una matriz de verificación: cada requisito frente a los casos que lo verifican.return verdictes el resultado: aquí, si la capacidad medida alcanza los 77 Wh del requisito 3.2.batteryTestes un uso del caso para el sistema de potencia de EO-1: la prueba planificada, con su sujeto enlazado aeo1.eps.
La satisfacción y la verificación se mantienen separadas a propósito. La satisfacción dice qué elemento de diseño responde a un requisito; la verificación dice cómo se sabe que lo hace. En el proyecto EO-1, TC-07 se ha aprobado con 78,3 Wh medidos. Los requisitos 3.1 y 3.3 aún necesitan sus propios casos, y una matriz de verificación de requisitos es donde aparece ese hueco.
Paso 9: vistas y diagramas
En SysML v2 un diagrama no es un dibujo aparte. Una vista es un elemento del modelo que indica qué mostrar (expose) y qué tipos de elementos incluir (filter). Una herramienta representa la vista y guarda su disposición; el contenido procede siempre del modelo. Las tres capturas de pantalla anteriores son estas tres vistas.
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 biblioteca estándar define los tipos de vista habituales:
| Vista | Muestra | En este modelo |
|---|---|---|
| Vista general | Cualquier elemento y sus relaciones, como cajas y líneas | requirementTree |
| Vista de interconexión | Las partes de un conjunto con sus puertos y conexiones | epsConnections |
| Vista de flujo de acciones | Los pasos de un comportamiento, su orden y lo que fluye entre ellos | powerCycleFlow |
| Vista de transición de estados | Los estados y las transiciones entre ellos | Ninguno |
| Vista de secuencia | Mensajes entre partes a lo largo del tiempo | Ninguno |
| Vista de cuadrícula (Grid View) | Elementos o relaciones como tabla o matriz | Ninguno |
requirementTree es una vista general cuyo filtro conserva solo los requisitos y las relaciones satisfy; las herramientas que conocen los tipos de diagrama de SysML v1, entre ellas Holarch, muestran una vista así como diagrama de requisitos. Como una vista forma parte del modelo, cambiar el nombre de la batería cambia todos los diagramas que la muestran, y un revisor puede leer en el texto exactamente lo que incluye un diagrama.
El modelo completo
Los tres paquetes juntos. Descargue el modelo del sistema de potencia de EO-1 (cubesat-eps.sysml), o copie el texto de abajo; ambos son iguales.
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::**;
}
}
Cómo se comprobaron los listados
Cada listado de esta página se analizó y comprobó con el Holarch Language Engine, el motor del Editor SysML v2 de Holarch, con la biblioteca estándar de SysML v2 cargada. Las comprobaciones resuelven cada nombre, comparan unidades y dimensiones, comparan las direcciones de los puertos a través de las conexiones y evalúan las restricciones de los requisitos frente a los valores que los satisfacen.
- El modelo completo y el listado independiente no dan errores ni advertencias.
- Cada fragmento aparece línea a línea, en orden, en el modelo completo.
- Los dos listados que muestran errores dan exactamente el error y la advertencia descritos junto a ellos.
- El modelo completo con un rendimiento de la cadena de potencia de 0,59 da exactamente una advertencia: el requisito 3.1 no se cumple.
Para saber qué construcciones de SysML v2 admite el motor y cuáles son sus carencias conocidas, consulte cobertura del lenguaje SysML v2. Para comparar herramientas en los mismos puntos, consulte qué comprobar en una herramienta SysML v2; este modelo es lo bastante pequeño para servir de archivo de prueba.
Pruébelo en Holarch
- Descargue
cubesat-eps.sysml, o guarde el modelo completo con ese nombre. - Abra Modelo → Importar y exportar, elija En un proyecto SysML v2 nuevo y suelte el archivo. Consulte importar archivos en un proyecto nuevo.
- Abra Modelo → Editor para leer y cambiar el texto. Cada paquete es un documento. Consulte el Editor.
- Abra la lista Diagramas y haga clic en
epsConnections,powerCycleFloworequirementTree. Consulte abrir una vista. - En CubeSatEPS, cambie
pathEfficiency = 0.6por0.59y haga una pausa. El Editor muestra la advertencia en la líneasatisfyde CubeSatEPSRequirements. Deshaga con ⌘Z / Ctrl+Z.
Para escribir el modelo a mano, cree un proyecto SysML v2, haga clic en + Nuevo package en el Editor y escriba los pasos en orden; el texto que se analiza correctamente se aplica tras una breve pausa. Consulte primeros pasos con proyectos SysML v2. La nave EO-1 completa, con sus documentos, pruebas y presupuestos, es la demostración CubeSat: Archivos de proyecto ▾ → Nuevo proyecto de demostración.
Siguientes pasos
- Proyectos SysML v2 en Holarch: texto, vistas y páginas de ingeniería sobre un mismo modelo.
- Referencia de la notación textual: qué admite Holarch, las comprobaciones y la biblioteca estándar.
- Referencia de vistas: cada tipo de vista y cómo editar el modelo en ella.
- Requisitos y verificación en proyectos SysML v2: páginas de requisitos, el Centro de pruebas y la RVTM.
- Análisis en proyectos SysML v2: paramétricos, presupuestos y estudios de alternativas.
- ¿Qué es MBSE?: por qué los ingenieros mantienen el sistema en un modelo.