Chaîne d'outils de conception de la sécurité

Utilisez la chaîne d'outils de conception de sécurité pour fournir une solution de surveillance de la sécurité générée à partir d'un document de conception Figma. Utilisez cette série d'outils dans l'ordre.

Le compilateur de conception de sécurité produit des artefacts de sécurité pour générer le code ultérieur permettant de créer le moniteur de sécurité. La séparation entre la compilation de la conception et la génération de code permet au générateur de code d'atteindre un niveau TCL-3 selon la norme ISO-26262.

Figure 1. Chaîne d'outils de conception de la sécurité.

Une fois que le compilateur a généré des artefacts, la chaîne d'outils crée un rapport qu'un ingénieur en sécurité OEM peut inspecter pour valider les artefacts générés à partir de la conception Figma.

Figure 2. Workflow de la chaîne d'outils de conception de la sécurité.

Concevoir des entrées de compilateur

Le document de conception sérialisé représente une conception d'UI importée à partir d'un outil de conception et traitée avec un schéma de boîte à outils. Le fichier contient les informations suivantes, analysées à partir de la conception :

• Arborescence complète d'une conception
• Images et composants
• Métadonnées telles que le nom, la version et la date de dernière modification

Les nœuds racines de la conception doivent être définis dans la liste des nœuds et doivent être les nœuds racines des éléments liés à la sécurité identifiés dans la conception.

Ce fichier s'intègre à Android Automotive OS pour afficher le bloc d'instruments et les éléments non liés à la sécurité avec un moteur de rendu à haute disponibilité (HAR) exécuté sur SDV Media en tant que calque pour afficher les éléments liés à la sécurité à l'utilisateur.

Le compilateur de conception utilise les personnalisations DesignCompose pour générer une sortie permettant d'activer/désactiver la visibilité des éléments critiques pour la sécurité dans la conception. La conception est rendue sans interface graphique avec Impeller. Entre les modifications de personnalisation, le système envoie des commandes de capture d'écran au backend de rendu pour générer des artefacts d'image.

Figure 3. Exemple de fichier de conception Figma pour créer un moniteur de sécurité.

Répertoire de sortie

Il s'agit de l'emplacement du système de fichiers local où le compilateur stocke les artefacts générés.

Fichier de configuration JSON

Le fichier de configuration JSON est généralement créé par un ingénieur sécurité de l'OEM. Il contient des métadonnées qui capturent les informations liées à la sécurité du véhicule qui ne sont pas capturées dans une conception d'UI. Ce fichier contient les données suivantes :

• Élément de conception désigné comme racine de l'affichage lié à la sécurité. La taille de cet élément de conception est adaptée à l'écran du véhicule. La taille doit avoir la même résolution que l'écran. Tous les éléments liés à la sécurité doivent être des descendants de cet élément. Ils ne doivent pas nécessairement être des descendants directs, mais être imbriqués dans des nœuds intermédiaires. Cette racine est l'objet de nœud racine, et son nom doit correspondre à un nœud du document de conception.

• Ciblez l'affichage pour la conception. Pour prendre en charge les UI avec des éléments sur plusieurs écrans, le fichier de configuration peut spécifier plusieurs conceptions, chacune étant destinée à être affichée sur un écran distinct.

• Dictionnaire des noms de signaux de bus du véhicule et des éléments d'UI associés. Les clés et les valeurs de ce dictionnaire sont les suivantes :

  • Clés : nom du signal du bus du véhicule qui doit avoir une signification pour que l'élément d'interface utilisateur associé s'affiche lorsque ce signal est actif. Lorsque le signal est inactif, l'élément d'interface utilisateur associé n'est pas affiché.

  • Valeurs : ID de nœud Figma pour l'élément lié à la sécurité régi par le signal de bus du véhicule.

Consultez cet exemple de fichier de configuration JSON :

{
  "documents" : [
    {
    "rootnode" : "#Stage",
    "display_id" : 1,
    "document_id": "GLJJrR1JI4HVEjL1qB40zq",
    "states" : {
      "abs": "#cluster/telltale/abs",
      "airbag": "#cluster/telltale/airbag",
      "low_tire_pressure": "#cluster/telltale/low-tire-pressure",
      "brake": "#cluster/telltale/brake",
      "traction": "#cluster/telltale/traction",
      "lowbeam": "#cluster/telltale/lowbeam",
      "hibeam": "#cluster/telltale/hibeam",
      "park_lights": "#cluster/telltale/park-lights",
      "fog_lights": "#cluster/telltale/fog-lights",
      "seatbelts" : "#cluster/telltale/no-seatbelt"
    }
    }
  ]
  ,
  "displays": [
    {
      "id": 1,
      "width": 1920,
      "height": 720
    }
  ]
 }

Exécuter le compilateur de conception

Pour exécuter le compilateur de conception :

/path/to/safety-design-compiler -c path/to/<input-file>.json
-o path/to/output_directory

Les entrées du compilateur de conception sont décrites dans ce tableau :

Concevoir la sortie du compilateur

Le compilateur de conception génère et enregistre la sortie dans le répertoire de sortie spécifié lorsque vous appelez l'outil de compilation. Cette sortie génère les fichiers d'en-tête utilisés pour définir les tests de pixels d'exécution dans le Safety Monitor et pour générer le rapport lisible par l'homme. La sortie du compilateur de conception est fournie dans un fichier Zip contenant les éléments suivants :

• Fichier de métadonnées data.json à la racine des composants exportés pour décrire la structure de la conception exportée. Tous les chemins d'accès du fichier sont relatifs à ce fichier.

• Série d'images d'éléments d'interface utilisateur isolés montrant les éléments d'interface utilisateur liés à la sécurité à l'état actif, qui sont utilisés lors de la génération de code ultérieure. Le canal alpha de ces images contient des informations sur les pixels qui n'ont pas d'incidence sur la sécurité.

• Série d'images d'interface utilisateur complète montrant les éléments d'interface utilisateur liés à la sécurité dans les états actif et inactif à utiliser lors du test du code généré.

• Version mise à jour du document Figma sérialisé utilisé par le compilateur comme entrée. HAR marque et met à jour les nœuds révélateurs spécifiés dans Config.json pour un traitement ultérieur en définissant le flag RenderOptions::PixelPerfect dans le schéma de la boîte à outils.

Cette figure affiche un fichier de conception Figma.

Figure 4. Contenu du fichier ZIP

Créer le fichier d'entrée

Créez un fichier d'entrée data.json pour le générateur de moniteur de sécurité. La sortie est structurée sous forme de tableau pour contenir les données dimensionnelles et un lien vers l'image pour chaque élément d'affichage lié à la sécurité. La structure de ce fichier de sortie est décrite dans le tableau suivant :

Cette section fournit un exemple de fichier data.json généré :

{
 "static_ui_elements": [
   {
     "x": 71,
     "y": 663,
     "width": 38,
     "height": 47,
     "name": "cluster/telltale/no-seatbelt"
   },
   {
     "x": 149,
     "y": 667,
     "width": 40,
     "height": 39,
     "name": "cluster/telltale/low-tire-pressure"
   },
      {
     "x": 1727,
     "y": 676,
     "width": 43,
     "height": 27,
     "name": "cluster/telltale/hibeam"
   },
   {
     "x": 1810,
     "y": 675,
     "width": 43,
     "height": 30,
     "name": "cluster/telltale/lowbeam"
   },
  ...
  ...
 ],
 "screen": {
   "width": 1920,
   "height": 720
 },
 "build": {
   "figma_document_id": "taQnsdPS96wZY8dB1TbzOH",
   "design_compiler_version": "0.1.0"
 }
}

Images de conception exportées

Le système affiche et enregistre les images des nœuds liés à la sécurité dans une structure de répertoires imbriquée en fonction de leur nom dans le document de conception sérialisé.

Figure 5. Images de validation.

Le système génère des images d'informations sur les éléments liés à la sécurité pour chaque voyant spécifié. Ces images contiennent les pixels attendus de l'élément essentiel à la sécurité lorsqu'il est visible à l'écran. Le moniteur de sécurité peut ignorer les pixels transparents de ces images pour les tests de pixels d'exécution.

Le système génère également des images de test et de validation de l'UI. Il affiche des captures d'écran de l'intégralité de l'UI avec chaque signal individuel et les fournit pour générer un rapport lisible par l'homme, afin que les ingénieurs en sécurité puissent examiner et approuver la configuration de sécurité.

Vous pouvez également utiliser ces images pour tester ultérieurement le moniteur de sécurité. Le système génère des images de validation pour tous les voyants en position "On" et "Off".

Ces images illustrent la conception avec tous les éléments liés à la sécurité, actifs et inactifs.

Figure 6 et Figure 7. Éléments actifs et inactifs liés à la sécurité.

La figure 8 montre l'image d'informations importantes sur la sécurité pour le voyant de non-port de la ceinture de sécurité :

Figure 8. Voyant de ceinture de sécurité non bouclée.

La figure 9 montre l'image de test et de validation de l'interface utilisateur pour le voyant.

Figure 9. Tests et validation de l'UI pour le telltale.

Le système génère des images de validation pour chaque élément du dossier d'artefacts compilés. Le système traite ces images lors de l'étape de génération de code et les ajoute à un fichier d'en-tête à utiliser pour les tests de pixels d'exécution dans le moniteur de sécurité.

Générateur de rapports lisibles par l'humain

Après avoir généré les artefacts à partir d'un document Figma, vous pouvez générer un rapport lisible par un humain. Le générateur de rapports se trouve dans utils/human-readable-report-generator.

Le système résume les artefacts des nœuds liés à la sécurité générés par le compilateur de conception dans un fichier HTML, y compris une capture d'écran de l'UI avec le nœud actif. Vous pouvez examiner les artefacts compilés avant de créer le moniteur de sécurité.

Exécutez le générateur de rapports à partir de la ligne de commande :

cargo run --bin human-readable-report-generator -- -d /path/to/data.json
-o /path/to/output_folder

Ce tableau décrit les entrées du générateur de rapports lisibles par l'utilisateur.

Outil d'approbation de sécurité

Pour générer un jeton d'approbation, un ingénieur en sécurité peut exécuter le script d'approbation de sécurité sur le output.json après avoir examiné le rapport lisible par l'humain. Cet outil se trouve également dans utils/human-readable-report-generator. Exemple :

cargo run --bin approve-hrr -- -f /path/to/compiler_inspection_output.html -n
"Your Name" -e youremail@domain.com -o output/path

Figure 10. Exemple de rapport HTML.

Cette section décrit les entrées de l'outil d'approbation de sécurité.

Cette section présente un exemple de approval_file.json.

{
    "approver_name": //Name of the approver
    "approver_email": //Email of the approver
    "file_hash": //SHA-256 hash generated against the human readable report.
}

Écran de contrôle de référence

Le moniteur de sécurité de référence est un service basé sur Rust qui se trouve dans reference/safety-monitor. Le moniteur utilise les artefacts générés par le compilateur de conception pour surveiller l'état du système et assurer la conformité de la sécurité de l'écran.

Le moniteur s'exécute en tant que binaire autonome (har_safety_monitor) et utilise le chemin d'accès au fichier data.json et le chemin d'accès de base pour les artefacts en tant qu'arguments.

/path/to/har_safety_monitor --data-json-path /path/to/data.json
--artifact-base-path /path/to/artifacts

Le moniteur effectue les tâches suivantes :

• Chargement des artefacts : charge data.json pour identifier les éléments d'interface utilisateur liés à la sécurité, ainsi que leurs positions et dimensions attendues.
• Comparaison des images de référence : compare le contenu actuel de l'écran avec les images de référence des éléments essentiels à la sécurité générées par le compilateur.
• Intégration des données du véhicule : se connecte aux sources de données du véhicule pour déterminer l'état attendu de chaque voyant.
• Détection des incohérences : enregistre une erreur en cas d'incohérence entre ce qui est attendu sur la base des données du véhicule et ce qui est visible à l'écran.

Le moniteur de sécurité est conçu pour être créé et déployé dans l'image système, généralement dans un APEX dédié.