Holarch

Guide · SysML v2

Tutoriel SysML v2 : modéliser le système de puissance d'un CubeSat en notation textuelle

Écouter ce guide (audio en anglais) 24 min

Ce tutoriel SysML v2 construit pas à pas un modèle petit mais complet : le système d'alimentation électrique du CubeSat EO-1, avec ses parts, ses grandeurs et unités, ses ports et connexions, un cycle ensoleillement-éclipse, des exigences qu'un outil peut contrôler, un cas de vérification et des vues. Chaque listing de cette page est du texte SysML v2 contrôlé avec un moteur de langage, et chaque étape clé montre le diagramme que le texte produit.

Sur cette page
  1. Ce que vous allez construire
  2. Première idée : définitions et usages
  3. Étape 1 : un package et ses imports
  4. Étape 2 : définitions de part et attributs avec unités
  5. Étape 3 : l'assemblage, avec ses valeurs
  6. Étape 4 : ports, interfaces et connexions
  7. Étape 5 : le comportement avec des actions et des flux
  8. Étape 6 : allouer le comportement à la structure
  9. Étape 7 : des exigences avec contraintes
  10. Étape 8 : un cas de vérification
  11. Étape 9 : vues et diagrammes
  12. Le modèle complet
  13. Comment les listings ont été contrôlés
  14. L'essayer dans Holarch
  15. Pour aller plus loin

Ce que vous allez construire

EO-1 est un CubeSat 6U d'observation de la Terre sur une orbite héliosynchrone de 500 km. C'est l'exemple commun de ces guides ; l'exemple de projet MBSE suit l'ensemble du satellite des besoins jusqu'à la vérification. Ce tutoriel prend un sous-système, le système d'alimentation électrique (EPS), et l'écrit en texte SysML v2.

L'EPS comporte trois parts. Deux panneaux solaires déployables convertissent la lumière du soleil en puissance. Un bloc batterie lithium-ion stocke l'énergie pour l'éclipse. Une unité de distribution de puissance (PDU) suit le point de puissance maximale des panneaux, charge la batterie et régule le bus de 12 V. Deux charges de ce bus figurent aussi dans le modèle : la caméra de la charge utile et l'émetteur en bande S.

Les chiffres viennent du modèle EO-1 :

ItemValeurOù il est utilisé
Panneaux solaires : surface des cellules, rendement des cellules, puissance crête0,2 m², 0,295, 75,4 WÉtape 3
Rendement de la chaîne de puissance ; fraction éclairée de l'orbite0.6; 0.62Étape 3
Bloc batterie : capacité ; énergie consommée pendant l'éclipse de 36 minutes77 Wh ; 18,5 WhÉtape 3
Masse : panneaux, batterie, PDU0,45 kg, 0,62 kg, 0,28 kgÉtape 3
Consommation moyenne en orbite : caméra, émetteur en bande S6,2 W, 3,4 WÉtape 3
Exigence 3.1 Orbit Average Powerau moins 28 W en fin de vieÉtape 7
Exigence 3.2 Battery Capacityau moins 77 Wh en début de vieÉtapes 7 et 8
Exigence 3.3 Depth of Dischargeau plus 30 % par orbiteÉtape 7
Cas de test TC-07 Battery Capacity Testdécharge à C/2 dans une enceinte à 20 °CÉtape 8

Le modèle comporte trois packages :

PackageContenuÉtapes
CubeSatEPSPorts, parts, un calcul, les assemblages avec leurs valeurs, et le comportement1 à 6
CubeSatEPSRequirementsLes exigences 3.1 à 3.3 et le cas de vérification TC-077 et 8
CubeSatEPSViewsDes vues qui sélectionnent des parties du modèle pour les diagrammes9

Aucun outil particulier n'est nécessaire pour suivre : le texte est du SysML v2 standard et se charge dans tout outil qui lit la notation textuelle. Le modèle complet se trouve en fin de page et en téléchargement, et la dernière section montre comment le charger dans Holarch.

Première idée : définitions et usages

SysML v2 sépare une définition d'un usage. Une définition dit ce qu'est un type de chose : part def BatteryPack décrit chaque bloc batterie de cette conception, avec ses attributs et ses ports. Un usage est une telle chose dans un contexte : part battery : BatteryPack à l'intérieur du système électrique est la batterie unique de l'EPS d'EO-1, connectée à sa PDU.

Le même couple se retrouve dans tout le langage : attribute def et attribute, port def et port, action def et action, requirement def et requirement. Un mot-clé suivi de def déclare un type ; le même mot-clé sans def en utilise un. Les valeurs spécifiques se placent généralement sur les usages, car c'est dans un usage qu'une décision de conception est prise.

Les lecteurs qui connaissent SysML v1 peuvent comparer une définition à un bloc et un usage à une propriété de part. En SysML v2, l'idée s'applique à chaque type d'élément, et les usages s'imbriquent et se raffinent les uns les autres à n'importe quelle profondeur. SysML v1 et SysML v2 compare les deux langages construction par construction.

Étape 1 : un package et ses imports

Un package est un espace de noms : il regroupe des éléments et leur donne des noms qualifiés comme CubeSatEPS::BatteryPack. Commencez par un package vide et les imports de bibliothèque dont il a besoin.

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 /* … */ attache une documentation au package. Contrairement à un commentaire //, elle fait partie du modèle, et les outils l'affichent avec l'élément.
  • ScalarValues fournit des types de base comme Real, Integer, Boolean et String.
  • ISQ fournit des types de grandeurs du Système international de grandeurs, comme MassValue, PowerValue et EnergyValue.
  • SI fournit des unités SI comme kg, V, W et h.
  • private garde les noms importés à l'intérieur de ce package ; un package qui importe CubeSatEPS ne les reçoit donc pas par son intermédiaire.

Sans les imports, un nom comme MassValue ne peut pas être résolu, et un vérificateur le signale comme inconnu.

Étape 2 : définitions de part et attributs avec unités

Chaque composant reçoit une définition de part avec des attributs typés. Typer un attribut par une grandeur plutôt que par Real enregistre ce qu'il mesure : une masse, une puissance, une énergie. Un outil peut alors contrôler la cohérence des dimensions de chaque valeur et de chaque expression.

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

Ces lignes se placent entre les accolades du package. Les deux rendements restent de simples Real car ce sont des rapports sans unité.

Il n'y a pas encore de valeurs. Une définition décrit chaque bloc batterie de ce type ; les chiffres arrivent avec la batterie propre à EO-1 à l'étape suivante.

Étape 3 : l'assemblage, avec ses valeurs

Le système électrique est lui aussi une définition de part, composée d'usages de part : les panneaux solaires, la batterie et la PDU. Chaque usage donne leurs valeurs aux attributs qu'il hérite de sa définition. Un calcul réutilisable convertit la puissance crête des panneaux en puissance moyenne en orbite, celle par rapport à laquelle l'exigence 3.1 est rédigée.

  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 déclare un usage nommé battery, typé par la définition BatteryPack.
  • attribute redefines capacity = 77 [W*h] donne une valeur à l'attribut hérité capacity. La forme courte :>> capacity = 77 [W*h]; a le même sens. Sans redefines, la ligne déclarerait un second attribut qui ne partage que le nom, et l'attribut hérité capacity n'aurait toujours pas de valeur.
  • 77 [W*h] est une grandeur : un nombre et une unité. Les unités se combinent avec *, / et ^ ; les wattheures s'écrivent donc W*h et les mètres carrés m^2.
  • calc def OrbitAverage est un calcul avec des entrées et un résultat typé. OrbitAverage(…) l'appelle avec les valeurs des panneaux ; la formule est donc écrite une seule fois et chacune de ses utilisations suit une modification.
  • depthOfDischarge divise une énergie par une énergie. Les unités s'annulent, et le résultat est un simple rapport.
  • Spacecraft place le système électrique à côté des deux charges que suit ce tutoriel. Le reste d'EO-1 (contrôle d'attitude, ordinateur de bord, structure) est laissé de côté pour garder le modèle court.

Les valeurs ne sont pas seulement stockées ; un outil les évalue. Avec les chiffres ci-dessus :

AttributExpressionRésultat
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

La puissance crête elle-même a une origine que vous pouvez vérifier : 0,2 m² de cellules d'un rendement de 0,295 sous un éclairement solaire de 1361 W/m², avec un angle d'incidence de 0,35 rad (cos 0,35 = 0,939), donnent 75,4 W. La fraction éclairée découle de l'orbite : une orbite de 500 km dure environ 94,6 minutes, dont 36 en éclipse, ce qui laisse 0,62 de l'orbite au soleil.

Comme chaque valeur porte une unité, une erreur de dimension apparaît dès que le modèle est contrôlé. Une erreur fréquente dans les modèles de puissance consiste à écrire la capacité d'une batterie en watts au lieu de wattheures :

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

  part def BatteryPack {
    attribute capacity : EnergyValue;
  }

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

Un vérificateur qui évalue les unités rejette la valeur : une puissance n'est pas une énergie. Dans Holarch, l'Éditeur marque la ligne d'une erreur de dimension. Dans un tableur, la même étourderie passerait inaperçue jusque dans la profondeur de décharge.

Étape 4 : ports, interfaces et connexions

Les ports sont les points où une part rencontre son environnement. Une définition de port liste ce qui traverse la frontière, chaque feature avec un sens : out pour ce que le propriétaire envoie, in pour ce qu'il reçoit.

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

Le côté récepteur utilise la même définition de port, conjuguée avec ~. ~BusPowerPort est l'image miroir de BusPowerPort : chaque out devient in. Une seule définition de port décrit les deux extrémités d'une liaison ; les deux extrémités ne peuvent donc pas diverger.

Une définition d'interface décrit un type de connexion avec des extrémités typées. BusLink relie le bus de 12 V, qui envoie la puissance, à une charge qui la reçoit. Elle joue le rôle de la 12 V Power Interface (IFB-1) d'EO-1.

Ajoutez maintenant les ports aux parts et connectez-les. Les lignes de commentaire représentent les lignes des étapes précédentes.

  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 est une connexion simple : le harnais des panneaux (l'interface IF-20 d'EO-1). battery.cellsOut vers pdu.batteryIn est le harnais de la batterie (IF-21).
  • bind bus = pdu.busOut énonce que le port bus propre au système électrique et la sortie de la PDU sont une seule et même chose. C'est ainsi qu'une part expose un port intérieur à sa frontière : les charges se connectent à l'EPS, pas à son intérieur.
  • interface payloadPower : BusLink connect … to … connecte deux ports par une interface typée ; la connexion porte donc le sens de BusLink. Les deux interfaces de bus sont la Payload Power Line (IF-01) et la Radio Power Line (IF-04) d'EO-1.

Une vue d'interconnexion dessine le système électrique à partir de ce texte : chaque part avec ses ports en bordure, les ports conjugués marqués de ~, et le port lié bus sur le cadre.

La vue epsConnections de l'étape 9 : les parts de l'EPS, leurs ports et leurs connexions, dessinés à partir du texte.

La conséquence pour l'ingénierie : la liste des interfaces du sous-système est désormais une requête, et non un tableau séparé. Chaque connexion nomme ses deux extrémités et, lorsqu'elle est typée, ce qui la traverse. C'est la matière première d'un document de contrôle d'interface, et elle change quand le modèle change.

Une erreur fréquente consiste à donner aux deux extrémités le même port, non conjugué. Les deux extrémités envoient alors et aucune ne reçoit :

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

Le texte s'analyse, mais un vérificateur qui compare les sens avertit que les deux extrémités de la connexion envoient voltage. Conjuguer l'extrémité réceptrice, port powerIn : ~BusPowerPort;, corrige le problème.

Étape 5 : le comportement avec des actions et des flux

La structure dit ce qu'est le système ; le comportement dit ce qu'il fait. Une définition d'action décrit un comportement avec des paramètres d'entrée et de sortie. Les définitions d'item décrivent ce qui circule, ici la lumière du soleil et la puissance électrique sous ses différentes formes.

  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;
  }
  • Les paramètres in et out sont les entrées et les sorties d'une action.
  • À l'intérieur de RunPowerCycle, quatre usages d'action sont les étapes d'une orbite : au soleil, les panneaux collectent la puissance et la PDU charge la batterie ; en éclipse, la batterie restitue l'énergie et la PDU alimente le bus à partir d'elle.
  • flow collect.power to charge.power indique que la sortie d'une étape est l'entrée de la suivante.
  • first collect then charge est une succession : une étape se termine avant que la suivante ne commence. Les flux disent ce qui circule ; les successions disent dans quel ordre. start et done sont le début et la fin de l'action englobante.

Les étapes correspondent aux fonctions de puissance d'EO-1 : F3.1 Convert Sunlight to Power, F3.2 Store Battery Energy et F3.3 Regulate Bus Power. Dériver de telles fonctions des exigences et les ordonner est le sujet de l'analyse fonctionnelle ; les définitions d'action sont l'endroit où ce travail aboutit en SysML v2.

La vue de flux d'action ci-dessous est dessinée à partir de ce texte et de l'allocation de l'étape 6, qui donne à chaque étape un couloir.

La vue powerCycleFlow : les étapes au soleil, puis les étapes en éclipse, avec la puissance qui circule entre elles.

La conséquence pour l'ingénierie : la batterie se trouve sur le chemin de chaque watt que le bus consomme en éclipse. Ce que la batterie stocke au soleil doit couvrir la charge en éclipse, et c'est exactement ce que contraignent les exigences 3.2 et 3.3 à l'étape 7.

Étape 6 : allouer le comportement à la structure

Jusqu'ici, le comportement n'appartient à aucun composant. Une instruction perform dit quelle part réalise quelle étape :

  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 est un usage de Spacecraft au sommet du package : le satellite de cette conception. Son système électrique réalise RunPowerCycle, et chaque part de l'EPS réalise ses étapes. part redefines eps raffine le système électrique hérité de Spacecraft au lieu d'en ajouter un second. La PDU réalise deux étapes, la charge au soleil et l'alimentation du bus en éclipse, car une seule unité assure les deux tâches.

C'est la forme textuelle d'une allocation fonctionnelle. À partir d'elle, un outil peut lister les fonctions que réalise chaque composant, ou dessiner le flux d'action avec un couloir par part, comme dans la vue ci-dessus.

Étape 7 : des exigences avec contraintes

Les exigences vont dans leur propre package, qui importe la conception. En SysML v2, une exigence est une contrainte sur un sujet : le texte doc dit en mots ce qui est nécessaire, et une require constraint dit la même chose sous une forme qu'un outil peut évaluer. Les trois exigences sont les exigences 3.1, 3.2 et 3.3 d'EO-1, avec leurs propres identifiants et leur propre formulation.

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'> est un nom court : l'identifiant que les ingénieurs citent lors des revues. Les autres éléments du modèle font référence au nom complet, OrbitAveragePower.
  • subject eps : ElectricalPowerSystem nomme ce sur quoi porte l'exigence.
  • require constraint { eps.orbitAveragePower >= required } est la condition qui doit être vérifiée. La limite est un paramètre ; la même définition sert donc à un satellite ayant un besoin de puissance différent.
  • powerSpec rassemble les exigences d'EO-1 et fixe les limites : 28 W, 77 Wh et 0,3.
  • satisfy powerSpec by eo1.eps affirme que le système électrique d'EO-1 satisfait la spécification.

Faites en sorte que le texte doc et la contrainte disent la même chose. Les relecteurs lisent le texte ; les outils évaluent la contrainte. Les liens de l'exigence vers la conception et le test sont le socle de la traçabilité des exigences.

Une vue d'exigences présente la spécification sous forme d'arbre, avec la part qui la satisfait et le cas de vérification de l'étape 8 :

La vue requirementTree : les exigences 3.1 à 3.3, ce qui les satisfait et ce qui les vérifie.

Comme les contraintes peuvent être évaluées, un vérificateur fait plus que dessiner la ligne satisfy : il teste l'affirmation par rapport aux valeurs de l'étape 3. Avec le modèle tel qu'écrit, les trois sont tenues : 28,05 W pour 28 W, 77 Wh pour 77 Wh, et une profondeur de décharge de 0,24 pour 0,3.

La première de ces marges est mince. Abaissez le rendement de la chaîne de puissance de 0,6 à 0,59, une variation de moins de deux pour cent, et la puissance moyenne en orbite tombe à 27,58 W. Le vérificateur signale alors que l'exigence 3.1 n'est plus satisfaite, avec les valeurs qui l'ont fait échouer :

Le contrôle de l'exigence après la modification d'une valeur de conception : l'avertissement nomme l'exigence, la part, la contrainte et les valeurs.

La conséquence pour l'ingénierie : l'exigence 3.1 porte déjà la marge système (sa justification dans EO-1 est une charge de 24 W en mode imagerie plus 15 %), mais les panneaux ne satisfont 3.1 elle-même qu'avec 0,05 W de réserve. Toute perte absente de l'estimation, comme une dégradation plus rapide des cellules, exige soit davantage de surface de panneaux, soit une charge plus faible. Un modèle qui contrôle l'exigence à chaque modification le montre dès que le chiffre bouge, pas à la revue suivante. Pour voir avec quelle probabilité la marge tient quand les entrées sont incertaines plutôt que fixes, voir l'analyse de Monte Carlo en ingénierie des systèmes.

Étape 8 : un cas de vérification

Une relation satisfy est une affirmation, et le contrôle de l'étape 7 ne la teste qu'avec les propres chiffres du modèle. Un cas de vérification dit comment l'affirmation est contrôlée sur le matériel réel, par test, inspection, analyse ou démonstration. EO-1 vérifie la capacité de sa batterie avec le cas de test TC-07.

  verification def <'TC-07'> BatteryCapacityTest {
    doc /* Discharge the pack at C/2 from full charge in a thermal chamber at 20 degrees C and measure the energy delivered. */
    subject eps : ElectricalPowerSystem;
    objective {
      verify powerSpec.batteryCapacity;
    }
    return verdict : Boolean = eps.battery.capacity >= powerSpec.batteryCapacity.minimum;
  }

  verification batteryTest : BatteryCapacityTest {
    subject eps = eo1.eps;
  }
  • objective { verify powerSpec.batteryCapacity; } nomme l'exigence que ce cas vérifie. Ces liens sont ce à partir de quoi une matrice de vérification est construite : chaque exigence face aux cas qui la vérifient.
  • return verdict est le résultat : ici, si la capacité mesurée atteint les 77 Wh de l'exigence 3.2.
  • batteryTest est un usage du cas pour le système électrique d'EO-1 : le test planifié, avec son sujet lié à eo1.eps.

Satisfaction et vérification sont volontairement séparées. La satisfaction dit quel élément de conception répond à une exigence ; la vérification dit comment vous savez qu'il y répond. Dans le projet EO-1, TC-07 a réussi avec 78,3 Wh mesurés. Les exigences 3.1 et 3.3 ont encore besoin de leurs propres cas, et c'est dans une matrice de vérification des exigences que cette lacune apparaît.

Étape 9 : vues et diagrammes

En SysML v2, un diagramme n'est pas un dessin séparé. Une vue est un élément du modèle qui énonce ce qu'il faut montrer (expose) et quels types d'éléments inclure (filter). Un outil restitue la vue et conserve sa disposition ; le contenu vient toujours du modèle. Les trois captures d'écran ci-dessus sont ces trois vues.

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 bibliothèque standard définit les types de vues courants :

VueMontreDans ce modèle
Vue généraleDes éléments quelconques et leurs relations, sous forme de boîtes et de lignesrequirementTree
Vue d'interconnexionLes parts d'un assemblage avec leurs ports et leurs connexionsepsConnections
Vue de flux d'ActionLes étapes d'un comportement, leur ordre et ce qui circule entre ellespowerCycleFlow
Vue des transitions d'étatLes états et les transitions entre euxAucun
Vue de séquenceLes messages échangés entre parts au fil du tempsAucun
Vue grilleDes éléments ou des relations sous forme de tableau ou de matriceAucun

requirementTree est une vue générale dont le filtre ne conserve que les exigences et les relations satisfy ; les outils qui connaissent les types de diagrammes SysML v1, dont Holarch, présentent une telle vue comme un diagramme d'exigences. Comme une vue fait partie du modèle, renommer la batterie modifie chaque diagramme qui la montre, et un relecteur peut lire dans le texte exactement ce qu'inclut un diagramme.

Le modèle complet

Les trois packages réunis. Téléchargez le modèle du système électrique d'EO-1 (cubesat-eps.sysml), ou copiez le texte ci-dessous ; les deux sont identiques.

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

Comment les listings ont été contrôlés

Chaque listing de cette page a été analysé et contrôlé avec le Holarch Language Engine, le moteur de l'Éditeur SysML v2 de Holarch, avec la bibliothèque standard SysML v2 chargée. Les contrôles résolvent chaque nom, comparent les unités et les dimensions, comparent les sens des ports à travers les connexions, et évaluent les contraintes d'exigences par rapport aux valeurs qui les satisfont.

  • Le modèle complet et le listing autonome ne produisent ni erreur ni avertissement.
  • Chaque extrait figure ligne pour ligne, dans l'ordre, dans le modèle complet.
  • Les deux listings qui montrent des erreurs produisent exactement l'erreur et l'avertissement décrits à côté d'eux.
  • Le modèle complet avec un rendement de chaîne de puissance de 0,59 produit exactement un avertissement : exigence 3.1 non satisfaite.

Pour les constructions SysML v2 que le moteur prend en charge et ses lacunes connues, voir couverture du langage SysML v2. Pour comparer des outils sur les mêmes points, voir ce qu'il faut vérifier dans un outil SysML v2 ; ce modèle est assez petit pour servir de fichier de test.

L'essayer dans Holarch

  1. Téléchargez cubesat-eps.sysml, ou enregistrez le modèle complet sous ce nom.
  2. Ouvrez Modèle → Importer et exporter, choisissez Dans un nouveau projet SysML v2 et déposez le fichier. Voir importer des fichiers dans un nouveau projet.
  3. Ouvrez Modèle → Éditeur pour lire et modifier le texte. Chaque package est un document. Voir l'Éditeur.
  4. Ouvrez la liste Diagrammes et cliquez sur epsConnections, powerCycleFlow ou requirementTree. Voir ouvrir une vue.
  5. Dans CubeSatEPS, remplacez pathEfficiency = 0.6 par 0.59 et marquez une pause. L'Éditeur affiche l'avertissement sur la ligne satisfy dans CubeSatEPSRequirements. Annulez avec ⌘Z / Ctrl+Z.

Pour saisir plutôt le modèle vous-même, créez un projet SysML v2, cliquez sur + Nouveau package dans l'Éditeur et écrivez les étapes dans l'ordre ; le texte qui s'analyse correctement est appliqué après une courte pause. Voir démarrer avec les projets SysML v2. Le satellite EO-1 complet, avec ses documents, ses tests et ses budgets, est la démo CubeSat : Fichiers de projet ▾ → Nouveau projet de démonstration.

Pour aller plus loin