Holarch

Guide · Architecture

Architecture fonctionnelle, logique et physique en MBSE : des fonctions à l'architecture système

Écouter ce guide (audio en anglais) 32 min

Une architecture système répond à deux questions dans l'ordre : que doit faire le système, et quelles parties le feront. Ce guide explique les vues fonctionnelle, logique et physique d'une architecture, pourquoi elles sont séparées, comment les fonctions sont allouées à travers elles à des composants réels, et comment les interfaces et les compromis découlent de cette allocation, sur l'exemple des sous-systèmes d'alimentation électrique et de gestion des données d'un CubeSat 6U d'observation de la Terre.

Sur cette page
  1. Trois vues d'un même système
    1. Une remarque sur la terminologie
  2. La place de l'architecture dans le cycle de vie
  3. L'architecture fonctionnelle
  4. L'architecture logique
  5. L'architecture physique
  6. L'allocation : du quoi au qui
    1. Les règles
    2. Montrer l'allocation sur un seul diagramme
  7. Les interfaces découlent de l'allocation
  8. Compromis d'architecture
  9. Exemple détaillé : les tranches puissance et gestion des données d'EO-1
    1. L'architecture physique
    2. Une couche logique pour les deux tranches
    3. L'allocation, contrôlée dans une matrice
    4. Les interfaces qui découlent de l'allocation
    5. Un compromis ouvert sur la tranche puissance
  10. Comment LML et SysML expriment les trois vues
  11. Liste de contrôle pour la revue d'architecture
  12. Erreurs courantes
  13. L'essayer dans Holarch
  14. Pour aller plus loin

Trois vues d'un même système

Une architecture est facile à dessiner et difficile à réussir, car un même dessin tente généralement de dire trois choses différentes à la fois : ce que fait le système, comment son travail est regroupé en éléments cohérents, et quels matériels et logiciels seront réellement construits. L'ingénierie des systèmes basée sur les modèles les sépare en trois vues du même système, reliées par l'allocation :

Architecture fonctionnelleArchitecture logiqueArchitecture physique
Répond àQue doit faire le système ?Comment le travail est-il regroupé en éléments, indépendamment de la technologie ?Quels composants réels font le travail ?
ÉlémentsLes fonctions et les items qu'elles échangentLes éléments logiques (aussi appelés composants logiques ou blocs fonctionnels) et leurs interfaces logiquesMatériel, logiciel, personnes et installations, avec les interfaces physiques
Nommé avecUn verbe et un nom : Regulate Bus PowerUn nom désignant un rôle : Power ConditioningUn nom désignant une chose : Power Distribution Unit
Change quandLes exigences changentLe concept changeUn fournisseur, une technologie ou une référence de pièce change
Reliés parEntrées et sortiesInterfaces logiques : ce qui doit passer, pas commentCâbles, bus, liaisons radio, conduites, liaisons mécaniques
Diagrammes typesArbre fonctionnel, FFBD, matrice N2Diagrammes de blocs des éléments logiques, N2 des élémentsDiagrammes d'Asset ou de blocs, diagrammes de blocs internes, diagrammes d'interfaces

Garder les vues séparées permet à une équipe d'en modifier une sans redessiner les autres. Si le fournisseur de la batterie change, la vue physique change et les fonctions restent en place. Si le client ajoute une exigence, une fonction apparaît et l'équipe peut se demander quel élément logique doit en être responsable avant que quiconque ne débatte des boîtes. Et si l'équipe veut comparer deux conceptions, elle peut figer les vues fonctionnelle et logique et ne faire varier que la vue physique, ce qui rend la comparaison équitable.

L'ISO/IEC/IEEE 42010 appelle cette idée points de vue et vues : une architecture, décrite par plusieurs vues, chacune répondant aux préoccupations de parties prenantes particulières. Les trois vues présentées ici sont celles dont presque tout projet système a besoin.

Une remarque sur la terminologie

Les termes ne sont pas employés partout de la même façon. Certains textes appellent l'architecture fonctionnelle architecture logique, car les deux sont indépendantes du matériel ; le guide de l'analyse fonctionnelle emploie « vue logique » dans ce sens large. D'autres réservent « logique » à la couche intermédiaire décrite ici, le regroupement des fonctions en éléments indépendants de la technologie. Beaucoup de petits projets omettent la couche intermédiaire et allouent les fonctions directement aux sous-systèmes physiques. Chacune de ces pratiques fonctionne si le projet indique par écrit laquelle il utilise et ne mélange pas fonctions, rôles et références de pièces dans un même diagramme.

La place de l'architecture dans le cycle de vie

L'ISO/IEC/IEEE 15288 situe ce travail dans deux processus techniques. Le processus de définition de l'architecture (article 6.4.4) élabore des architectures candidates, les évalue et en retient une, exprimée sous forme d'un ensemble de vues cohérentes. Le processus de définition de la conception (article 6.4.5) donne ensuite à chaque élément assez de détail pour le construire ou l'acheter. La définition des exigences système alimente les deux, et l'analyse système (6.4.6) fournit les chiffres qui permettent de départager les candidates.

Le NASA Systems Engineering Handbook (NASA/SP-2016-6105 Rev 2) suit le même ordre sous d'autres noms : la décomposition logique (section 4.3) transforme les exigences en modèles fonctionnels et comportementaux, et la définition de la solution de conception (section 4.4) les transforme en conceptions physiques alternatives et en retient une. Le Systems Engineering Handbook de l'INCOSE décrit les boucles qui les relient : le travail d'architecture renvoie régulièrement l'équipe aux exigences, et le travail de conception à l'architecture.

En pratique : d'abord l'architecture fonctionnelle, puis le regroupement logique, puis une ou plusieurs architectures physiques candidates, chacune entièrement allouée pour que ses interfaces et ses budgets puissent être comparés, ensuite une étude de compromis pour en choisir une, et enfin la définition des interfaces et la conception des composants.

L'architecture fonctionnelle

L'architecture fonctionnelle énonce ce que le système doit faire, sans engagement sur la manière. Ses briques sont un arbre fonctionnel (une fonction de premier niveau décomposée niveau par niveau), un flux pour chaque fonction parente (séquence, branches parallèles, alternatives et boucles) et les items que chaque fonction produit et consomme. Chaque fonction est tracée vers les exigences qu'elle satisfait.

Le guide de l'analyse fonctionnelle présente la méthode sur le même CubeSat que ci-dessous. Pour le travail d'architecture, ses principaux résultats sont les fonctions de plus bas niveau (les unités qui sont allouées), les items qui circulent entre elles (la matière première des interfaces) et les exigences portant sur chaque fonction, qui la suivent jusqu'au composant qui la réalise.

L'architecture logique

Un élément logique est une responsabilité dont le système a besoin, énoncée sans choisir la technologie qui l'assurera. Energy Storage est un élément logique ; un bloc batterie lithium-ion, un banc de supercondensateurs et un volant d'inertie sont trois manières physiques de le réaliser. L'architecture logique regroupe les fonctions en de tels éléments et enregistre ce qui doit passer entre eux.

Pourquoi ajouter une couche entre les fonctions et les pièces ? Pour trois raisons :

  • Elle stabilise la conception. Les fonctions sont fines et les pièces volatiles. Quelques éléments logiques aux responsabilités claires survivent aux changements de fournisseur et aux évolutions technologiques, et les exigences et interfaces rédigées par rapport à eux survivent aussi.
  • Elle cadre les alternatives. Une étude de compromis compare des candidates physiques par rapport aux mêmes éléments logiques. Sans ce cadre commun, deux candidates diffèrent souvent par ce qu'elles font autant que par la manière, et la comparaison n'est pas équitable.
  • Elle sépare « ce qui va ensemble » de « ce qui s'achète ensemble ». Deux éléments logiques peuvent finir dans un même boîtier (un ordinateur de bord qui assure à la fois le traitement des télécommandes et la gestion des pannes), ou un élément peut s'étendre sur plusieurs boîtiers (la gestion des pannes répartie entre le logiciel et un circuit de déclenchement matériel). Voir explicitement cette différence est le point de départ d'une bonne décision d'allocation.

Pour former les éléments logiques, examinez la matrice N2 des fonctions. Les fonctions qui échangent beaucoup d'items, partagent des données ou doivent s'exécuter au même rythme vont ensemble ; les fonctions qui échangent peu peuvent vivre séparément. C'est la règle de cohésion et de couplage bien connue en logiciel : des liens forts à l'intérieur d'un élément, peu de liens entre éléments. Nommez chaque élément d'après sa responsabilité, vérifiez que chaque fonction tombe dans exactement un élément, et rédigez une phrase d'objectif pour chacun.

L'architecture physique

L'architecture physique nomme les choses réelles : ensembles matériels, articles logiciels, personnes et installations, organisés en une décomposition qui va du système aux composants en passant par les segments et les sous-systèmes. Chaque composant porte les attributs dont la conception et les budgets ont besoin (masse, puissance, débit de données, coût) et est relié aux autres par des interfaces physiques : harnais, bus, liaisons radio, fixations mécaniques, conduites de fluides.

Incluez les systèmes externes et l'environnement comme contexte hors de la frontière du système, pour que leurs interfaces puissent aussi être listées.

L'allocation : du quoi au qui

L'allocation est la décision qu'un élément donné d'une vue est réalisé par un élément donné de la vue suivante. Elle forme une chaîne :

requirement  -> satisfied by -> function
function     -> allocated to -> logical element
logical      -> allocated to -> physical component

Lorsque la couche logique est omise, les fonctions sont allouées directement aux composants physiques. Les exigences et contraintes qui ne sont pas des fonctions (masse, température de fonctionnement, norme imposée) sont allouées directement aux composants ou au système, jamais introduites de force dans l'arbre fonctionnel.

Les règles

  • Chaque fonction de plus bas niveau est allouée. Une fonction que personne ne réalise est un travail que le système ne fera pas. Les fonctions parentes sont couvertes par leurs enfants.
  • Chaque fonction de plus bas niveau a un seul responsable. Si deux composants doivent coopérer pour réaliser une fonction, une interface s'y cache ; décomposez la fonction jusqu'à ce que chaque morceau ait un seul exécutant, et l'interface entre eux devient visible.
  • Plusieurs fonctions pour un composant, c'est normal. Un ordinateur de bord planifie les télécommandes, stocke les données et exécute la gestion des pannes. L'allocation de plusieurs fonctions à un composant est la façon d'utiliser efficacement le matériel réel ; vérifiez seulement que le composant peut porter la charge combinée (traitement, mémoire, puissance, contraintes temporelles).
  • Une fonction pour plusieurs composants est un signal. Au plus bas niveau, cela signifie que la fonction n'est pas assez décomposée. À un niveau parent, c'est attendu : une fonction parente est réalisée par l'ensemble des composants qui réalisent ses enfants.
  • L'allocation est traçable dans les deux sens. À partir de n'importe quel composant, vous pouvez lister les fonctions qu'il réalise et, à travers elles, les exigences qu'il doit satisfaire ; à partir de n'importe quelle exigence, vous pouvez trouver la fonction et le composant responsables. C'est ce qui rend possible l'analyse d'impact des modifications (le guide de la traçabilité des exigences montre comment).

La façon habituelle de revoir l'allocation est une matrice d'allocation : les fonctions en lignes, les composants en colonnes, une marque là où un composant réalise une fonction. Une ligne vide est une fonction non allouée ; une colonne vide est un composant qui ne fait rien ; une ligne avec deux marques au plus bas niveau est une fonction partagée.

Montrer l'allocation sur un seul diagramme

Une matrice répond aux questions une cellule à la fois. Une hiérarchie allouée montre les mêmes liens sous la forme de la décomposition physique : le système à gauche, ses sous-systèmes en colonne avec les fonctions que chacun réalise, et les composants de chaque sous-système listés à côté avec leurs propres fonctions. Une seule image montre qui fait quoi et où ce travail se situe dans la structure.

La figure dessine 1 EO-1 Spacecraft de cette façon. Lisez-la de gauche à droite. La ligne sous un sous-système liste les fonctions qu'il réalise lui-même ; sa liste de composants ajoute les fonctions confiées à ses parties. 1.3 EPS réalise F3 Generate and Store Power, et sa liste place F3.1 à F3.3 sur les panneaux solaires, le bloc batterie et l'unité de distribution de puissance. 1.5 Communications ne réalise rien lui-même : son travail repose sur l'émetteur-récepteur UHF (F6) et l'émetteur en bande S (F9). La boîte du système porte F5 Operate Imaging Orbits, dont aucun sous-système n'est seul responsable. Les numéros comme OPS.4 et SM.2 sont des étapes du scénario d'exploitation et des activités du mode survie, réalisées par les mêmes sous-systèmes.

Deux contrôles prennent quelques secondes sur cette vue :

  • Chaque fonction est couverte par au moins un sous-système. Parcourez la liste des fonctions et retrouvez chaque numéro sur le diagramme. F1 à F10 apparaissent toutes. F11 Process and Deliver Images n'apparaît pas, car c'est 2.2 Mission Operations Center, au sol, qui la réalise. Une fonction qui n'apparaît sur aucun diagramme du système ou de ses voisins n'a pas d'exécutant.
  • Une fonction sous plusieurs sous-systèmes signale une interface. Quand un même numéro apparaît sous deux sous-systèmes, ceux-ci se partagent ce travail, et ce qui passe entre eux est une interface, dessinée ou non. Décomposez la fonction jusqu'à ce que chaque morceau ait un seul exécutant, et consignez l'interface. Dans EO-1, chaque fonction n'apparaît qu'une fois.

SysML montre la même information bloc par bloc, dans un compartiment allocatedFrom qui liste ce qui est alloué au bloc. La hiérarchie allouée montre ces listes pour toute la décomposition à la fois.

Les interfaces découlent de l'allocation

Dans la vue fonctionnelle, un item passe d'une fonction à une autre. Après l'allocation, le même item passe du composant qui réalise la première fonction au composant qui réalise la seconde. S'il s'agit de composants différents, l'item franchit désormais une frontière physique, et quelque chose doit le transporter. C'est de là que viennent les interfaces :

  1. Pour chaque item échangé entre fonctions, recherchez l'exécutant de la fonction productrice et celui de la fonction consommatrice.
  2. Si l'exécutant est le même, l'échange est interne à ce composant ; c'est une question de conception pour l'équipe du composant.
  3. Si les exécutants diffèrent, l'échange nécessite un chemin physique entre eux : une interface existante capable de le porter, ou une nouvelle.
  4. Contrôlez la capacité de chaque chemin par rapport à tout ce qu'il porte, et donnez à chaque interface un responsable et un statut.

C'est aussi pourquoi les choix d'allocation comptent autant. Déplacer une fonction d'un composant à un autre peut créer des interfaces, en supprimer, ou faire passer un flux de données important sur une liaison plus lente. Une bonne allocation garde les échanges les plus lourds et les plus fréquents à l'intérieur des composants et laisse aux frontières des échanges simples et stables. Une fois les interfaces trouvées, le guide du document de contrôle d'interface explique comment les définir et les maîtriser.

Compromis d'architecture

Il n'existe presque jamais une seule architecture physique raisonnable. Chaque candidate réalise les mêmes éléments logiques différemment, et ce sont ces différences qu'une étude de compromis met en balance :

  • Intégration ou séparation. Placer plusieurs éléments logiques dans un même composant économise de la masse, de la puissance et des interfaces, mais couple leurs défaillances et leurs calendriers. Les séparer isole les pannes et les fournisseurs, au prix de davantage d'interfaces.
  • Matériel ou logiciel. Une fonction comme la protection contre les sous-tensions peut être une règle logicielle sur l'ordinateur de bord, un circuit de déclenchement matériel dans l'unité de puissance, ou les deux. Chaque choix déplace des exigences, de l'effort de test et des modes de défaillance.
  • Où passent les flux lourds. Les données à haut débit, la forte puissance et les contraintes temporelles serrées coûtent cher à travers les frontières. Une allocation qui place le producteur et le consommateur d'un flux lourd dans des composants différents nécessite entre eux une interface performante.

Notez les candidates par rapport à des critères dérivés des exigences, avec des pondérations convenues avant que les notes ne soient connues, et testez jusqu'où les pondérations peuvent bouger avant que le gagnant ne change. L'exemple d'étude de compromis applique cette méthode au même CubeSat, et le guide Monte Carlo montre comment traiter des entrées incertaines lorsque les marges sont faibles.

Exemple détaillé : les tranches puissance et gestion des données d'EO-1

L'exemple est EO-1, un CubeSat 6U fictif d'observation de la Terre sur une orbite héliosynchrone de 500 km, le même système que suivent les autres guides (l'exemple de projet MBSE parcourt l'ensemble du modèle). Deux de ses tranches montrent la chaîne complète des fonctions aux composants : le sous-système d'alimentation électrique (EPS) et la gestion des commandes et des données (C&DH). Tout ce qui suit est tiré du modèle, y compris sa couche logique L1 à L6, qui fait partie du modèle de référence EO-1 (v1.0) et des projets de démonstration créés dans Holarch 2.2.1 ou ultérieur.

Téléchargement : chaîne d'allocation d'EO-1 pour l'EPS et la C&DH (CSV) : une ligne par fonction de l'EPS et de la C&DH avec ses exigences, son élément logique, son composant, les items qu'elle échange avec d'autres composants et les interfaces qui les portent. Utilisez-la comme modèle pour votre propre tableau d'allocation.

L'architecture physique

La décomposition physique du modèle commence à 0 EO-1 Mission, avec en dessous le satellite, le segment sol, le lanceur et l'environnement orbital. Le satellite comporte six sous-systèmes, dont trois sont décomposés en parties :

  • 1.3 EPS contient 1.3.1 Solar Arrays (deux panneaux déployables à triple jonction), 1.3.2 Battery Pack (lithium-ion à 8 cellules, 77 Wh) et 1.3.3 Power Distribution Unit (suivi du point de puissance maximale, régulation 12 V, sorties de charge commutées).
  • 1.4 C&DH est une seule unité : un ordinateur de bord avec 64 Go de stockage pour la charge utile.
  • Les conduits sont des interfaces physiques numérotées, comme IF-01 à IF-04 pour les lignes de puissance issues de l'EPS et IF-09 Power Telemetry Link, une liaison I2C entre l'unité de distribution de puissance et l'ordinateur de bord.

Une couche logique pour les deux tranches

La décomposition physique seule passe directement des fonctions aux sous-systèmes et aux parties. Une couche logique pour les deux tranches montre ce qu'apporte l'étape intermédiaire. Six éléments logiques, L1 à L6 sous L0 EO-1 Logical Architecture, couvrent les fonctions concernées :

Élément logiqueResponsabilitéFonctions regroupéesRéalisé par
L1 Power GenerationConvertir une source d'énergie externe en puissance électriqueF3.1 Convert Sunlight to Power1.3.1 Solar Arrays
L2 Energy StorageConserver l'énergie pour l'éclipse et les pics de chargeF3.2 Store Battery Energy1.3.2 Battery Pack
L3 Power Conditioning and DistributionRéguler le bus, gérer la charge de la batterie, commuter les chargesF3.3 Regulate Bus Power1.3.3 Power Distribution Unit
L4 Onboard Command ProcessingValider, planifier et exécuter les télécommandesOPS.3 Load Command Schedule, SM.1 Execute Command Schedule, SM.3 Enable S-band Transmitter1.4 C&DH
L5 Payload Data ManagementCompresser, stocker et libérer les données de la charge utileF8 Store Payload Data, OPS.7 Encode and Store Image1.4 C&DH
L6 Fault ManagementDétecter les pannes et placer le satellite dans un état sûrF10 Enter Safe Mode1.4 C&DH

Côté EPS, la correspondance est biunivoque : chaque élément logique a sa propre partie. Côté C&DH, ce n'est pas le cas : trois éléments logiques partagent un même ordinateur de bord. C'est un choix de conception légitime pour un CubeSat, où un second processeur coûte de la masse, de la puissance et du volume, mais la couche logique en fait un choix visible plutôt qu'un accident. Elle montre aussi les alternatives qu'une étude de compromis pourrait mettre en balance : L5 dans une unité de mémoire de masse séparée, ou une partie de L6 sous forme de déclenchement matériel sur sous-tension dans l'unité de distribution de puissance, qui servirait l'exigence 4.3 (mode survie dans les 10 secondes suivant la détection d'une sous-tension) sans dépendre du logiciel de vol.

L'allocation, contrôlée dans une matrice

Le modèle enregistre l'exécutant de chaque fonction avec un lien performed by. Une matrice d'allocation avec l'arbre fonctionnel de F0 Perform EO-1 Mission en lignes et l'arbre des Assets de la mission en colonnes montre toute l'allocation d'un coup (les colonnes qui ne réalisent rien sont masquées) :

Lisez la matrice à la lumière des règles :

  • Chaque fonction est allouée. Chacune des 18 fonctions a exactement une marque. La seule ligne vide est F0, la fonction de premier niveau, qui est couverte par ses enfants.
  • Les parents vont aux sous-systèmes, les enfants aux parties. F3 Generate and Store Power est réalisée par l'EPS, et ses trois sous-fonctions par les trois parties de l'EPS. L'allocation est cohérente d'un niveau à l'autre : l'exécutant de chaque enfant fait partie de l'exécutant du parent.
  • Plusieurs fonctions pour la C&DH. La colonne C&DH porte deux marques dans cet arbre, F8 et F10. Sur l'ensemble du modèle, elle réalise six actions, en ajoutant OPS.3 Load Command Schedule et OPS.7 Encode and Store Image issues du scénario d'exploitation et deux activités de mode issues de la machine à états. C'est le regroupement L4 à L6 ci-dessus, rendu concret.
  • Un sous-système qui fait le travail d'une partie. F4.2 Compute Control Torques est réalisée par 1.2 ADCS lui-même, alors que ses voisines vont à des parties (viseur d'étoiles, roues de réaction, magnétocoupleurs). L'ADCS n'a pas de partie contrôleur dans la décomposition, bien que trois liaisons au niveau des parties (IF-16 à IF-18) aboutissent à l'ADCS. Ajouter une partie comme ADCS Controller et y déplacer F4.2 et ces extrémités de liaison ferait dire à la décomposition ce que les interfaces impliquent déjà.
  • Une fonction sur le satellite entier. F5 Operate Imaging Orbits est réalisée par 1 EO-1 Spacecraft. C'est correct pour une fonction qui est en réalité une boucle répétée sur d'autres fonctions : aucun sous-système n'en est seul responsable, et ses exigences (temps de revisite, durée de vie de la mission) sont de niveau système.

La matrice fait aussi apparaître des allocations qui méritent un second regard au vu des exigences. L'exigence 4.4 Downlink Encryption, ajoutée après la référence des exigences, est satisfaite par F8 Store Payload Data et la C&DH. Chiffrer des trames est une transformation différente de leur stockage ; une fonction comme Encrypt Downlink Frames sous L5 la porterait plus précisément et donnerait à l'équipe de test un seul endroit où regarder.

Les interfaces qui découlent de l'allocation

Chaque fonction de puissance étant allouée à une partie, les items entre ces fonctions montrent où l'EPS a besoin de chemins physiques. Un diagramme d'E/S physique de l'EPS trace une ligne partout où une fonction réalisée par une partie envoie un item à une fonction réalisée par une autre :

Chaque ligne est un échange fonctionnel que l'allocation a transformé en échange physique :

ItemDe la fonction (exécutant)Vers la fonction (exécutant)Porté par
Array Power OutputF3.1 (Solar Arrays)F3.3 (Power Distribution Unit)IF-20 Array Power
Battery Charge PowerF3.3 (Power Distribution Unit)F3.2 (Battery Pack)IF-21 Battery Power
Battery Discharge PowerF3.2 (Battery Pack)F3.3 (Power Distribution Unit)IF-21 Battery Power
Power TelemetryF3.3 (Power Distribution Unit)F10 Enter Safe Mode (C&DH)IF-09 Power Telemetry Link
Safe Mode CommandsF10 Enter Safe Mode (C&DH)F3.3 (Power Distribution Unit)IF-09 Power Telemetry Link
Solar IlluminationEnvironnement orbital (hors du système)F3.1 (Solar Arrays)IF-23 Sunlight Path

Le diagramme de blocs internes de l'EPS montre les mêmes échanges du côté physique : chaque connecteur entre parties, son statut et les items qu'il véhicule.

Trois points ressortent :

  • Chaque échange fonctionnel a un chemin. IF-20 et IF-21 existent parce que F3.1, F3.2 et F3.3 sont sur des parties différentes. Si la commande de charge avait été intégrée au bloc batterie, Battery Charge Power serait un échange interne au bloc, et IF-21 porterait à la place une puissance de bus non régulée : c'est l'allocation qui décide de ce que porte une interface.
  • Les tranches se rejoignent en une seule interface. Hormis la ligne d'alimentation de la C&DH, le seul échange entre les tranches EPS et C&DH est la boucle de télémesure et de télécommande de la gestion des pannes. Comme L6 Fault Management se trouve sur l'ordinateur de bord alors que les données de puissance viennent de l'unité de distribution de puissance, IF-09 est sur le chemin critique de l'exigence 4.3. Elle porte 0,01 Mbps de télémesure et 0,001 Mbps de télécommandes sur une liaison I2C de 0,4 Mbps, une marge confortable, mais sa latence et son comportement quand l'ordinateur de bord est occupé ou redémarre ont désormais leur place dans l'ICD.
  • La frontière est typée. IF-22 Regulated Bus aboutit au port 12 V Bus de l'EPS, typé par la 12 V Power Interface. Chaque sous-système qui consomme de la puissance se connecte à cette définition unique ; une modification de la tension du bus ou de sa limite de courant se fait donc en un seul endroit.

Un compromis ouvert sur la tranche puissance

L'allocation place aussi les budgets au bon endroit. L'exigence 3.1 demande aux panneaux solaires de générer au moins 30 W de puissance moyenne en orbite en fin de vie (c'était 28 W jusqu'à ce que la charge moyenne en orbite passe à 26 W après la revue de conception préliminaire). TC-06 a mesuré 75,1 W en crête ; avec la fraction éclairée de 0,62 et le rendement de chaîne de puissance de 0,6 du modèle, cela donne environ 27,9 W en moyenne orbitale, en deçà de 30 W. L'exigence est allouée via F3.1 aux panneaux solaires ; c'est donc là que tombe le déficit, et les options relèvent de l'architecture :

  • davantage de surface de panneaux ou des cellules à plus haut rendement sur L1 (masse, complexité du déploiement, coût) ;
  • une meilleure chaîne de puissance sur L3, pour relever le rendement de 0,6 (une autre topologie de régulateur dans l'unité de distribution de puissance) ;
  • moins de charge : une modification de l'exploitation qui photographie moins de cibles par orbite, ce qui déplace le problème vers les exigences de mission.

Chacune est une modification candidate de l'architecture physique ou du concept, et chacune peut être notée selon les mêmes critères. C'est le pont entre l'architecture et l'étude de compromis ; tant qu'il n'est pas refermé, le résultat de TC-06 reste suspect, comme le décrit le guide de la traçabilité.

Comment LML et SysML expriment les trois vues

LML (le Lifecycle Modeling Language) garde un vocabulaire réduit. Les fonctions sont des Actions, décomposées par decomposed by, qui échangent des Input/Outputs via generates et receives. Les composants sont des Assets, reliés par des Conduits qui transfèrent (transfer) les Input/Outputs. L'allocation est la relation performs (lue dans l'autre sens, performed by) d'un Asset vers une Action, et les exigences sont allouées avec satisfies. LML n'a pas de classe distincte pour les éléments logiques ; un projet qui veut une couche logique la modélise comme un second arbre d'Assets, marqué d'une étiquette comme Logical. C'est ce que fait EO-1 : son schéma ajoute une paire de relations, allocated to / allocated from, qui range chaque fonction dans son élément logique, de sorte que performed by continue de désigner la partie qui fait le travail, et chaque partie est liée (related to) à l'élément logique qu'elle réalise.

SysML dispose d'un concept d'allocation dédié. En SysML v1, les fonctions sont des activités ou des actions, les composants des blocs et des parts, et l'allocation est une dépendance «allocate», souvent représentée par des couloirs (partitions d'activité d'allocation) sur un diagramme d'activité ou par des compartiments d'allocation sur les blocs. Les architectures logique et physique sont généralement deux hiérarchies de blocs reliées par des allocations.

En SysML v2, les mêmes idées s'écrivent en texte. Les actions sont des action def et des action, les composants des part def et des part, et l'allocation est l'instruction allocate … to …; (ou perform, quand une part réalise une action). Le listing ci-dessous écrit les deux tranches d'EO-1 sous cette forme : les vues fonctionnelle, logique et physique, la chaîne d'allocation entre elles, et la boucle de télémesure qui devient IF-09.

package EO1Architecture {
    // Items the functions exchange
    item def PowerTelemetry;
    item def SafeModeCommands;

    // Functional architecture: what the system does
    action def GenerateAndStorePower {
        action convertSunlight;
        action storeEnergy;
        action regulateBus {
            out telemetry : PowerTelemetry;
            in commands : SafeModeCommands;
        }
    }
    action def EnterSafeMode {
        in telemetry : PowerTelemetry;
        out commands : SafeModeCommands;
    }
    action def StorePayloadData;

    // Logical architecture: solution-independent elements
    part def PowerGeneration;
    part def EnergyStorage;
    part def PowerConditioning;
    part def FaultManagement;
    part def DataStorage;

    // Physical architecture: the real components
    part def SolarArray;
    part def BatteryPack;
    part def PowerDistributionUnit;
    part def FlightComputer;

    part def Spacecraft {
        action power : GenerateAndStorePower;
        action safeMode : EnterSafeMode;
        action storeData : StorePayloadData;

        part logical {
            part generation : PowerGeneration;
            part storage : EnergyStorage;
            part conditioning : PowerConditioning;
            part faults : FaultManagement;
            part data : DataStorage;
        }
        part eps {
            part solarArrays : SolarArray[2];
            part battery : BatteryPack;
            part pdu : PowerDistributionUnit;
        }
        part cdh : FlightComputer;

        // Functions to logical elements
        allocate power.convertSunlight to logical.generation;
        allocate power.storeEnergy to logical.storage;
        allocate power.regulateBus to logical.conditioning;
        allocate safeMode to logical.faults;
        allocate storeData to logical.data;

        // Logical elements to physical components
        allocate logical.generation to eps.solarArrays;
        allocate logical.storage to eps.battery;
        allocate logical.conditioning to eps.pdu;
        allocate logical.faults to cdh;
        allocate logical.data to cdh;

        // The functional exchange becomes an interface between components
        flow of PowerTelemetry from power.regulateBus.telemetry to safeMode.telemetry;
        flow of SafeModeCommands from safeMode.commands to power.regulateBus.commands;
    }
}

Les deux lignes allocate logical.… to cdh; montrent d'un coup d'œil l'allocation de plusieurs éléments à la C&DH. Le tutoriel SysML v2 construit pas à pas le système électrique d'EO-1, y compris son allocation avec perform.

Liste de contrôle pour la revue d'architecture

  • Le projet a consigné les vues qu'il utilise (fonctionnelle et physique, ou fonctionnelle, logique et physique) et le sens de chaque terme.
  • Chaque fonction de plus bas niveau est allouée à exactement un élément logique ou un composant.
  • Chaque composant réalise au moins une fonction, et chaque élément logique est réalisé par au moins un composant.
  • L'exécutant de chaque fonction fait partie de l'exécutant de sa fonction parente.
  • Les composants qui réalisent de nombreuses fonctions ont été contrôlés pour la charge combinée : traitement, mémoire, puissance et contraintes temporelles.
  • Chaque item échangé entre fonctions situées sur des composants différents a un chemin physique, et chaque chemin porte au moins un item.
  • Chaque interface a un responsable, un statut et une capacité contrôlée par rapport à la somme de ce qu'elle porte.
  • Les exigences qui sont des contraintes sont allouées aux composants ou au système, pas à des fonctions inventées.
  • Les budgets de masse, de puissance et de données sont alloués aux composants et se consolident dans les limites du système, avec de la marge.
  • Au moins une architecture physique alternative a été envisagée pour chaque décision d'allocation majeure, et le choix est consigné avec sa justification.

Erreurs courantes

ErreurPourquoi c'est un problèmeCorrection
Commencer par le diagramme de blocs physiqueLa conception est figée avant que les fonctions ne soient connues ; les fonctions sont ensuite tordues pour entrer dans les boîtesConvenir d'abord des fonctions et de leurs échanges, puis allouer
Fonctions nommées d'après des composantsLes vues fonctionnelle et physique deviennent un seul dessin, et les alternatives ne peuvent pas être comparéesNommer les fonctions avec un verbe et un nom que n'importe quelle conception pourrait réaliser
Fonctions de plus bas niveau partagéesUne interface se cache dans la fonction et personne n'en est responsableDécomposer jusqu'à ce que chaque morceau ait un seul exécutant
Des sous-systèmes calqués un à un sur la liste des fonctionsChaque fonction reçoit son propre sous-système ; l'allocation ne décide donc rien et la vue physique répète la vue fonctionnellePartitionner selon des critères physiques comme l'emplacement, la technologie ou le fournisseur, et laisser les fonctions s'étendre sur plusieurs sous-systèmes (décomposées de sorte que chaque morceau ait toujours un seul exécutant)
Allocation tenue dans un tableur à côté du modèleLe tableau et le modèle divergent ; l'analyse d'impact donne de mauvaises réponsesEnregistrer l'allocation sous forme de liens dans le modèle et en générer la matrice
Interfaces listées à partir du plan de câblageLes échanges sans fil physique (radio, optique, thermique, logiciel) sont oubliésDéduire les interfaces des échanges fonctionnels alloués

L'essayer dans Holarch

Holarch est un outil MBSE avec des projets LML et des projets SysML v2. Dans un projet LML, les fonctions sont des Actions, les composants des Assets et l'allocation est performed by ; dans un projet SysML v2, ce sont des usages d'action et de part reliés par perform et allocate (voir projets SysML v2). L'exemple ci-dessus est le projet de démonstration CubeSat EO-1 : créez-le avec Gérer les projets → Fichiers de projet ▾ → Nouveau projet de démonstration → CubeSat (ingénierie système guidée). Pour revoir son architecture :

  1. Ouvrez Comportement → Analyse fonctionnelle pour l'arbre fonctionnel, le flux et le FFBD. Liez chaque fonction à son composant avec performed by dans la section Traçabilité de l'inspecteur, et cochez Sous-système pour afficher les exécutants dans le tableau d'allocation.
  2. Pour la matrice d'allocation, ouvrez Vérification → Matrice de traçabilité. Cliquez sur la puce Lignes et choisissez Hiérarchie sous un élément racine avec F0 Perform EO-1 Mission ; cliquez sur la puce Colonnes et choisissez Hiérarchie sous un élément racine avec 0 EO-1 Mission ; réglez Relation sur performed by et cochez Masquer les colonnes vides. Cliquez sur une cellule vide pour allouer, et sur Enregistrer la vue… pour conserver le réglage. Voir la documentation de la matrice de traçabilité.
  3. Ouvrez le Diagramme d'Asset de 1 EO-1 Spacecraft depuis la page Diagrammes pour l'architecture physique, puis basculez le sélecteur de type de diagramme sur Diagramme d'E/S physique. Ses lignes viennent des échanges alloués et des conduits ; les contrôles du diagramme (Contrôles dans la barre d'outils) listent tout échange qu'aucun conduit ne porte. Voir construire une architecture physique et contrôler ses interfaces.
  4. Double-cliquez sur EPS dans ce diagramme d'Asset pour ouvrir son propre diagramme, et basculez le sélecteur de type sur Diagramme d'E/S physique ou Diagramme de blocs internes pour les deux vues de l'EPS présentées ci-dessus.
  5. Pour la hiérarchie allouée, rouvrez le Diagramme d'Asset de 1 EO-1 Spacecraft, basculez le sélecteur de type sur Diagramme hiérarchique, cliquez sur Configurer dans la barre d'outils et cliquez sur le préréglage Hiérarchie d'allocation sous Options. Voir le préréglage Hiérarchie d'allocation.
  6. Ouvrez Interfaces → Diagrammes N² pour les échanges entre fonctions, et Interfaces → Registre des interfaces pour chaque conduit avec son statut et le contrôle de sa capacité.
  7. Lancez Vérification → Contrôles du modèle : Action.11 liste les actions qu'aucun asset ne réalise, Asset.11 les assets qui ne réalisent aucune action, et Asset.13 les assets qui échangent un item sans conduit commun.

À partir d'un flux sur un diagramme d'Action, Disposer ▾ → Générer un diagramme d'Asset construit un premier contexte physique à partir des exécutants et des items qu'ils échangent.

Pour aller plus loin