IoTFleetWise / Paginator / ListDecoderManifestSignals

ListDecoderManifestSignals#

class IoTFleetWise.Paginator.ListDecoderManifestSignals#

paginator = client.get_paginator('list_decoder_manifest_signals')

paginate(**kwargs)#

Creates an iterator that will paginate through responses from IoTFleetWise.Client.list_decoder_manifest_signals().

Request Syntax

response_iterator = paginator.paginate(
    name='string',
    PaginationConfig={
        'MaxItems': 123,
        'PageSize': 123,
        'StartingToken': 'string'
    }
)

Parameters:

name (string) –
[REQUIRED]

The name of the decoder manifest to list information about.
PaginationConfig (dict) –
A dictionary that provides parameters to control pagination.
- MaxItems (integer) –
  
  The total number of items to return. If the total number of items available is more than the value specified in max-items then a NextToken will be provided in the output that you can use to resume pagination.
- PageSize (integer) –
  
  The size of each page.
- StartingToken (string) –
  
  A token to specify where to start paginating. This is the NextToken from a previous response.

Return type:

dict

Returns:

Response Syntax

{
    'signalDecoders': [
        {
            'fullyQualifiedName': 'string',
            'type': 'CAN_SIGNAL'|'OBD_SIGNAL'|'MESSAGE_SIGNAL',
            'interfaceId': 'string',
            'canSignal': {
                'messageId': 123,
                'isBigEndian': True|False,
                'isSigned': True|False,
                'startBit': 123,
                'offset': 123.0,
                'factor': 123.0,
                'length': 123,
                'name': 'string'
            },
            'obdSignal': {
                'pidResponseLength': 123,
                'serviceMode': 123,
                'pid': 123,
                'scaling': 123.0,
                'offset': 123.0,
                'startByte': 123,
                'byteLength': 123,
                'bitRightShift': 123,
                'bitMaskLength': 123
            },
            'messageSignal': {
                'topicName': 'string',
                'structuredMessage': {
                    'primitiveMessageDefinition': {
                        'ros2PrimitiveMessageDefinition': {
                            'primitiveType': 'BOOL'|'BYTE'|'CHAR'|'FLOAT32'|'FLOAT64'|'INT8'|'UINT8'|'INT16'|'UINT16'|'INT32'|'UINT32'|'INT64'|'UINT64'|'STRING'|'WSTRING',
                            'offset': 123.0,
                            'scaling': 123.0,
                            'upperBound': 123
                        }
                    },
                    'structuredMessageListDefinition': {
                        'name': 'string',
                        'memberType': {'... recursive ...'},
                        'listType': 'FIXED_CAPACITY'|'DYNAMIC_UNBOUNDED_CAPACITY'|'DYNAMIC_BOUNDED_CAPACITY',
                        'capacity': 123
                    },
                    'structuredMessageDefinition': [
                        {
                            'fieldName': 'string',
                            'dataType': {'... recursive ...'}
                        },
                    ]
                }
            }
        },
    ],
    'NextToken': 'string'
}

Response Structure

(dict) –
- signalDecoders (list) –
  
  Information about a list of signals to decode.
  - (dict) –
    
    Information about a signal decoder.
    - fullyQualifiedName (string) –
      
      The fully qualified name of a signal decoder as defined in a vehicle model.
    - type (string) –
      
      The network protocol for the vehicle. For example, CAN_SIGNAL specifies a protocol that defines how data is communicated between electronic control units (ECUs). OBD_SIGNAL specifies a protocol that defines how self-diagnostic data is communicated between ECUs.
    - interfaceId (string) –
      
      The ID of a network interface that specifies what network protocol a vehicle follows.
    - canSignal (dict) –
      
      Information about signal decoder using the Controller Area Network (CAN) protocol.
      - messageId (integer) –
        
        The ID of the message.
      - isBigEndian (boolean) –
        
        Whether the byte ordering of a CAN message is big-endian.
      - isSigned (boolean) –
        
        Whether the message data is specified as a signed value.
      - startBit (integer) –
        
        Indicates the beginning of the CAN signal. This should always be the least significant bit (LSB).
        
        This value might be different from the value in a DBC file. For little endian signals, startBit is the same value as in the DBC file. For big endian signals in a DBC file, the start bit is the most significant bit (MSB). You will have to calculate the LSB instead and pass it as the startBit.
      - offset (float) –
        
        The offset used to calculate the signal value. Combined with factor, the calculation is value = raw_value * factor + offset.
      - factor (float) –
        
        A multiplier used to decode the CAN message.
      - length (integer) –
        
        How many bytes of data are in the message.
      - name (string) –
        
        The name of the signal.
    - obdSignal (dict) –
      
      Information about signal decoder using the On-board diagnostic (OBD) II protocol.
      - pidResponseLength (integer) –
        
        The length of the requested data.
      - serviceMode (integer) –
        
        The mode of operation (diagnostic service) in a message.
      - pid (integer) –
        
        The diagnostic code used to request data from a vehicle for this signal.
      - scaling (float) –
        
        A multiplier used to decode the message.
      - offset (float) –
        
        The offset used to calculate the signal value. Combined with scaling, the calculation is value = raw_value * scaling + offset.
      - startByte (integer) –
        
        Indicates the beginning of the message.
      - byteLength (integer) –
        
        The length of a message.
      - bitRightShift (integer) –
        
        The number of positions to shift bits in the message.
      - bitMaskLength (integer) –
        
        The number of bits to mask in a message.
    - messageSignal (dict) –
      
      The decoding information for a specific message which supports higher order data types.
      - topicName (string) –
        
        The topic name for the message signal. It corresponds to topics in ROS 2.
      - structuredMessage (dict) –
        
        The structured message for the message signal. It can be defined with either a primitiveMessageDefinition, structuredMessageListDefinition, or structuredMessageDefinition recursively.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: primitiveMessageDefinition, structuredMessageListDefinition, structuredMessageDefinition. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        primitiveMessageDefinition (dict) –
        
        Represents a primitive type node of the complex data structure.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: ros2PrimitiveMessageDefinition. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        ros2PrimitiveMessageDefinition (dict) –
        
        Information about a PrimitiveMessage using a ROS 2 compliant primitive type message of the complex data structure.
        
        primitiveType (string) –
        
        The primitive type (integer, floating point, boolean, etc.) for the ROS 2 primitive message definition.
        
        offset (float) –
        
        The offset used to calculate the signal value. Combined with scaling, the calculation is value = raw_value * scaling + offset.
        
        scaling (float) –
        
        A multiplier used to decode the message.
        
        upperBound (integer) –
        
        An optional attribute specifying the upper bound for STRING and WSTRING.
        
        structuredMessageListDefinition (dict) –
        
        Represents a list type node of the complex data structure.
        
        name (string) –
        
        The name of the structured message list definition.
        
        memberType (dict) –
        
        The member type of the structured message list definition.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: primitiveMessageDefinition, structuredMessageListDefinition, structuredMessageDefinition. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        listType (string) –
        
        The type of list of the structured message list definition.
        
        capacity (integer) –
        
        The capacity of the structured message list definition when the list type is FIXED_CAPACITY or DYNAMIC_BOUNDED_CAPACITY.
        
        structuredMessageDefinition (list) –
        
        Represents a struct type node of the complex data structure.
        
        (dict) –
        
        Represents a StructureMessageName to DataType map element.
        
        fieldName (string) –
        
        The field name of the structured message. It determines how a data value is referenced in the target language.
        
        dataType (dict) –
        
        The data type.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: primitiveMessageDefinition, structuredMessageListDefinition, structuredMessageDefinition. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
- NextToken (string) –
  
  A token to resume pagination.