Écrire une définition de type SOME/IP

Lorsque vous définissez des mappages SOME/IP (Scalable service-oriented middleware over IP) dans VSIDL, vous décrivez la structure de la charge utile SOME/IP. Vous décrivez la structure à l'aide du message SomeIpType, qui vous permet de modéliser des primitives, des chaînes, des tableaux et des structures complexes.

Cette page explique comment écrire une définition de type SomeIpStruct, qui est utilisée dans les blocs type_definition pour les mappages d'événements et de méthodes.

Message SomeIpStruct

Un message SomeIpStruct représente une charge utile SOME/IP structurée composée de plusieurs champs. La structure définie ici est utilisée par le broker SOME/IP pour effectuer la traduction entre les octets SOME/IP bruts et les champs d'un message protobuf SDV.

Lorsque vous définissez une structure, vous configurez deux propriétés principales :

• length_field_size (facultatif) : spécifie la taille (en octets) du champ de longueur qui précède la structure dans la charge utile sérialisée. Les valeurs utilisées de l'énumération LengthFieldSize incluent ZERO (aucun champ de longueur), ONE, TWO et FOUR.
• field (répété) : liste des champs qui composent la structure.

Définir les champs de structure

Chaque champ dans SomeIpStruct nécessite les éléments suivants :

• field_name : nom du champ. Il doit correspondre exactement au nom de champ correspondant défini dans le message protobuf SDV pour garantir une traduction correcte du message.
• field_type : type de données SOME/IP du champ (SomeIpType). Il peut s'agir d'une primitive, d'une chaîne, d'un tableau ou d'une autre structure imbriquée.

Écrire des types de champs SomeIpType

Le bloc field_type configure le type de données spécifique à l'aide de l'une des variantes suivantes :

• Types primitifs : utilisez someip_primitive avec des valeurs telles que UINT8, UINT32, INT32, FLOAT32 et BOOL.
• Chaînes : utilisez someip_string et spécifiez l'encodage (par exemple, UTF_8, UTF_16_LE) et les informations de longueur (fixed_length ou length_field_size).
• Tableaux : utilisez someip_array et définissez array_type (qui est un autre SomeIpType récursif), ainsi que les informations de longueur (fixed_length ou length_field_size).
• Structures imbriquées : utilisez someip_struct pour intégrer une autre définition de structure de manière récursive.

Exemple : Écrire une définition de type de structure

Voici un exemple concret d'écriture d'un SomeIpStruct dans un bloc type_definition. Cette charge utile contient un entier non signé de 8 bits nommé interval et un entier non signé de 32 bits nommé counter :

type_definition {
  # No length field precedes this struct
  length_field_size: ZERO

  # First field: interval
  field {
    field_name: "interval"
    field_type {
      someip_primitive: UINT8
    }
  }

  # Second field: counter
  field {
    field_name: "counter"
    field_type {
      someip_primitive: UINT32
    }
  }
}

Ajouter des types complexes

Pour inclure un champ de chaîne de longueur dynamique et un tableau dans la structure, ajoutez des champs comme suit :

field {
  field_name: "status_message"
  field_type {
    someip_string {
      string_encoding: UTF_8
      length_field_size: FOUR
    }
  }
}
field {
  field_name: "measurements"
  field_type {
    someip_array {
      length_field_size: FOUR
      array_type { someip_primitive: FLOAT32 }
    }
  }
}