API Documentation: autosar_data.abstraction.communication¶

communication ¶

Cluster `module-attribute` ¶

Cluster: TypeAlias = Union[
    CanCluster, FlexrayCluster, EthernetCluster
]

CommunicationController `module-attribute` ¶

CommunicationController: TypeAlias = Union[
    CanCommunicationController,
    FlexrayCommunicationController,
    EthernetCommunicationController,
]

Frame `module-attribute` ¶

Frame: TypeAlias = Union[CanFrame, FlexrayFrame]

IPdu `module-attribute` ¶

IPdu: TypeAlias = Union[
    ContainerIPdu,
    DcmIPdu,
    GeneralPurposeIPdu,
    ISignalIPdu,
    SecuredIPdu,
    NPdu,
    MultiplexedIPdu,
]

Pdu `module-attribute` ¶

Pdu: TypeAlias = Union[
    ContainerIPdu,
    DcmIPdu,
    GeneralPurposePdu,
    GeneralPurposeIPdu,
    NPdu,
    ISignalIPdu,
    NmPdu,
    SecuredIPdu,
    MultiplexedIPdu,
]

PhysicalChannel `module-attribute` ¶

PhysicalChannel: TypeAlias = Union[
    CanPhysicalChannel,
    FlexrayPhysicalChannel,
    EthernetPhysicalChannel,
]

TransformationTechnologyConfig `module-attribute` ¶

TransformationTechnologyConfig: TypeAlias = Union[
    ComTransformationTechnologyConfig,
    E2ETransformationTechnologyConfig,
    SomeIpTransformationTechnologyConfig,
    GenericTransformationTechnologyConfig,
]

CanAddressingMode ¶

The addressing mode for a CAN frame

Extended `instance-attribute` ¶

Extended: CanAddressingMode

Standard `instance-attribute` ¶

Standard: CanAddressingMode

CanCluster ¶

CanCluster(element: Element)

A CanCluster contains all configuration items associated with a CAN network. The cluster connects multiple ECUs.

baudrate `instance-attribute` ¶

baudrate: int

get or set the baudrate of the cluster

can_fd_baudrate `instance-attribute` ¶

can_fd_baudrate: Optional[int]

get or set the CAN FD baudrate of the cluster

can_xl_baudrate `instance-attribute` ¶

can_xl_baudrate: Optional[int]

get or set the CAN XL baudrate of the cluster

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

physical_channel `instance-attribute` ¶

physical_channel: Optional[CanPhysicalChannel]

get or set the settings of this CanCluster with new values for the baudrates

system `instance-attribute` ¶

system: Optional[System]

get the System that contains this CanCluster

create_physical_channel ¶

create_physical_channel(
    channel_name: str,
) -> CanPhysicalChannel

Create a new physical channel for the cluster

A can cluster must contain exactly one physical channel; trying to add a second one triggers an error.

CanCommunicationConnector ¶

CanCommunicationConnector(element: Element)

A connector between a [CanCommunicationController] in an ECU and a [CanPhysicalChannel]

controller `instance-attribute` ¶

controller: CanCommunicationController

Get the controller of the CommunicationConnector

ecu_instance `instance-attribute` ¶

ecu_instance: EcuInstance

EcuInstance that contains this CommunicationConnector

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

CanCommunicationController ¶

CanCommunicationController(element: Element)

An EcuInstance needs a CanCommunicationController in order to connect to a CAN cluster.

ecu_instance `instance-attribute` ¶

ecu_instance: EcuInstance

Get the EcuInstance that contains this CanCommunicationController

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

connect_physical_channel ¶

connect_physical_channel(
    connection_name: str, can_channel: CanPhysicalChannel
) -> CanCommunicationConnector

Connect this [CanCommunicationController] inside an [EcuInstance] to a [CanPhysicalChannel] in the [crate::System]

Creates a [CanCommunicationConnector] in the [EcuInstance] that contains this [CanCommunicationController].

This function establishes the relationships

[CanPhysicalChannel] -> [CanCommunicationConnector]
[CanCommunicationConnector] -> [CanCommunicationController]

connected_channels ¶

connected_channels() -> Iterator[CanPhysicalChannel]

return an iterator over the [CanPhysicalChannel]s connected to this controller

CanFrame ¶

CanFrame(element: Element)

A frame on a CAN bus

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

length of the frame

name `instance-attribute` ¶

name: str

frame_triggerings ¶

frame_triggerings() -> List[CanFrameTriggering]

List all [FrameTriggering]s using this frame

map_pdu ¶

map_pdu(
    pdu: Pdu,
    start_position: int,
    byte_order: ByteOrder,
    /,
    *,
    update_bit: Optional[int] = None,
) -> PduToFrameMapping

map a PDU to the frame

mapped_pdus ¶

mapped_pdus() -> Iterator[Pdu]

returns an iterator over all PDUs in the frame

CanFrameTriggering ¶

CanFrameTriggering(element: Element)

The frame triggering connects a frame to a physical channel

addressing_mode `instance-attribute` ¶

addressing_mode: Optional[CanAddressingMode]

set the addressing mode for this frame triggering

element `instance-attribute` ¶

element: Element

frame `instance-attribute` ¶

frame: Optional[CanFrame]

get the frame associated with this frame triggering

frame_type `instance-attribute` ¶

frame_type: Optional[CanFrameType]

frame type for this frame triggering

identifier `instance-attribute` ¶

identifier: Optional[int]

can id associated with this frame

name `instance-attribute` ¶

name: str

physical_channel `instance-attribute` ¶

physical_channel: CanPhysicalChannel

get the physical channel that contains this frame triggering

connect_to_ecu ¶

connect_to_ecu(
    ecu: EcuInstance, direction: CommunicationDirection
) -> FramePort

connect this frame triggering to an ECU

The direction parameter specifies if the communication is incoming or outgoing

frame_ports ¶

frame_ports() -> Iterator[FramePort]

iterate over all frame ports for this frame triggering

pdu_triggerings ¶

pdu_triggerings() -> Iterator[PduTriggering]

iterate over all PDU triggerings referenced by the frame triggering

CanFrameType ¶

The type of a CAN frame

Any `instance-attribute` ¶

Any: CanFrameType

Can20 `instance-attribute` ¶

Can20: CanFrameType

CanFd `instance-attribute` ¶

CanFd: CanFrameType

CanNmCluster ¶

CanNmCluster(element: Element)

Can specific NmCluster attributes

channel_sleep_master `instance-attribute` ¶

channel_sleep_master: Optional[bool]

set or remove the nmChannelSleepMaster flag

communication_cluster `instance-attribute` ¶

communication_cluster: Optional[CanCluster]

get or set the referenced CanCluster

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

nm_busload_reduction_active `instance-attribute` ¶

nm_busload_reduction_active: Optional[bool]

nmBusloadReductionActive flag

nm_immediate_nm_transmissions `instance-attribute` ¶

nm_immediate_nm_transmissions: Optional[int]

nmImmediateNmTransmissions value

nm_message_timeout_time `instance-attribute` ¶

nm_message_timeout_time: Optional[float]

get or set the nmMessageTimeoutTime

nm_msg_cycle_time `instance-attribute` ¶

nm_msg_cycle_time: Optional[float]

get or set the nmMsgCycleTime

nm_network_timeout `instance-attribute` ¶

nm_network_timeout: Optional[float]

get or set the nmNetworkTimeout

nm_remote_sleep_indication_time `instance-attribute` ¶

nm_remote_sleep_indication_time: Optional[float]

get or set the nmRemoteSleepIndicationTime

nm_repeat_message_time `instance-attribute` ¶

nm_repeat_message_time: Optional[float]

get or set the nmRepeatMessageTime

nm_wait_bus_sleep_time `instance-attribute` ¶

nm_wait_bus_sleep_time: Optional[float]

get or set the nmWaitBusSleepTime

node_detection_enabled `instance-attribute` ¶

node_detection_enabled: Optional[bool]

get or set the nmNodeDetectionEnabled flag

node_id_enabled `instance-attribute` ¶

node_id_enabled: Optional[bool]

get or set the nmNodeIdEnabled flag

pnc_cluster_vector_length `instance-attribute` ¶

pnc_cluster_vector_length: Optional[int]

get or set the pncClusterVectorLength

pnc_participation `instance-attribute` ¶

pnc_participation: Optional[bool]

get or set the nmPncParticipation flag

repeat_msg_ind_enabled `instance-attribute` ¶

repeat_msg_ind_enabled: Optional[bool]

get or set the nmRepeatMsgIndEnabled flag

synchronizing_network `instance-attribute` ¶

synchronizing_network: Optional[bool]

get or set the nmSynchronizingNetwork flag

create_can_nm_node ¶

create_can_nm_node(
    name: str,
    controller: CanCommunicationController,
    nm_ecu: NmEcu,
) -> CanNmNode

add a CanNmNode to the cluster

nm_nodes ¶

nm_nodes() -> Iterator[CanNmNode]

iterate over all NmNodes in this cluster

CanNmClusterCoupling ¶

CanNmClusterCoupling(element: Element)

A CanNmClusterCoupling couples multiple CanNmClusters, and contains CAN specific settings.

element `instance-attribute` ¶

element: Element

nm_busload_reduction_enabled `instance-attribute` ¶

nm_busload_reduction_enabled: Optional[bool]

get or set the nmBusloadReductionEnabled flag

nm_immediate_restart_enabled `instance-attribute` ¶

nm_immediate_restart_enabled: Optional[bool]

get or set the nmImmediateRestartEnabled flag

add_coupled_cluster ¶

add_coupled_cluster(cluster: CanNmCluster) -> None

add a reference to a coupled NmCluster

coupled_clusters ¶

coupled_clusters() -> Iterator[CanNmCluster]

iterate over all coupled NmClusters

CanNmClusterSettings ¶

CanNmClusterSettings(
    *,
    nm_busload_reduction_active: bool,
    nm_immediate_nm_transmissions: int,
    nm_message_timeout_time: float,
    nm_msg_cycle_time: float,
    nm_network_timeout: float,
    nm_remote_sleep_indication_time: float,
    nm_repeat_message_time: float,
    nm_wait_bus_sleep_time: float,
)

Mandatory settings for a CanNmCluster

These settings are mandatory for a CanNmCluster and must be set during creation. Additional optional settings can be set using the CanNmCluster methods.

nm_busload_reduction_active `instance-attribute` ¶

nm_busload_reduction_active: bool

nmBusloadReductionActive: Determines if bus load reduction for the respective CanNm channel is active.

nm_immediate_nm_transmissions `instance-attribute` ¶

nm_immediate_nm_transmissions: int

nmImmediateNmTransmissions: Defines the number of immediate NmPdus which shall be transmitted. If the value is zero no immediate NmPdus are transmitted.

nm_message_timeout_time `instance-attribute` ¶

nm_message_timeout_time: float

nmMessageTimeoutTime: Timeout of an NmPdu in seconds.

nm_msg_cycle_time `instance-attribute` ¶

nm_msg_cycle_time: float

nmMsgCycleTime: Period of a NmPdu in seconds

nm_network_timeout `instance-attribute` ¶

nm_network_timeout: float

nmNetworkTimeout: Network Timeout for NmPdus in seconds.

nm_remote_sleep_indication_time `instance-attribute` ¶

nm_remote_sleep_indication_time: float

nmRemoteSleepIndicationTime: Timeout for Remote Sleep Indication in seconds.

nm_repeat_message_time `instance-attribute` ¶

nm_repeat_message_time: float

nmRepeatMessageTime: Timeout for Repeat Message State in seconds.

nm_wait_bus_sleep_time `instance-attribute` ¶

nm_wait_bus_sleep_time: float

nmWaitBusSleepTime: Timeout for bus calm down phase in seconds.

CanNmNode ¶

CanNmNode(element: Element)

A CanNmNode represents a node in a CanNmCluster.

The node connects to a CanCommunicationController and an NmEcu.

communication_controller `instance-attribute` ¶

communication_controller: Optional[
    CanCommunicationController
]

get or set the referenced CanCommunicationController

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

nm_ecu `instance-attribute` ¶

nm_ecu: Optional[NmEcu]

get or set the referenced NmEcu

node_id `instance-attribute` ¶

node_id: Optional[int]

get or set the nmNodeId This value is optional; if it is set to Some(x) the value is created, if it is set to None the value is removed.

passive_mode `instance-attribute` ¶

passive_mode: Optional[bool]

get or set ot remove the nmPassiveModeEnabled flag

This flag is optional; if it is set to Some(x) the value is created, if it is set to None the value is removed.

add_rx_nm_pdu ¶

add_rx_nm_pdu(nm_pdu: NmPdu) -> None

add an Rx NmPdu

Every NmNode must have at least one Rx NmPdu

add_tx_nm_pdu ¶

add_tx_nm_pdu(nm_pdu: NmPdu) -> None

add a Tx NmPdu

Active NmNodes must have at least one Tx NmPdu, while passive NmNodes may have none.

rx_nm_pdus ¶

rx_nm_pdus() -> Iterator[NmPdu]

iterate over all RX NmPdus

tx_nm_pdus ¶

tx_nm_pdus() -> Iterator[NmPdu]

iterate over all TX NmPdus

CanPhysicalChannel ¶

CanPhysicalChannel(element: Element)

The `CanPhysicalChannel contains all of the communication on a CAN network

cluster `instance-attribute` ¶

cluster: CanCluster

get the cluster containing this physical channel

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

frame_triggerings ¶

frame_triggerings() -> Iterator[CanFrameTriggering]

iterate over all frame triggerings of this physical channel

pdu_triggerings ¶

pdu_triggerings() -> Iterator[PduTriggering]

iterate over all PDU triggerings of this physical channel

signal_triggerings ¶

signal_triggerings() -> Iterator[ISignalTriggering]

iterate over all signal triggerings of this physical channel

trigger_frame ¶

trigger_frame(
    frame: CanFrame,
    identifier: int,
    addressing_mode: CanAddressingMode,
    frame_type: CanFrameType,
) -> CanFrameTriggering

add a trigger for a CAN frame in this physical channel

CanTpAddress ¶

CanTpAddress(element: Element)

A CanTpAddress represents a logical address in the CanTp module

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

tp_address `instance-attribute` ¶

tp_address: Optional[int]

get or set the address of the CanTpAddress

CanTpAddressingFormat ¶

The addressing format of a CanTpConnection

Extended `instance-attribute` ¶

Extended: CanTpAddressingFormat

Mixed `instance-attribute` ¶

Mixed: CanTpAddressingFormat

Mixed29Bit `instance-attribute` ¶

Mixed29Bit: CanTpAddressingFormat

NormalFixed `instance-attribute` ¶

NormalFixed: CanTpAddressingFormat

Standard `instance-attribute` ¶

Standard: CanTpAddressingFormat

CanTpChannel ¶

CanTpChannel(element: Element)

A CanTpChannel represents a channel in the CanTp module

channel_id `instance-attribute` ¶

channel_id: Optional[int]

get or set the channel id of the channel

channel_mode `instance-attribute` ¶

channel_mode: Optional[CanTpChannelMode]

get or set the channel mode of the channel

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

CanTpChannelMode ¶

The mode of a CanTpChannel

FullDuplex `instance-attribute` ¶

FullDuplex: CanTpChannelMode

HalfDuplex `instance-attribute` ¶

HalfDuplex: CanTpChannelMode

CanTpConfig ¶

CanTpConfig(element: Element)

Container for CanTp configuration

There should be one CanTpConfig for each CAN network in the system

cluster `instance-attribute` ¶

cluster: Optional[CanCluster]

get or set the CanCluster associated with this configuration

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

can_tp_addresses ¶

can_tp_addresses() -> Iterator[CanTpAddress]

get all of the Can Tp addresses in the configuration

can_tp_channels ¶

can_tp_channels() -> Iterator[CanTpChannel]

iterate over all CanTpChannels in the configuration

can_tp_connections ¶

can_tp_connections() -> Iterator[CanTpConnection]

get all of the CanTpConnections in the configuration

can_tp_ecus ¶

can_tp_ecus() -> Iterator[CanTpEcu]

get an iterator over all ECUs in the configuration

can_tp_nodes ¶

can_tp_nodes() -> Iterator[CanTpNode]

get all of the CanTpNodes in the configuration

create_can_tp_address ¶

create_can_tp_address(
    name: str, address: int
) -> CanTpAddress

create a new CanTpAddress in the configuration

create_can_tp_channel ¶

create_can_tp_channel(
    name: str, channel_id: int, mode: CanTpChannelMode
) -> CanTpChannel

create a new CanTpChannel in the configuration

create_can_tp_connection ¶

create_can_tp_connection(
    name: Optional[str],
    addressing_format: CanTpAddressingFormat,
    can_tp_channel: CanTpChannel,
    data_pdu: NPdu,
    tp_sdu: IPdu,
    padding_activation: bool,
) -> CanTpConnection

create a new CanTpConnection in the configuration

create_can_tp_ecu ¶

create_can_tp_ecu(
    ecu_instance: EcuInstance,
    /,
    *,
    cycle_time_main_function: Optional[float] = None,
) -> CanTpEcu

create a CanTp ECU in the configuration

create_can_tp_node ¶

create_can_tp_node(name: str) -> CanTpNode

create a new CanTpNode in the configuration

CanTpConnection ¶

CanTpConnection(element: Element)

A connection identifies the sender and the receiver of this particular communication. The CanTp module routes a Pdu through this connection.

addressing_format `instance-attribute` ¶

addressing_format: Optional[CanTpAddressingFormat]

get or set the addressing format of the connection

channel `instance-attribute` ¶

channel: Optional[CanTpChannel]

get or set the CanTpChannel associated with this connection

data_pdu `instance-attribute` ¶

data_pdu: Optional[NPdu]

get or set the NPdu associated with this connection

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

padding_activation `instance-attribute` ¶

padding_activation: Optional[bool]

get or set the padding activation of the connection

tp_sdu `instance-attribute` ¶

tp_sdu: Optional[IPdu]

get or set the IPdu associated with this connection

transmitter `instance-attribute` ¶

transmitter: Optional[CanTpNode]

set the transmitter of the connection

This is a CanTpNode representing an ECU that will send the data

add_receiver ¶

add_receiver(receiver: CanTpNode) -> None

add a receiver to the connection

This is a CanTpNode representing an ECU that will receive the data

receivers ¶

receivers() -> Iterator[CanTpNode]

get all of the receivers of the connection

CanTpEcu ¶

CanTpEcu(element: Element)

A CanTpEcu represents an ECU that is using the CanTp module

cycle_time_main_function `instance-attribute` ¶

cycle_time_main_function: Optional[float]

get or set the cycle time of the CanTp main function of the ECU

ecu_instance `instance-attribute` ¶

ecu_instance: Optional[EcuInstance]

get or set the ECU instance of the CanTpEcu

element `instance-attribute` ¶

element: Element

CanTpNode ¶

CanTpNode(element: Element)

A CanTpNode provides the TP address and the connection to the topology description in a CanTpConfig

address `instance-attribute` ¶

address: Optional[CanTpAddress]

get or set the CanTpAddress of this Node

connector `instance-attribute` ¶

connector: Optional[CanCommunicationConnector]

set the reference to a CanCommunicationConnector between an EcuInstance and a CanPhysicalChannel

The connector connects the ECU to the physical channel, so by setting this reference, the ECU is also connected to the CanTpNode

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

ComTransformationTechnologyConfig ¶

ComTransformationTechnologyConfig(
    *, isignal_ipdu_length: int
)

Configuration for a COM transformation

isignal_ipdu_length `instance-attribute` ¶

isignal_ipdu_length: int

The length of the ISignalIpdu tha will be transformed by this Com transformer. The value is only used up to AUTOSAR R20-11 (AUTOSAR_00049), where it is needed to calculate the buffer size.

CommonServiceDiscoveryConfig ¶

CommonServiceDiscoveryConfig(
    *,
    multicast_rx_socket: SocketAddress,
    multicast_rx_pdu: GeneralPurposePdu,
    remote_socket: SocketAddress,
    prefer_static_socket_connections: bool,
    ipdu_identifier_set: Optional[
        SocketConnectionIpduIdentifierSet
    ] = None,
    name_prefix: Optional[str] = None,
)

A CommonServiceDiscoveryConfig contains common configuration settings for System::configure_service_discovery_for_ecu.

This struct contains ECU-independent settings that should be re-used for all ECUs that are configured for SD.

ipdu_identifier_set `instance-attribute` ¶

ipdu_identifier_set: Optional[
    SocketConnectionIpduIdentifierSet
]

an ipdu identifier set in which PduTriggerings are created. Only needed for StaticSocketConnections.

multicast_rx_pdu `instance-attribute` ¶

multicast_rx_pdu: GeneralPurposeIPdu

the multicast rx PDU used by all SD ECUs

multicast_rx_socket `instance-attribute` ¶

multicast_rx_socket: SocketAddress

the socket address used for multicast rx by all SD ECUs

name_prefix `instance-attribute` ¶

name_prefix: Optional[str]

an optional prefix for the names of the created elements

prefer_static_socket_connections `instance-attribute` ¶

prefer_static_socket_connections: bool

configure_service_discovery_for_ecu checks if any SocketConnectionBundles exist. If so, the old configuration method must be used. If none are found and the version is new enough, both methods are possible, and this flag determines which one to use.

remote_socket `instance-attribute` ¶

remote_socket: SocketAddress

the remote socket used for SD communication. This socket must have an IP address (v4 or v6) set to ANY.

CommunicationDirection ¶

The [CommunicationDirection] is used by the communication ports for frames, PDUs and signals

In `instance-attribute` ¶

In: CommunicationDirection

Out `instance-attribute` ¶

Out: CommunicationDirection

ConsumedEventGroup ¶

ConsumedEventGroup(element: Element)

A ConsumedEventGroup is a group of events in a ConsumedServiceInstance that are consumed by an ECU

element `instance-attribute` ¶

element: Element

event_group_identifier `instance-attribute` ¶

event_group_identifier: Optional[int]

get or set the event group identifier of this ConsumedEventGroup

name `instance-attribute` ¶

name: str

sd_client_timer_config `instance-attribute` ¶

sd_client_timer_config: Optional[
    SomeipSdClientEventGroupTimingConfig
]

get or set the SD client timer configuration for this ConsumedEventGroup

add_event_multicast_address ¶

add_event_multicast_address(address: SocketAddress) -> None

add an event multicast address to this ConsumedEventGroup

create_pdu_activation_routing_group ¶

create_pdu_activation_routing_group(
    name: str,
    event_group_control_type: EventGroupControlType,
) -> PduActivationRoutingGroup

create a new PduActivationRoutingGroup in this ConsumedEventGroup

event_multicast_addresses ¶

event_multicast_addresses() -> Iterator[SocketAddress]

get the event multicast addresses

pdu_activation_routing_groups ¶

pdu_activation_routing_groups() -> Iterator[
    PduActivationRoutingGroup
]

iterate over the PduActivationRoutingGroups in this ConsumedEventGroup

ConsumedEventGroupV1 ¶

ConsumedEventGroupV1(element: Element)

A ConsumedEventGroupV1 is a SD event group of a service instance that is consumed by this ECU.

This is the old V1 version of the service definition.

application_endpoint `instance-attribute` ¶

application_endpoint: Optional[SocketAddress]

set the SocketAddress that receives events from this ConsumedEventGroup This may be a different SocketAddress than the one that is used to send requests.

element `instance-attribute` ¶

element: Element

event_group_identifier `instance-attribute` ¶

event_group_identifier: Optional[int]

get or set the event group identifier of this ConsumedEventGroup

name `instance-attribute` ¶

name: str

sd_client_config `instance-attribute` ¶

sd_client_config: Optional[SdEventConfig]

get or set the SD client configuration for this ConsumedEventGroup

add_routing_group ¶

add_routing_group(routing_group: SoAdRoutingGroup) -> None

add a reference to a SoAdRoutingGroup to this ConsumedEventGroup

event_handlers ¶

event_handlers() -> List[EventHandlerV1]

list all EventHandlerV1s that reference this ConsumedEventGroupV1

routing_groups ¶

routing_groups() -> Iterator[SoAdRoutingGroup]

get the routing groups referenced by this ConsumedEventGroup

ConsumedServiceInstance ¶

ConsumedServiceInstance(element: Element)

A ConsumedServiceInstance is a service that is consumed by an ECU

element `instance-attribute` ¶

element: Element

instance_identifier `instance-attribute` ¶

instance_identifier: Optional[int]

get or set the instance identifier of this ConsumedServiceInstance

major_version `instance-attribute` ¶

major_version: Optional[int]

get or set the major version of this ConsumedServiceInstance

minor_version `instance-attribute` ¶

minor_version: Optional[Union[int, str]]

get or set the minor version of this ConsumedServiceInstance

The minor version can be a number or the String "ANY".

name `instance-attribute` ¶

name: str

sd_client_instance_config `instance-attribute` ¶

sd_client_instance_config: Optional[
    SomeipSdClientServiceInstanceConfig
]

get or set the SD client instance configuration for this ConsumedServiceInstance

service_identifier `instance-attribute` ¶

service_identifier: Optional[int]

get or set the service identifier of this ConsumedServiceInstance

consumed_event_groups ¶

consumed_event_groups() -> Iterator[ConsumedEventGroup]

get the ConsumedEventGroups in this ConsumedServiceInstance

create_consumed_event_group ¶

create_consumed_event_group(
    name: str, event_group_identifier: int
) -> ConsumedEventGroup

create a new ConsumedEventGrup in this ConsumedServiceInstance

local_unicast_addresses ¶

local_unicast_addresses() -> Iterator[SocketAddress]

iterate over the local unicast addresses

set_local_unicast_address ¶

set_local_unicast_address(address: SocketAddress) -> None

set a local unicast address for this ConsumedServiceInstance

The CSI may use two local unicast addresses, one each for UDP and TCP. If the consumed service instance does not specify a local unicast address because it only receives multicast messages, then the ConsumedEventGroup must have an eventMulticastAddress.

ConsumedServiceInstanceV1 ¶

ConsumedServiceInstanceV1(element: Element)

A ConsumedServiceInstanceV1 is a SD service instance that is consumed by this ECU.

This is the old V1 version of the service definition.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

provided_service_instance `instance-attribute` ¶

provided_service_instance: Optional[
    ProvidedServiceInstanceV1
]

get the ProvidedServiceInstanceV1 referenced by this ConsumedServiceInstanceV1

consumed_event_groups ¶

consumed_event_groups() -> Iterator[ConsumedEventGroupV1]

get the ConsumedEventGroups in this ConsumedServiceInstanceV1

create_consumed_event_group ¶

create_consumed_event_group(
    name: str,
    event_group_identifier: int,
    event_handler: EventHandlerV1,
) -> ConsumedEventGroupV1

create a new ConsumedEventGroupV1 in this ConsumedServiceInstanceV1

sd_client_config ¶

sd_client_config() -> Optional[SdConfig]

get the SD client configuration for this ConsumedServiceInstanceV1

set_sd_client_config ¶

set_sd_client_config(sd_client_config: SdConfig) -> None

set the SD client configuration for this ConsumedServiceInstanceV1

ContainedIPduCollectionSemantics ¶

collection semantics for the ContainedIPdu

LastIsBest `instance-attribute` ¶

LastIsBest: ContainedIPduCollectionSemantics

Queued `instance-attribute` ¶

Queued: ContainedIPduCollectionSemantics

ContainedIPduProps ¶

ContainedIPduProps(
    *,
    collection_semantics: Optional[
        ContainedIPduCollectionSemantics
    ] = None,
    header_id_long: Optional[int] = None,
    header_id_short: Optional[int] = None,
    offset: Optional[int] = None,
    priority: Optional[int] = None,
    timeout: Optional[float] = None,
    trigger: Optional[PduCollectionTrigger] = None,
    update_indication_bit_position: Optional[int] = None,
)

Properties for an IPdu that is transmitted in a container IPdu

collection_semantics `instance-attribute` ¶

collection_semantics: Optional[
    ContainedIPduCollectionSemantics
]

collection semantics: LastIsBest or Queued

header_id_long `instance-attribute` ¶

header_id_long: Optional[int]

header id of the contained IPdu, used when the header type is LongHeader

header_id_short `instance-attribute` ¶

header_id_short: Optional[int]

header id of the contained IPdu, used when the header type is ShortHeader

offset `instance-attribute` ¶

offset: Optional[int]

offset of the contained IPdu in the container IPdu, used when the header type is NoHeader

priority `instance-attribute` ¶

priority: Optional[int]

priority of the contained IPdu. 255: lowest, 0: highest

timeout `instance-attribute` ¶

timeout: Optional[float]

sender timeout. Ignored on the receiver side

trigger `instance-attribute` ¶

trigger: Optional[PduCollectionTrigger]

defines whether the contained IPdu triggers transmission of the container IPdu

update_indication_bit_position `instance-attribute` ¶

update_indication_bit_position: Optional[int]

update indication bit position of the contained IPdu

ContainerIPdu ¶

ContainerIPdu(element: Element)

Several IPdus can be collected in one ContainerIPdu based on the headerType

contained_ipdu_props `instance-attribute` ¶

contained_ipdu_props: Optional[ContainedIPduProps]

set the ContainedIPduProps for this IPdu This is only needed when the IPdu is contained in a ContainerIPdu

container_timeout `instance-attribute` ¶

container_timeout: Optional[float]

container_trigger `instance-attribute` ¶

container_trigger: Optional[ContainerIPduTrigger]

get or set the container trigger of this ContainerIPdu

element `instance-attribute` ¶

element: Element

header_type `instance-attribute` ¶

header_type: ContainerIPduHeaderType

length `instance-attribute` ¶

length: Optional[int]

get or set the length of this PDU

name `instance-attribute` ¶

name: str

rx_accept_contained_ipdu `instance-attribute` ¶

rx_accept_contained_ipdu: Optional[RxAcceptContainedIPdu]

get or set the rx accept of this ContainerIPdu

contained_ipdu_triggerings ¶

contained_ipdu_triggerings() -> Iterator[PduTriggering]

iterate over all contained IPdu triggerings

map_ipdu ¶

map_ipdu(
    ipdu: IPdu, physical_channel: PhysicalChannel
) -> PduTriggering

map an IPdu to this ContainerIPdu and create a PduTriggering for it in the PhysicalChannel

pdu_triggerings ¶

pdu_triggerings() -> List[PduTriggering]

list all PduTriggerings that trigger this PDU

ContainerIPduHeaderType ¶

The header type of a ContainerIPdu

LongHeader `instance-attribute` ¶

LongHeader: ContainerIPduHeaderType

NoHeader `instance-attribute` ¶

NoHeader: ContainerIPduHeaderType

ShortHeader `instance-attribute` ¶

ShortHeader: ContainerIPduHeaderType

ContainerIPduTrigger ¶

Defines when the transmission of the ContainerIPdu shall be requested

DefaultTrigger `instance-attribute` ¶

DefaultTrigger: ContainerIPduTrigger

FirstContainedTrigger `instance-attribute` ¶

FirstContainedTrigger: ContainerIPduTrigger

CycleRepetition ¶

The cycle repetition of a Flexray frame, from the Flexray standard

C1 `instance-attribute` ¶

C1: CycleRepetition

C10 `instance-attribute` ¶

C10: CycleRepetition

C16 `instance-attribute` ¶

C16: CycleRepetition

C2 `instance-attribute` ¶

C2: CycleRepetition

C20 `instance-attribute` ¶

C20: CycleRepetition

C32 `instance-attribute` ¶

C32: CycleRepetition

C4 `instance-attribute` ¶

C4: CycleRepetition

C40 `instance-attribute` ¶

C40: CycleRepetition

C5 `instance-attribute` ¶

C5: CycleRepetition

C50 `instance-attribute` ¶

C50: CycleRepetition

C64 `instance-attribute` ¶

C64: CycleRepetition

C8 `instance-attribute` ¶

C8: CycleRepetition

CyclicTiming ¶

CyclicTiming(
    time_period: float,
    /,
    *,
    time_offset: Optional[float] = None,
)

Cyclic timing parameters for an IPDU

time_offset `instance-attribute` ¶

time_offset: Optional[float]

delay until the first transmission of the PDU in seconds

time_period `instance-attribute` ¶

time_period: float

period of repetition in seconds

DataIdMode ¶

data ID modes for E2E profiles 01 and 11

All16Bit `instance-attribute` ¶

All16Bit: DataIdMode

Alternating8Bit `instance-attribute` ¶

Alternating8Bit: DataIdMode

Lower12Bit `instance-attribute` ¶

Lower12Bit: DataIdMode

Lower8Bit `instance-attribute` ¶

Lower8Bit: DataIdMode

DataTransformation ¶

DataTransformation(element: Element)

A DataTransformation is a chain of TransformationTechnologys that are used to transform data

data_transformation_set `instance-attribute` ¶

data_transformation_set: Optional[DataTransformationSet]

get the DataTransformationSet that contains this DataTransformation

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

transformation_technologies ¶

transformation_technologies() -> Iterator[
    TransformationTechnology
]

Create an iterator over the TransformationTechnologies in the DataTransformation

DataTransformationSet ¶

DataTransformationSet(element: Element)

A [DataTransformationSet] contains DataTransformations and TransformationTechnologys used in communication

Use [ArPackage::create_data_transformation_set] to create a new DataTransformationSet

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

create_data_transformation ¶

create_data_transformation(
    name: str,
    transformations: List[TransformationTechnology],
    execute_despite_data_unavailability: bool,
) -> DataTransformation

Create a new DataTransformation in the DataTransformationSet

create_transformation_technology ¶

create_transformation_technology(
    name: str, config: TransformationTechnologyConfig
) -> TransformationTechnology

Create a new TransformationTechnology in the DataTransformationSet

data_transformations ¶

data_transformations() -> Iterator[DataTransformation]

Iterate over all DataTransformations in the DataTransformationSet

transformation_technologies ¶

transformation_technologies() -> Iterator[
    TransformationTechnology
]

Iterate over all TransformationTechnologys in the DataTransformationSet

DcmIPdu ¶

DcmIPdu(element: Element)

Represents the IPdus handled by Dcm

contained_ipdu_props `instance-attribute` ¶

contained_ipdu_props: Optional[ContainedIPduProps]

set the ContainedIPduProps for this IPdu This is only needed when the IPdu is contained in a ContainerIPdu

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

get or set the length of this PDU

name `instance-attribute` ¶

name: str

pdu_triggerings ¶

pdu_triggerings() -> List[PduTriggering]

list all PduTriggerings that trigger this PDU

DoIpLogicAddress ¶

DoIpLogicAddress(element: Element)

This element defines the logical address of a DoIp connection

address `instance-attribute` ¶

address: Optional[int]

get or set the address of this DoIpLogicAddress

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

DoIpTpConfig ¶

DoIpTpConfig(element: Element)

Container for DoIp TP configuration

cluster `instance-attribute` ¶

cluster: Optional[EthernetCluster]

get or set the reference to the EthernetCluster for this DoIpTpConfig

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

create_doip_logic_address ¶

create_doip_logic_address(
    name: str, address: int
) -> DoIpLogicAddress

create a new DoIpLogicAddress

create_doip_tp_connection ¶

create_doip_tp_connection(
    name: Optional[str],
    source: DoIpLogicAddress,
    target: DoIpLogicAddress,
    tp_sdu_triggering: PduTriggering,
) -> DoIpTpConnection

create a new DoIpTpConnection

doip_logic_addresses ¶

doip_logic_addresses() -> Iterator[DoIpLogicAddress]

iterate over all DoIpLogicAddresss

doip_tp_connections ¶

doip_tp_connections() -> Iterator[DoIpTpConnection]

iterate over all DoIpTpConnections

DoIpTpConnection ¶

DoIpTpConnection(element: Element)

The DoIpTpConnection defines a DoIp transport protocol connection

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

source `instance-attribute` ¶

source: Optional[DoIpLogicAddress]

get or set the source DoIpLogicAddress

target `instance-attribute` ¶

target: Optional[DoIpLogicAddress]

get or set the target DoIpLogicAddress

tp_sdu_triggering `instance-attribute` ¶

tp_sdu_triggering: Optional[PduTriggering]

get or set the PduTriggering for this connection

E2EProfile ¶

enumeration of the possible E2E profiles

P01 `instance-attribute` ¶

P01: E2EProfile

P02 `instance-attribute` ¶

P02: E2EProfile

P04 `instance-attribute` ¶

P04: E2EProfile

P04m `instance-attribute` ¶

P04m: E2EProfile

P05 `instance-attribute` ¶

P05: E2EProfile

P06 `instance-attribute` ¶

P06: E2EProfile

P07 `instance-attribute` ¶

P07: E2EProfile

P07m `instance-attribute` ¶

P07m: E2EProfile

P08 `instance-attribute` ¶

P08: E2EProfile

P08m `instance-attribute` ¶

P08m: E2EProfile

P11 `instance-attribute` ¶

P11: E2EProfile

P22 `instance-attribute` ¶

P22: E2EProfile

P44 `instance-attribute` ¶

P44: E2EProfile

P44m `instance-attribute` ¶

P44m: E2EProfile

E2EProfileBehavior ¶

there are two standardized behaviors for E2E profiles, which can be selected for each E2E transformation

PreR4_2 `instance-attribute` ¶

PreR4_2: E2EProfileBehavior

R4_2 `instance-attribute` ¶

R4_2: E2EProfileBehavior

E2ETransformationTechnologyConfig ¶

E2ETransformationTechnologyConfig(
    *,
    profile: E2EProfile,
    zero_header_length: bool,
    transform_in_place: bool,
    offset: int,
    max_delta_counter: int,
    max_error_state_init: int,
    max_error_state_invalid: int,
    max_error_state_valid: int,
    max_no_new_or_repeated_data: int,
    min_ok_state_init: int,
    min_ok_state_invalid: int,
    min_ok_state_valid: int,
    window_size: int,
    window_size_init: Optional[int] = None,
    window_size_invalid: Optional[int] = None,
    window_size_valid: Optional[int] = None,
    profile_behavior: Optional[E2EProfileBehavior] = None,
    sync_counter_init: Optional[int] = None,
    data_id_mode: Optional[DataIdMode] = None,
    data_id_nibble_offset: Optional[int] = None,
    crc_offset: Optional[int] = None,
    counter_offset: Optional[int] = None,
)

Configuration for an E2E transformation

counter_offset `instance-attribute` ¶

counter_offset: Optional[int]

Offset of the counter in the Data[] array in bits. Required for E2E profiles 01 and 11, unused otherwise

crc_offset `instance-attribute` ¶

crc_offset: Optional[int]

Offset of the crc in the Data[] array in bits. Required for E2E profiles 01 and 11, unused otherwise

data_id_mode `instance-attribute` ¶

data_id_mode: Optional[DataIdMode]

The data ID mode to use; required for E2E profiles 01 and 11, unused otherwise

data_id_nibble_offset `instance-attribute` ¶

data_id_nibble_offset: Optional[int]

Offset of the data ID in the Data[] array in bits. Required for E2E profiles 01 and 11 when data_id_mode is Lower12Bit, unused otherwise

max_delta_counter `instance-attribute` ¶

max_delta_counter: int

Maximum jump in the counter value between two consecutive messages

max_error_state_init `instance-attribute` ¶

max_error_state_init: int

The maximum allowed number of consecutive failed counter checks in the init state

max_error_state_invalid `instance-attribute` ¶

max_error_state_invalid: int

The maximum allowed number of consecutive failed counter checks in the invalid state

max_error_state_valid `instance-attribute` ¶

max_error_state_valid: int

The maximum allowed number of consecutive failed counter checks in the valid state

max_no_new_or_repeated_data `instance-attribute` ¶

max_no_new_or_repeated_data: int

The maximum allowed number of consecutive failed counter checks

min_ok_state_init `instance-attribute` ¶

min_ok_state_init: int

The minimum allowed number of consecutive successful counter checks in the init state

min_ok_state_invalid `instance-attribute` ¶

min_ok_state_invalid: int

The minimum allowed number of consecutive successful counter checks in the invalid state

min_ok_state_valid `instance-attribute` ¶

min_ok_state_valid: int

The minimum allowed number of consecutive successful counter checks in the valid state

offset `instance-attribute` ¶

offset: int

The offset in bits from the start of the buffer where the E2E data should be placed If E2E is used after COM, the offset should be 0; if E2E is used after SOMEIP, the offset should be 64

profile `instance-attribute` ¶

profile: E2EProfile

E2E profile to use

profile_behavior `instance-attribute` ¶

profile_behavior: Optional[E2EProfileBehavior]

Behavior of the check functionality

sync_counter_init `instance-attribute` ¶

sync_counter_init: Optional[int]

Number of successful checks required for validating the consistency of the counter

transform_in_place `instance-attribute` ¶

transform_in_place: bool

Should the E2E transformation take place in the existing buffer or in a separate buffer?

window_size `instance-attribute` ¶

window_size: int

window size: Size of the monitoring window for the E2E state machine. This can be directly set up to AUTOSAR 4.4.0 (AUTOSAR_00047). For newer files this only provides the default if window_size_init, window_size_invalid and window_size_valid are not set

window_size_init `instance-attribute` ¶

window_size_init: Optional[int]

window size in the init state - only valid in AUTOSAR 4.5.0 (AUTOSAR_00048) and newer. if it is not set, this will default to window_size

window_size_invalid `instance-attribute` ¶

window_size_invalid: Optional[int]

window size in the invalid state - only valid in AUTOSAR 4.5.0 (AUTOSAR_00048) and newer. if it is not set, this will default to window_size

window_size_valid `instance-attribute` ¶

window_size_valid: Optional[int]

window size in the valid state - only valid in AUTOSAR 4.5.0 (AUTOSAR_00048) and newer. if it is not set, this will default to window_size

zero_header_length `instance-attribute` ¶

zero_header_length: bool

When E2E is used in a transformer chain after COM, the header length must be zero. In this configuration you are expected to provide space for the E2E data inside the signal group layout, and zero_header_length should be set to true. If zero_header_length is set to false, the appropriate header length for the chosen E2E profile will be used (e.g. 24 bits for PROFILE_05)

EndToEndTransformationISignalProps ¶

EndToEndTransformationISignalProps(element: Element)

Properties for the End to End transformation of an ISignal(Group)

data_ids `instance-attribute` ¶

data_ids: List[int]

get or set the data IDs that are used for the E2E transformation

data_length `instance-attribute` ¶

data_length: Optional[int]

get or set the length of payload and E2E header in bits

element `instance-attribute` ¶

element: Element

max_data_length `instance-attribute` ¶

max_data_length: Optional[int]

get or set the maximum data length

min_data_length `instance-attribute` ¶

min_data_length: Optional[int]

get or set the minimum data length

source_id `instance-attribute` ¶

source_id: Optional[int]

get or set the source ID

transformer `instance-attribute` ¶

transformer: Optional[TransformationTechnology]

get or set the transformer reference of the E2E transformation properties

EthernetCluster ¶

EthernetCluster(element: Element)

An EthernetCluster contains all configuration items associated with an ethernet network. The cluster connects multiple ECUs.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

system `instance-attribute` ¶

system: Optional[System]

get the System that this EthernetCluster is part of

create_physical_channel ¶

create_physical_channel(
    channel_name: str,
    /,
    *,
    vlan_info: Optional[EthernetVlanInfo] = None,
) -> EthernetPhysicalChannel

Create a new physical channel for the cluster

The supplied VLAN info must be unique - there cannot be two VLANs with the same vlan identifier. One channel may be created without VLAN information; it carries untagged traffic.

physical_channels ¶

physical_channels() -> Iterator[EthernetPhysicalChannel]

returns an iterator over all [EthernetPhysicalChannel]s in the cluster

EthernetCommunicationConnector ¶

EthernetCommunicationConnector(element: Element)

A connector between an [EthernetCommunicationController] in an ECU and an [EthernetPhysicalChannel]

controller `instance-attribute` ¶

controller: EthernetCommunicationController

Get the controller of the CommunicationConnector

ecu_instance `instance-attribute` ¶

ecu_instance: EcuInstance

Get the EcuInstance that contains this CommunicationConnector

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

EthernetCommunicationController ¶

EthernetCommunicationController(element: Element)

An EcuInstance needs an EthernetCommunicationController in order to connect to an ethernet cluster.

ecu_instance `instance-attribute` ¶

ecu_instance: EcuInstance

Get the EcuInstance that contains this EthernetCommunicationController

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

connect_physical_channel ¶

connect_physical_channel(
    connection_name: str,
    eth_channel: EthernetPhysicalChannel,
) -> EthernetCommunicationConnector

Connect this [EthernetCommunicationController] inside an [EcuInstance] to an [EthernetPhysicalChannel] in the [crate::System]

Creates an EthernetCommunicationConnector in the [EcuInstance] that contains this [EthernetCommunicationController].

This function establishes the relationships

[EthernetPhysicalChannel] -> EthernetCommunicationConnector
EthernetCommunicationConnector -> [EthernetCommunicationController]

connected_channels ¶

connected_channels() -> Iterator[EthernetPhysicalChannel]

return an iterator over the [EthernetPhysicalChannel]s connected to this controller

EthernetPhysicalChannel ¶

EthernetPhysicalChannel(element: Element)

The EthernetPhysicalChannel represents a VLAN or untagged traffic

cluster `instance-attribute` ¶

cluster: EthernetCluster

get the cluster containing this physical channel

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

configure_service_discovery_for_ecu ¶

configure_service_discovery_for_ecu(
    ecu: EcuInstance,
    unicast_socket: SocketAddress,
    unicast_rx_pdu: GeneralPurposePdu,
    unicast_tx_pdu: GeneralPurposePdu,
    common_config: CommonServiceDiscoveryConfig,
) -> None

configure SOME/IP service discovery (SD) for an ECU connected to this channel

SD is used to broadcast service offers on the network and subscribe to services offered by other ECUs. This function configures the ECU to use the SOME/IP SD protocol.

SD uses either socket connection bundles or static socket connections to communicate.

ecu is the ECU that should be configured for SD. unicast_socket is the socket address used for unicast rx/tx communication by the ECU. unicast_rx_pdu and unicast_tx_pdu are the GeneralPurposePdus used for the unicast communication. common_config contains common configuration settings that can be used for all SD ECUs. - multicast_rx_socket is the socket address used for multicast communication by all SD ECUs. - remote_socket is a socket whose IP is set to ANY with UDP port 0, acting as the remote address in the SD communication. - name_prefix is an optional prefix for the names of the created elements. - prefer_static_socket_connections is a flag that determines if SocketConnectionBundles should be used instead of StaticSocketConnections. This is only relevant if the type can't be detected automatically. - ipdu_identifier_set is contains the IPduIdentifiers that are used in StaticSocketConnections.

Note: Usually SomeIP SD is expected to use port 30490, but this is not mandatory. The port number is set in the sockets, and must be the same for all SD sockets.

create_network_endpoint ¶

create_network_endpoint(
    name: str,
    address: NetworkEndpointAddress,
    /,
    *,
    ecu: Optional[EcuInstance] = None,
) -> NetworkEndpoint

create a network endpoint - IPv4 or IPv6 address - for this channel

In older versions of the Autosar standard, up to version 4.4.0, the NetworkEndpoint could be linked to an Ecu. The parameter ecu specifies the target. The link is obsoleted in newer versions, and will only be created if the file version allows it.

create_socket_address ¶

create_socket_address(
    name: str,
    network_endpoint: NetworkEndpoint,
    tp_config: TpConfig,
    sa_type: SocketAddressType,
) -> SocketAddress

create a socket address in the ethernet channel

It contains the settings of the TCP/UDP port and links to a [NetworkEndpoint] which contains the IP address. The socket address can either be a unicast adress which is associated with a single ECU, or a multicast address

create_socket_connection_bundle ¶

create_socket_connection_bundle(
    name: str, server_port: SocketAddress
) -> SocketConnectionBundle

create a socket connection bundle

The SocketConnectionBundle is the "old" way to establish a connection between two sockets. It is deprecated in newer versions of the Autosar standard, but remains available for compatibility.

create_static_socket_connection_pair ¶

create_static_socket_connection_pair(
    name: str,
    port_1: SocketAddress,
    port_2: SocketAddress,
    /,
    *,
    tcp_connect_timeout: Optional[float] = None,
) -> Tuple[StaticSocketConnection, StaticSocketConnection]

create a pair of static socket connections

Static socket connections are usually created as a pair, one on each socket involved on the connection. This helper function creates both at once. To create a single connection, use [SocketAddress::create_static_socket_connection].

If the connection is a TCP connection, the first port connects to the second port, and the second port listens for incoming connection. The ordering of port_1 and port_2 has no impact on the direction of the transported PDUs. This is defined in the PduTriggering.

StaticSocketConnections are the "new" way to establish a connection between two sockets. It was introduced in Autosar 4.5.0 (AUTOSAR_00048) and is the recommended way to create connections.

SocketConnectionBundles (old) and StaticSocketConnections (new) may never be used in the same file.

has_socket_connections ¶

has_socket_connections() -> bool

check if the channel contains any SocketConnectionBundles (old) or SocketConnections (very old)

network_endpoints ¶

network_endpoints() -> Iterator[NetworkEndpoint]

create an iterator over all [NetworkEndpoint]s in this channel

pdu_triggerings ¶

pdu_triggerings() -> Iterator[PduTriggering]

iterate over all PDU triggerings of this physical channel

set_vlan_info ¶

set_vlan_info(
    vlan_info: Optional[EthernetVlanInfo],
) -> None

get or set the VLAN information of the channel.

In an EthernetCluster, each physical channel must have unique VLAN settings; only one channel can omit VLAN information - it carries untagged traffic. Setting duplicate VLAN information will result in an error.

signal_triggerings ¶

signal_triggerings() -> Iterator[ISignalTriggering]

iterate over all signal triggerings of this physical channel

socket_addresses ¶

socket_addresses() -> Iterator[SocketAddress]

create an iterator over all [SocketAddress]es in this channel

socket_connection_bundles ¶

socket_connection_bundles() -> Iterator[
    SocketConnectionBundle
]

iterate over all socket connection bundles in this channel

The SocketConnectionBundle is the "old" way to establish a connection between two sockets. It is deprecated in newer versions of the Autosar standard, but remains available for compatibility.

vlan_info ¶

vlan_info() -> Optional[EthernetVlanInfo]

get or set the VLAN information of the channel. In an EthernetCluster, each physical channel must have unique VLAN settings; only one channel can omit VLAN information - it carries untagged traffic. Setting duplicate VLAN information will result in an error.

EthernetVlanInfo ¶

EthernetVlanInfo(*, vlan_name: str, vlan_id: int)

Provides information about the VLAN of an [EthernetPhysicalChannel]

vlan_id `instance-attribute` ¶

vlan_id: int

vlan_name `instance-attribute` ¶

vlan_name: str

EventControlledTiming ¶

EventControlledTiming(
    number_of_repetitions: int,
    /,
    *,
    repetition_period: Optional[float] = None,
)

Event controlled timing parameters for an IPDU

number_of_repetitions `instance-attribute` ¶

number_of_repetitions: int

The PDU will be sent (number of repetitions + 1) times. If number of repetitions is 0, then the PDU is sent exactly once.

repetition_period `instance-attribute` ¶

repetition_period: Optional[float]

time in seconds between two transmissions of the PDU

EventGroupControlType ¶

control types used in routing groups for SOME/IP events

ActivationAndTriggerUnicast `instance-attribute` ¶

ActivationAndTriggerUnicast: EventGroupControlType

ActivationMulticast `instance-attribute` ¶

ActivationMulticast: EventGroupControlType

ActivationUnicast `instance-attribute` ¶

ActivationUnicast: EventGroupControlType

TriggerUnicast `instance-attribute` ¶

TriggerUnicast: EventGroupControlType

EventHandler ¶

EventHandler(element: Element)

An EventHandler describes the handling of a single event in a ProvidedServiceInstance

element `instance-attribute` ¶

element: Element

event_group_identifier `instance-attribute` ¶

event_group_identifier: Optional[int]

get or set the event group identifier of this EventHandler

name `instance-attribute` ¶

name: str

sd_server_event_group_timing_config `instance-attribute` ¶

sd_server_event_group_timing_config: Optional[
    SomeipSdServerEventGroupTimingConfig
]

get or set the SD server event group timing configuration for this EventHandler

create_pdu_activation_routing_group ¶

create_pdu_activation_routing_group(
    name: str,
    event_group_control_type: EventGroupControlType,
) -> PduActivationRoutingGroup

create a new PduActivationRoutingGroup in this EventHandler

pdu_activation_routing_groups ¶

pdu_activation_routing_groups() -> Iterator[
    PduActivationRoutingGroup
]

get the PduActivationRoutingGroups in this EventHandler

EventHandlerV1 ¶

EventHandlerV1(element: Element)

An EventHandlerV1 is a SD event handler that is used to receive events from other ECUs.

This is the old V1 version of the service definition.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

add_consumed_event_group ¶

add_consumed_event_group(
    consumed_event_group: ConsumedEventGroupV1,
) -> None

add a reference to a ConsumedEventGroupV1 to this EventHandlerV1

add_routing_group ¶

add_routing_group(routing_group: SoAdRoutingGroup) -> None

add a reference to a SoAdRoutingGroup to this EventHandler

consumed_event_groups ¶

consumed_event_groups() -> Iterator[ConsumedEventGroupV1]

get the consumed event groups referenced by this EventHandler

routing_groups ¶

routing_groups() -> Iterator[SoAdRoutingGroup]

get the routing groups referenced by this EventHandler

sd_server_config ¶

sd_server_config() -> Optional[SdEventConfig]

get the SD server event configuration for this EventHandlerV1

set_sd_server_config ¶

set_sd_server_config(
    sd_event_config: SdEventConfig,
) -> None

set the SD server event configuration for this EventHandlerV1

FlexrayArTpChannel ¶

FlexrayArTpChannel(element: Element)

The FlexrayArTpChannel represents a channel in the Flexray Autosar Transport Protocol

ack_type `instance-attribute` ¶

ack_type: Optional[FrArTpAckType]

get or set the ack type of the channel

element `instance-attribute` ¶

element: Element

extended_addressing `instance-attribute` ¶

extended_addressing: Optional[bool]

get or set the extended addressing attribute

maximum_message_length `instance-attribute` ¶

maximum_message_length: Optional[MaximumMessageLengthType]

get or set the maximum message length type

minimum_separation_time `instance-attribute` ¶

minimum_separation_time: Optional[float]

get or set the minimum separation time

multicast_segmentation `instance-attribute` ¶

multicast_segmentation: Optional[bool]

get or set the multicast segmentation

add_n_pdu ¶

add_n_pdu(n_pdu: NPdu) -> None

add an N-PDU to the channel

The NPdus are logically assembled into a pool of Rx NPdus and another pool of Tx NPdus. This function is supported on autosar 4.1 and later, while Autosar 4.0 uses a different approach.

create_flexray_ar_tp_connection ¶

create_flexray_ar_tp_connection(
    name: Optional[str],
    direct_tp_sdu: IPdu,
    source: FlexrayArTpNode,
    target: FlexrayArTpNode,
) -> FlexrayArTpConnection

create a new FlexrayArTpConnection for this channel

flexray_ar_tp_connections ¶

flexray_ar_tp_connections() -> Iterator[
    FlexrayArTpConnection
]

get an iterator over the connections in the channel

n_pdus ¶

n_pdus() -> Iterator[NPdu]

iterate over the NPdus of the channel

FlexrayArTpConfig ¶

FlexrayArTpConfig(element: Element)

The FlexrayArTpConfig represents the configuration of the Flexray Autosar Transport Protocol

cluster `instance-attribute` ¶

cluster: Optional[FlexrayCluster]

get or set the Flexray cluster for the configuration

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

create_flexray_ar_tp_channel ¶

create_flexray_ar_tp_channel(
    ack_type: FrArTpAckType,
    extended_addressing: bool,
    maximum_message_length: MaximumMessageLengthType,
    minimum_separation_time: float,
    multicast_segmentation: bool,
) -> FlexrayArTpChannel

create a new FlexrayArTpChannel

create_flexray_ar_tp_node ¶

create_flexray_ar_tp_node(name: str) -> FlexrayArTpNode

create a new FlexrayArTpNode

create_tp_address ¶

create_tp_address(name: str, address: int) -> TpAddress

create a new TpAddress

flexray_ar_tp_channels ¶

flexray_ar_tp_channels() -> Iterator[FlexrayArTpChannel]

get an iterator over the channels in the configuration

flexray_ar_tp_nodes ¶

flexray_ar_tp_nodes() -> Iterator[FlexrayArTpNode]

get an iterator over the nodes

tp_addresses ¶

tp_addresses() -> Iterator[TpAddress]

iterate over all TpAddresses

FlexrayArTpConnection ¶

FlexrayArTpConnection(element: Element)

FlexrayArTpConnection represents a connection within a FlexrayArTpChannel

The connection identifies the sender and the receiver of this particular communication. The Flexray Autosar Tp module routes a Pdu through this connection.

direct_tp_sdu `instance-attribute` ¶

direct_tp_sdu: Optional[IPdu]

get or set the direct TP SDU

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

reversed_tp_sdu `instance-attribute` ¶

reversed_tp_sdu: Optional[IPdu]

get or set or remove the reversed TP SDU

If the connection supports both directions, then the reversed TP SDU is required. if Some(value) is passed, the reversed TP SDU is set to the given value, otherwise it is removed.

source `instance-attribute` ¶

source: Optional[FlexrayArTpNode]

get or set the source of the connection

add_target ¶

add_target(target: FlexrayArTpNode) -> None

add a target to the connection

The connection can have multiple targets, but at least one target is required.

targets ¶

targets() -> Iterator[FlexrayArTpNode]

get the targets

FlexrayArTpNode ¶

FlexrayArTpNode(element: Element)

FlexrayArTpNode represents a node in the Flexray Autosar Transport Protocol

A TP node (sender or receiver) provides the TP address and the connection to the topology description

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

tp_address `instance-attribute` ¶

tp_address: Optional[TpAddress]

set or remove the TP address

if Some(value) is passed, the TP address is set to the given value, otherwise it is removed.

add_communication_connector ¶

add_communication_connector(
    connector: FlexrayCommunicationConnector,
) -> None

add a reference to a FlexrayCommunicationConnector

The connectors define the association with a PhysicalChannel and an ECU. In a SystemDescription, this reference is mandatory, but in an ECUExtract it is optional. Up to 2 connectors can be added to a node.

communication_connectors ¶

communication_connectors() -> Iterator[
    FlexrayCommunicationConnector
]

get the connectors

FlexrayChannelName ¶

A flexray cluster may contain the channels A and/or B.

This enum is an abstraction over the element.

A `instance-attribute` ¶

A: FlexrayChannelName

B `instance-attribute` ¶

B: FlexrayChannelName

FlexrayCluster ¶

FlexrayCluster(element: Element)

A FlexrayCluster contains all configuration items associated with a Flexray network. The cluster connects multiple ECUs.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

physical_channels `instance-attribute` ¶

physical_channels: FlexrayPhysicalChannelsInfo

get the physical channels of this cluster

system `instance-attribute` ¶

system: Optional[System]

get the system that contains this cluster

create_physical_channel ¶

create_physical_channel(
    name: str, channel_name: FlexrayChannelName
) -> FlexrayPhysicalChannel

Create a new physical channel for the cluster

A cluster may contain channel A, channel B, or both A and B.

set_settings ¶

set_settings(settings: FlexrayClusterSettings) -> None

set the current flexray cluster settings

settings ¶

settings() -> Optional[FlexrayClusterSettings]

get the current flexray cluster settings

FlexrayClusterSettings ¶

action_point_offset `instance-attribute` ¶

action_point_offset: float

get or set the action point offset of the cluster

baudrate `instance-attribute` ¶

baudrate: int

get or set the baudrate of the cluster

bit `instance-attribute` ¶

bit: float

get or set the bit time of the cluster

cas_rx_low_max `instance-attribute` ¶

cas_rx_low_max: int

get or set the cas rx low max of the cluster

cold_start_attempts `instance-attribute` ¶

cold_start_attempts: int

get or set the cold start attempts of the cluster

cycle `instance-attribute` ¶

cycle: float

get or set the cycle time of the cluster (in seconds)

cycle_count_max `instance-attribute` ¶

cycle_count_max: int

get or set the cycle count max of the cluster

detect_nit_error `instance-attribute` ¶

detect_nit_error: bool

get or set the detect nit error status of the cluster

dynamic_slot_idle_phase `instance-attribute` ¶

dynamic_slot_idle_phase: int

get or set the dynamic slot idle phase of the cluster

ignore_after_tx `instance-attribute` ¶

ignore_after_tx: int

get or set the ignore after tx duration of the cluster

listen_noise `instance-attribute` ¶

listen_noise: int

get or set the listen noise of the cluster

macro_per_cycle `instance-attribute` ¶

macro_per_cycle: int

get or set the macro per cycle of the cluster

macrotick_duration `instance-attribute` ¶

macrotick_duration: float

get or set the macrotick duration of the cluster

max_without_clock_correction_fatal `instance-attribute` ¶

max_without_clock_correction_fatal: int

get or set the max without clock correction fatal of the cluster

max_without_clock_correction_passive `instance-attribute` ¶

max_without_clock_correction_passive: int

get or set the max without clock correction passive of the cluster

minislot_action_point_offset `instance-attribute` ¶

minislot_action_point_offset: int

get or set the minislot action point offset of the cluster

minislot_duration `instance-attribute` ¶

minislot_duration: int

get or set the minislot duration of the cluster

network_idle_time `instance-attribute` ¶

network_idle_time: int

get or set the network idle time of the cluster

network_management_vector_length `instance-attribute` ¶

network_management_vector_length: int

get or set the network management vector length of the cluster

number_of_minislots `instance-attribute` ¶

number_of_minislots: int

get or set the number of minislots of the cluster

number_of_static_slots `instance-attribute` ¶

number_of_static_slots: int

get or set the number of static slots of the cluster

offset_correction_start `instance-attribute` ¶

offset_correction_start: int

get or set the offset correction start of the cluster

payload_length_static `instance-attribute` ¶

payload_length_static: int

get or set the payload length static of the cluster

safety_margin `instance-attribute` ¶

safety_margin: int

get or set the safety margin of the cluster

sample_clock_period `instance-attribute` ¶

sample_clock_period: Optional[float]

get or set the sample clock period of the cluster

static_slot_duration `instance-attribute` ¶

static_slot_duration: int

get or set the static slot duration of the cluster

symbol_window `instance-attribute` ¶

symbol_window: int

get or set the symbol window of the cluster

symbol_window_action_point_offset `instance-attribute` ¶

symbol_window_action_point_offset: int

get or set the symbol window action point offset of the cluster

sync_frame_id_count_max `instance-attribute` ¶

sync_frame_id_count_max: int

get or set the sync frame id count max of the cluster

transceiver_standby_delay `instance-attribute` ¶

transceiver_standby_delay: Optional[float]

get or set the transceiver standby delay of the cluster

transmission_start_sequence_duration `instance-attribute` ¶

transmission_start_sequence_duration: int

get or set the transmission start sequence duration of the cluster

wakeup_rx_idle `instance-attribute` ¶

wakeup_rx_idle: int

get or set the wakeup rx idle of the cluster

wakeup_rx_low `instance-attribute` ¶

wakeup_rx_low: int

get or set the wakeup rx low of the cluster

wakeup_rx_window `instance-attribute` ¶

wakeup_rx_window: int

get or set the wakeup rx window of the cluster

wakeup_tx_active `instance-attribute` ¶

wakeup_tx_active: int

get or set the wakeup tx active of the cluster

wakeup_tx_idle `instance-attribute` ¶

wakeup_tx_idle: int

get or set the wakeup tx idle of the cluster

verify ¶

verify() -> bool

verify the settings of a flexray cluster

FlexrayCommunicationConnector ¶

FlexrayCommunicationConnector(element: Element)

A connector between a [FlexrayCommunicationController] in an ECU and a [FlexrayPhysicalChannel]

controller `instance-attribute` ¶

controller: FlexrayCommunicationController

Get or set the controller of the CommunicationConnector

ecu_instance `instance-attribute` ¶

ecu_instance: EcuInstance

Get the EcuInstance that contains this CommunicationConnector

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

FlexrayCommunicationController ¶

FlexrayCommunicationController(element: Element)

An EcuInstance needs a FlexrayCommunicationController in order to connect to a Flexray cluster.

ecu_instance `instance-attribute` ¶

ecu_instance: EcuInstance

Get the EcuInstance that contains this FlexrayCommunicationController

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

connect_physical_channel ¶

connect_physical_channel(
    connection_name: str,
    flx_channel: FlexrayPhysicalChannel,
) -> FlexrayCommunicationConnector

Connect this [FlexrayCommunicationController] inside an [EcuInstance] to a [FlexrayPhysicalChannel] in the [crate::System]

Creates a FlexrayCommunicationConnector in the [EcuInstance] that contains this [FlexrayCommunicationController].

This function establishes the relationships

[FlexrayPhysicalChannel] -> FlexrayCommunicationConnector
FlexrayCommunicationConnector -> [FlexrayCommunicationController]

connected_channels ¶

connected_channels() -> Iterator[FlexrayPhysicalChannel]

return an iterator over the [FlexrayPhysicalChannel]s connected to this controller

FlexrayCommunicationCycle ¶

The timing settings of a Flexray frame

Counter `instance-attribute` ¶

Counter: Type[FlexrayCommunicationCycle_Counter]

Repetition `instance-attribute` ¶

Repetition: Type[FlexrayCommunicationCycle_Repetition]

FlexrayCommunicationCycle_Counter ¶

FlexrayCommunicationCycle_Counter(cycle_counter: int)

Bases: FlexrayCommunicationCycle

cycle_counter `instance-attribute` ¶

cycle_counter: int

FlexrayCommunicationCycle_Repetition ¶

FlexrayCommunicationCycle_Repetition(
    base_cycle: int, cycle_repetition: CycleRepetition
)

Bases: FlexrayCommunicationCycle

base_cycle `instance-attribute` ¶

base_cycle: int

cycle_repetition `instance-attribute` ¶

cycle_repetition: CycleRepetition

FlexrayFrame ¶

FlexrayFrame(element: Element)

a Flexray frame

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

get or set the length of the frame

name `instance-attribute` ¶

name: str

frame_triggerings ¶

frame_triggerings() -> List[FlexrayFrameTriggering]

List all FlexrayFrameTriggerings using this frame

map_pdu ¶

map_pdu(
    pdu: Pdu,
    start_position: int,
    byte_order: ByteOrder,
    /,
    *,
    update_bit: Optional[int] = None,
) -> FlexrayFrameTriggering

map a PDU to the frame

mapped_pdus ¶

mapped_pdus() -> Iterator[Pdu]

returns an iterator over all PDUs in the frame

FlexrayFrameTriggering ¶

FlexrayFrameTriggering(element: Element)

Iterator over all [FlexrayFrameTriggering]s using this frame map a PDU to the frame The frame triggering connects a frame to a physical channel

element `instance-attribute` ¶

element: Element

frame `instance-attribute` ¶

frame: Optional[FlexrayFrame]

get the frame triggered by the frame triggering

name `instance-attribute` ¶

name: str

physical_channel `instance-attribute` ¶

physical_channel: FlexrayPhysicalChannel

get the physical channel that contains this frame triggering

slot `instance-attribute` ¶

slot: Optional[int]

get or set the slot id for the flexray frame triggering

connect_to_ecu ¶

connect_to_ecu(
    ecu: EcuInstance, direction: CommunicationDirection
) -> FramePort

connect this frame triggering to an ECU

The frame triggering may be connected to any number of ECUs.

frame_ports ¶

frame_ports() -> Iterator[FramePort]

get the frame ports connected to this frame triggering

pdu_triggerings ¶

pdu_triggerings() -> Iterator[PduTriggering]

get the PDU triggerings referenced by this frame triggering

set_timing ¶

set_timing(timing: FlexrayCommunicationCycle) -> None

set the timing of the flexray frame

timing ¶

timing() -> Optional[FlexrayCommunicationCycle]

get the timing of the flexray frame

In a well-formed file this should always return a value

FlexrayNmCluster ¶

FlexrayNmCluster(element: Element)

Flexray specific NmCluster

channel_sleep_master `instance-attribute` ¶

channel_sleep_master: Optional[bool]

get or set or remove the nmChannelSleepMaster flag

communication_cluster `instance-attribute` ¶

communication_cluster: Optional[FlexrayCluster]

get or set the referenced FlexrayCluster

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

nm_data_cycle `instance-attribute` ¶

nm_data_cycle: Optional[int]

get or set the nmDataCycle

Number of Flexray Communication Cycles needed to transmit the Nm Data PDUs of all Flexray Nm Ecus of this FlexrayNmCluster.

nm_remote_sleep_indication_time `instance-attribute` ¶

nm_remote_sleep_indication_time: Optional[float]

get or set the nmRemoteSleepIndicationTime

Timeout for Remote Sleep Indication in seconds.

nm_repeat_message_time `instance-attribute` ¶

nm_repeat_message_time: Optional[float]

get or set the nmRepeatMessageTime

Timeout for Repeat Message State in seconds.

nm_repetition_cycle `instance-attribute` ¶

nm_repetition_cycle: Optional[int]

get or set the nmRepetitionCycle

Number of Flexray Communication Cycles used to repeat the transmission of the Nm vote Pdus of all Flexray NmEcus of this FlexrayNmCluster. This value shall be an integral multiple of nmVotingCycle.

nm_voting_cycle `instance-attribute` ¶

nm_voting_cycle: Optional[int]

get or set the nmVotingCycle

The number of Flexray Communication Cycles used to transmit the Nm Vote PDUs of all Flexray Nm Ecus of this FlexrayNmCluster.

node_detection_enabled `instance-attribute` ¶

node_detection_enabled: Optional[bool]

get or set the nmNodeDetectionEnabled flag

node_id_enabled `instance-attribute` ¶

node_id_enabled: Optional[bool]

get or set the nmNodeIdEnabled flag

pnc_cluster_vector_length `instance-attribute` ¶

pnc_cluster_vector_length: Optional[int]

get or set the pncClusterVectorLength

pnc_participation `instance-attribute` ¶

pnc_participation: Optional[bool]

get or set the nmPncParticipation flag

repeat_msg_ind_enabled `instance-attribute` ¶

repeat_msg_ind_enabled: Optional[bool]

get or set the nmRepeatMsgIndEnabled flag

synchronizing_network `instance-attribute` ¶

synchronizing_network: Optional[bool]

get or set the nmSynchronizingNetwork flag

create_flexray_nm_node ¶

create_flexray_nm_node(
    name: str,
    controller: FlexrayCommunicationController,
    nm_ecu: NmEcu,
) -> FlexrayNmNode

add a FlexrayNmNode to the cluster

nm_nodes ¶

nm_nodes() -> Iterator[FlexrayNmNode]

iterate over all NmNodes in this cluster

FlexrayNmClusterCoupling ¶

FlexrayNmClusterCoupling(element: Element)

A FlexrayNmClusterCoupling couples multipleFlexrayNmCluster`s.

element `instance-attribute` ¶

element: Element

nm_schedule_variant `instance-attribute` ¶

nm_schedule_variant: Optional[FlexrayNmScheduleVariant]

get or set the nmScheduleVariant

add_coupled_cluster ¶

add_coupled_cluster(cluster: FlexrayNmCluster) -> None

add a reference to a coupled NmCluster

coupled_clusters ¶

coupled_clusters() -> Iterator[FlexrayNmCluster]

iterate over all coupled NmClusters

FlexrayNmClusterSettings ¶

FlexrayNmClusterSettings(
    *,
    nm_data_cycle: int,
    nm_remote_sleep_indication_time: float,
    nm_repeat_message_time: float,
    nm_repetition_cycle: int,
    nm_voting_cycle: int,
)

Mandatory settings for a FlexrayNmCluster

These settings must be provided when creating a new FlexrayNmCluster. Additional optional settings can be set using FlexrayNmCluster methods.

nm_data_cycle `instance-attribute` ¶

nm_data_cycle: Optional[int]

nmDataCycle: Number of Flexray Communication Cycles needed to transmit the Nm Data PDUs of all Flexray Nm Ecus of this FlexrayNmCluster.

nm_remote_sleep_indication_time `instance-attribute` ¶

nm_remote_sleep_indication_time: Optional[float]

nmRemoteSleepIndicationTime: Timeout for Remote Sleep Indication in seconds.

nm_repeat_message_time `instance-attribute` ¶

nm_repeat_message_time: Optional[float]

nmRepeatMessageTime: Timeout for Repeat Message State in seconds.

nm_repetition_cycle `instance-attribute` ¶

nm_repetition_cycle: Optional[int]

nmRepetitionCycle: Number of Flexray Communication Cycles used to repeat the transmission of the Nm vote Pdus of all Flexray NmEcus of this FlexrayNmCluster. This value shall be an integral multiple of nmVotingCycle.

nm_voting_cycle `instance-attribute` ¶

nm_voting_cycle: Optional[int]

nmVotingCycle: The number of Flexray Communication Cycles used to transmit the Nm Vote PDUs of all Flexray Nm Ecus of this FlexrayNmCluster.

FlexrayNmNode ¶

FlexrayNmNode(element: Element)

A FlexrayNmNode represents a Flexray specific NmNode.

It connects a FlexrayCommunicationController with a NmEcu.

communication_controller `instance-attribute` ¶

communication_controller: Optional[
    FlexrayCommunicationController
]

get or set the referenced FlexrayCommunicationController

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

nm_ecu `instance-attribute` ¶

nm_ecu: Optional[NmEcu]

get or set the referenced NmEcu

node_id `instance-attribute` ¶

node_id: Optional[int]

get or set the nmNodeId This value is optional; if it is set to Some(x) the value is created, if it is set to None the value is removed.

passive_mode `instance-attribute` ¶

passive_mode: Optional[bool]

get or set ot remove the nmPassiveModeEnabled flag

This flag is optional; if it is set to Some(x) the value is created, if it is set to None the value is removed.

add_rx_nm_pdu ¶

add_rx_nm_pdu(nm_pdu: NmPdu) -> None

add an Rx NmPdu

Every NmNode must have at least one Rx NmPdu

add_tx_nm_pdu ¶

add_tx_nm_pdu(nm_pdu: NmPdu) -> None

add a Tx NmPdu

Active NmNodes must have at least one Tx NmPdu, while passive NmNodes may have none.

rx_nm_pdus ¶

rx_nm_pdus() -> Iterator[NmPdu]

iterate over all RX NmPdus

tx_nm_pdus ¶

tx_nm_pdus() -> Iterator[NmPdu]

iterate over all TX NmPdus

FlexrayNmScheduleVariant ¶

The FlexrayNmScheduleVariant defines the way the NM-Vote and NM-Data are transmitted within the Flexray network.

ScheduleVariant1 `instance-attribute` ¶

ScheduleVariant1: FlexrayNmScheduleVariant

ScheduleVariant2 `instance-attribute` ¶

ScheduleVariant2: FlexrayNmScheduleVariant

ScheduleVariant3 `instance-attribute` ¶

ScheduleVariant3: FlexrayNmScheduleVariant

ScheduleVariant4 `instance-attribute` ¶

ScheduleVariant4: FlexrayNmScheduleVariant

ScheduleVariant5 `instance-attribute` ¶

ScheduleVariant5: FlexrayNmScheduleVariant

ScheduleVariant6 `instance-attribute` ¶

ScheduleVariant6: FlexrayNmScheduleVariant

ScheduleVariant7 `instance-attribute` ¶

ScheduleVariant7: FlexrayNmScheduleVariant

FlexrayPhysicalChannel ¶

FlexrayPhysicalChannel(element: Element)

the FlexrayPhysicalChannel represents either channel A or B of Flexray cluster

channel_name `instance-attribute` ¶

channel_name: Optional[FlexrayChannelName]

get the channel name of a FlexrayPhysicalChannel

cluster `instance-attribute` ¶

cluster: FlexrayCluster

get the cluster containing this physical channel

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

frame_triggerings ¶

frame_triggerings() -> Iterator[FlexrayFrameTriggering]

iterate over all frame triggerings of this physical channel

pdu_triggerings ¶

pdu_triggerings() -> Iterator[PduTriggering]

iterate over all PDU triggerings of this physical channel

signal_triggerings ¶

signal_triggerings() -> Iterator[ISignalTriggering]

iterate over all signal triggerings of this physical channel

trigger_frame ¶

trigger_frame(
    frame: FlexrayFrame,
    slot_id: int,
    timing: FlexrayCommunicationCycle,
) -> FlexrayFrameTriggering

add a trigger for a flexray frame in this physical channel

FlexrayPhysicalChannelsInfo ¶

Information about the flexray physical channels present inside a cluster

channel_a `instance-attribute` ¶

channel_a: Optional[FlexrayPhysicalChannel]

get the channel A of the cluster

channel_b `instance-attribute` ¶

channel_b: Optional[FlexrayPhysicalChannel]

get the channel B of the cluster

FlexrayTpConfig ¶

FlexrayTpConfig(element: Element)

FlexrayTpConfig defines exactly one Flexray ISO TP Configuration

cluster `instance-attribute` ¶

cluster: Optional[FlexrayCluster]

get or set the FlexrayCluster of the FlexrayTpConfig

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

create_flexray_tp_connection ¶

create_flexray_tp_connection(
    name: Optional[str],
    transmitter: FlexrayTpNode,
    direct_tp_sdu: IPdu,
    connection_control: FlexrayTpConnectionControl,
) -> FlexrayTpConnection

create a new FlexrayTpConnection

create_flexray_tp_connection_control ¶

create_flexray_tp_connection_control(
    name: str,
) -> FlexrayTpConnectionControl

create a new FlexrayTpConnectionControl

create_flexray_tp_ecu ¶

create_flexray_tp_ecu(
    ecu_instance: EcuInstance, full_duplex_enabled: bool
) -> FlexrayTpEcu

add a FlexrayTpEcu to the FlexrayTpConfig

create_flexray_tp_node ¶

create_flexray_tp_node(name: str) -> FlexrayTpNode

create a new FlexrayTpNode

create_flexray_tp_pdu_pool ¶

create_flexray_tp_pdu_pool(name: str) -> FlexrayTpPduPool

create a new FlexrayTpPduPool

create_tp_address ¶

create_tp_address(name: str, address: int) -> TpAddress

create a new TpAddress

flexray_tp_connection_controls ¶

flexray_tp_connection_controls() -> Iterator[
    FlexrayTpConnectionControl
]

iterate over all FlexrayTpConnectionControls

flexray_tp_connections ¶

flexray_tp_connections() -> Iterator[FlexrayTpConnection]

iterate over all FlexrayTpConnections

flexray_tp_ecus ¶

flexray_tp_ecus() -> Iterator[FlexrayTpEcu]

iterate over all FlexrayTpEcus

flexray_tp_nodes ¶

flexray_tp_nodes() -> Iterator[FlexrayTpNode]

iterate over all FlexrayTpNodes

flexray_tp_pdu_pools ¶

flexray_tp_pdu_pools() -> Iterator[FlexrayTpPduPool]

iterate over all FlexrayTpPduPools

tp_addresses ¶

tp_addresses() -> Iterator[TpAddress]

iterate over all TpAddresses

FlexrayTpConnection ¶

FlexrayTpConnection(element: Element)

A FlexrayTpConnection defines a connection between FlexrayTpNodes

connection_control `instance-attribute` ¶

connection_control: Optional[FlexrayTpConnectionControl]

get or set the connection control of the connection

direct_tp_sdu `instance-attribute` ¶

direct_tp_sdu: Optional[IPdu]

get or set the direct TP SDU of the connection

element `instance-attribute` ¶

element: Element

multicast_address `instance-attribute` ¶

multicast_address: Optional[TpAddress]

get or set the multicast TpAddress of the connection

name `instance-attribute` ¶

name: str

reversed_tp_sdu `instance-attribute` ¶

reversed_tp_sdu: Optional[IPdu]

get or set the reversed TP SDU of the connection This is used if the connection supports both sending and receiving

rx_pdu_pool `instance-attribute` ¶

rx_pdu_pool: Optional[FlexrayTpPduPool]

get or set the RX FlexrayTpPduPool of the connection

transmitter `instance-attribute` ¶

transmitter: Optional[FlexrayTpNode]

get or set the transmitter of the connection

tx_pdu_pool `instance-attribute` ¶

tx_pdu_pool: Optional[FlexrayTpPduPool]

get or set the TX FlexrayTpPduPool of the connection

add_receiver ¶

add_receiver(receiver: FlexrayTpNode) -> None

add a receiver to the connection

receivers ¶

receivers() -> Iterator[FlexrayTpNode]

iterate over all receivers of the connection

FlexrayTpConnectionControl ¶

FlexrayTpConnectionControl(element: Element)

A FlexrayTpConnectionControl defines the connection control parameters for a FlexrayTpConnection

element `instance-attribute` ¶

element: Element

max_fc_wait `instance-attribute` ¶

max_fc_wait: Optional[int]

get or set the maxFcWait value

max_number_of_npdu_per_cycle `instance-attribute` ¶

max_number_of_npdu_per_cycle: Optional[int]

get or set the maxNumberOfNpduPerCycle value

max_retries `instance-attribute` ¶

max_retries: Optional[int]

get or set the maxRetries value

name `instance-attribute` ¶

name: str

separation_cycle_exponent `instance-attribute` ¶

separation_cycle_exponent: Optional[int]

get or set the separationCycleExponent value

FlexrayTpEcu ¶

FlexrayTpEcu(element: Element)

A FlexrayTpEcu represents an ECU within the FlexrayTpConfig

cancellation `instance-attribute` ¶

cancellation: Optional[bool]

get or set the cancellation status of the FlexrayTpEcu

cycle_time_main_function `instance-attribute` ¶

cycle_time_main_function: Optional[float]

get or set the cycle time of the TP main function in seconds

ecu_instance `instance-attribute` ¶

ecu_instance: Optional[EcuInstance]

get or set the ECU instance of the FlexrayTpEcu

element `instance-attribute` ¶

element: Element

full_duplex_enabled `instance-attribute` ¶

full_duplex_enabled: Optional[bool]

get or set the full duplex enabled flag of the FlexrayTpEcu

FlexrayTpNode ¶

FlexrayTpNode(element: Element)

A FlexrayTpNode provides the TP address and the connection to the topology description in a FlexrayTpConfig

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

tp_address `instance-attribute` ¶

tp_address: Optional[TpAddress]

set or remove FlexrayTpAddress of the node A TP address is mandatory for unicast nodes, but optional for multicast nodes Setting None will remove the element

add_communication_connector ¶

add_communication_connector(
    connector: FlexrayCommunicationConnector,
) -> None

add a FlexrayCommunicationConnector to the node The node can be associated with up to 2 connectors. In a system description this reference is mandatory.

communication_connectors ¶

communication_connectors() -> Iterator[
    FlexrayCommunicationConnector
]

iterate over all FlexrayCommunicationConnectors of the node

FlexrayTpPduPool ¶

FlexrayTpPduPool(element: Element)

A FlexrayTpPduPool contains a set of NPdus that can be used for sending and receiving

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

add_n_pdu ¶

add_n_pdu(n_pdu: NPdu) -> None

add an NPdu to the PduPool

n_pdus ¶

n_pdus() -> Iterator[NPdu]

iterate over all referenced NPdus

FrArTpAckType ¶

Types of Acknowledgement that can be used in an FlexrayArTpChannel

AckWithRt `instance-attribute` ¶

AckWithRt: FrArTpAckType

AckWithoutRt `instance-attribute` ¶

AckWithoutRt: FrArTpAckType

NoAck `instance-attribute` ¶

NoAck: FrArTpAckType

FramePort ¶

FramePort(element: Element)

The FramePort allows an ECU to send or receive a frame

communication_direction `instance-attribute` ¶

communication_direction: Optional[CommunicationDirection]

get or set the communication direction of the frame port

ecu `instance-attribute` ¶

ecu: EcuInstance

get the ECU instance that contains this frame port

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

GeneralPurposeIPdu ¶

GeneralPurposeIPdu(element: Element)

This element is used for AUTOSAR Pdus without attributes that are routed by the PduR

category `instance-attribute` ¶

category: Optional[GeneralPurposeIPduCategory]

get the category of this PDU

contained_ipdu_props `instance-attribute` ¶

contained_ipdu_props: Optional[ContainedIPduProps]

set the ContainedIPduProps for this IPdu This is only needed when the IPdu is contained in a ContainerIPdu

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

get or set the length of this PDU

name `instance-attribute` ¶

name: str

pdu_triggerings ¶

pdu_triggerings() -> List[PduTriggering]

list all PduTriggerings that trigger this PDU

GeneralPurposeIPduCategory ¶

The category of a GeneralPurposeIPdu

The Autosar standard defines the following categories: - XCP - SOMEIP_SEGMENTED_IPDU - DLT

Dlt `instance-attribute` ¶

Dlt: GeneralPurposeIPduCategory

SomeipSegmentedIpdu `instance-attribute` ¶

SomeipSegmentedIpdu: GeneralPurposeIPduCategory

Xcp `instance-attribute` ¶

Xcp: GeneralPurposeIPduCategory

GeneralPurposePdu ¶

GeneralPurposePdu(element: Element)

This element is used for AUTOSAR Pdus without additional attributes that are routed by a bus interface

category `instance-attribute` ¶

category: Optional[GeneralPurposePduCategory]

get or set the category of this PDU

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

get or set the length of this PDU

name `instance-attribute` ¶

name: str

pdu_triggerings ¶

pdu_triggerings() -> List[PduTriggering]

list all PduTriggerings that trigger this PDU

GeneralPurposePduCategory ¶

The category of a GeneralPurposePdu

The Autosar standard defines the following categories: - SD - GLOBAL_TIME - DOIP

DoIp `instance-attribute` ¶

DoIp: GeneralPurposePduCategory

GlobalTime `instance-attribute` ¶

GlobalTime: GeneralPurposePduCategory

Sd `instance-attribute` ¶

Sd: GeneralPurposePduCategory

GenericTransformationTechnologyConfig ¶

GenericTransformationTechnologyConfig(
    *,
    protocol_name: str,
    protocol_version: str,
    header_length: int,
    in_place: bool,
)

Configuration for a generic transformation technology For a generic trasformation, the mandatory values must be chosen by the user

header_length `instance-attribute` ¶

header_length: int

The length of the header in bits

in_place `instance-attribute` ¶

in_place: bool

Should the transformation take place in the existing buffer or in a separate buffer?

protocol_name `instance-attribute` ¶

protocol_name: str

The name of the custom protocol

protocol_version `instance-attribute` ¶

protocol_version: str

The version of the custom protocol

IPduPort ¶

IPduPort(element: Element)

The IPduPort allows an ECU to send or receive a PDU

communication_direction `instance-attribute` ¶

communication_direction: Optional[CommunicationDirection]

get or set the communication direction of this IPduPort

ecu `instance-attribute` ¶

ecu: EcuInstance

get the ECU instance that contains this IPduPort

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

IPv4AddressSource ¶

IPv4AddressSource defines how the address of an IPv4 NetworkEndpoint is obtained

AutoIp `instance-attribute` ¶

AutoIp: IPv4AddressSource

AutoIpDoIp `instance-attribute` ¶

AutoIpDoIp: IPv4AddressSource

DHCPv4 `instance-attribute` ¶

DHCPv4: IPv4AddressSource

Fixed `instance-attribute` ¶

Fixed: IPv4AddressSource

IPv6AddressSource ¶

IPv6AddressSource defines how the address of an IPv6 NetworkEndpoint is obtained

DHCPv6 `instance-attribute` ¶

DHCPv6: IPv6AddressSource

Fixed `instance-attribute` ¶

Fixed: IPv6AddressSource

LinkLocal `instance-attribute` ¶

LinkLocal: IPv6AddressSource

LinkLocalDoIp `instance-attribute` ¶

LinkLocalDoIp: IPv6AddressSource

RouterAdvertisement `instance-attribute` ¶

RouterAdvertisement: IPv6AddressSource

ISignal ¶

ISignal(element: Element)

Signal of the Interaction Layer

datatype `instance-attribute` ¶

datatype: Optional[SwBaseType]

get or set the data type for this signal

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

set the length of this signal in bits

name `instance-attribute` ¶

name: str

signal_group `instance-attribute` ¶

signal_group: Optional[ISignalGroup]

get the signal group that contains this signal, if any

system_signal `instance-attribute` ¶

system_signal: Optional[SystemSignal]

get the system signal that corresponds to this isignal

add_data_transformation ¶

add_data_transformation(
    data_transformation: DataTransformation,
) -> None

add a data transformation to this signal

create_e2e_transformation_isignal_props ¶

create_e2e_transformation_isignal_props(
    transformer: TransformationTechnology,
) -> EndToEndTransformationISignalProps

create E2E transformation properties for this signal

create_someip_transformation_isignal_props ¶

create_someip_transformation_isignal_props(
    transformer: TransformationTechnology,
) -> SomeIpTransformationISignalProps

create SomeIp transformation properties for this signal

data_transformations ¶

data_transformations() -> Iterator[DataTransformation]

get all data transformations that are applied to this signal

mappings ¶

mappings() -> List[ISignalToIPduMapping]

list all ISignalToIPduMapping for this signal

Usually a signal should only be mapped to a single PDU, so this list is expected to contain either zero or one items in ordinary cases.

signal_triggerings ¶

signal_triggerings() -> List[ISignalTriggering]

list all ISignalTriggerings that trigger this signal

transformation_isignal_props ¶

transformation_isignal_props() -> Iterator[
    Union[
        EndToEndTransformationISignalProps,
        SomeIpTransformationISignalProps,
    ]
]

get all transformation properties that are applied to this signal

ISignalGroup ¶

ISignalGroup(element: Element)

An ISignalGroup groups signals that should always be kept together

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

system_signal_group `instance-attribute` ¶

system_signal_group: Optional[SystemSignalGroup]

get the system signal group that is associated with this signal group

add_data_transformation ¶

add_data_transformation(
    data_transformation: DataTransformation,
) -> None

add a data transformation to this signal group

add_signal ¶

add_signal(signal: ISignal) -> None

Add a signal to the signal group

create_e2e_transformation_isignal_props ¶

create_e2e_transformation_isignal_props(
    transformer: TransformationTechnology,
) -> EndToEndTransformationISignalProps

create E2E transformation properties for this signal group

create_someip_transformation_isignal_props ¶

create_someip_transformation_isignal_props(
    transformer: TransformationTechnology,
) -> SomeIpTransformationISignalProps

create SomeIp transformation properties for this signal group

data_transformations ¶

data_transformations() -> Iterator[DataTransformation]

iterate over all data transformations that are applied to this signal group

signals ¶

signals() -> Iterator[ISignal]

Iterator over all [ISignal]s in this group

Example¶

transformation_isignal_props ¶

transformation_isignal_props() -> Iterator[
    Union[
        EndToEndTransformationISignalProps,
        SomeIpTransformationISignalProps,
    ]
]

get all transformation properties that are applied to this signal group

ISignalIPdu ¶

ISignalIPdu(element: Element)

Represents the IPdus handled by Com

contained_ipdu_props `instance-attribute` ¶

contained_ipdu_props: Optional[ContainedIPduProps]

set the ContainedIPduProps for this IPdu This is only needed when the IPdu is contained in a ContainerIPdu

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

get or set the length of this PDU

name `instance-attribute` ¶

name: str

map_signal ¶

map_signal(
    signal: ISignal,
    start_position: int,
    byte_order: ByteOrder,
    /,
    *,
    update_bit: Optional[int] = None,
    transfer_property: TransferProperty = TransferProperty.Pending,
) -> ISignalToIPduMapping

map a signal to the ISignalIPdu

If this signal is part of a signal group, then the group must be mapped first

map_signal_group ¶

map_signal_group(
    signal_group: ISignalGroup,
) -> ISignalToIPduMapping

map a signal group to the PDU

mapped_signals ¶

mapped_signals() -> Iterator[Union[ISignal, ISignalGroup]]

returns an iterator over all signals and signal groups mapped to the PDU

pdu_triggerings ¶

pdu_triggerings() -> List[PduTriggering]

list all PduTriggerings that trigger this PDU

set_timing ¶

set_timing(timing_spec: IpduTiming) -> None

set the transmission timing of the PDU

timing ¶

timing() -> IpduTiming

Helper function to set the transmission mode timing, used by ISignalIPdu::set_timing for both true and false timing get the transmission timing of the PDU

ISignalPort ¶

ISignalPort(element: Element)

The ISignalPort allows an ECU to send or receive a Signal

communication_direction `instance-attribute` ¶

communication_direction: Optional[CommunicationDirection]

get or set the communication direction of this port

ecu `instance-attribute` ¶

ecu: EcuInstance

get the ECU that is connected to this signal port

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

ISignalToIPduMapping ¶

ISignalToIPduMapping(element: Element)

ISignalToIPduMapping connects an ISignal or ISignalGroup to an ISignalToIPdu

byte_order `instance-attribute` ¶

byte_order: Optional[ByteOrder]

get or set the byte order of the data in the mapped signal.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

signal `instance-attribute` ¶

signal: Optional[ISignal]

Reference to the signal that is mapped to the PDU. Every mapping contains either a signal or a signal group.

signal_group `instance-attribute` ¶

signal_group: Optional[ISignalGroup]

Reference to the signal group that is mapped to the PDU. Every mapping contains either a signal or a signal group.

start_position `instance-attribute` ¶

start_position: Optional[int]

Start position of the signal data within the PDU (bit position). The start position is mandatory if the mapping describes a signal.

transfer_property `instance-attribute` ¶

transfer_property: Optional[TransferProperty]

Set the transfer property of the mapped signal

update_bit `instance-attribute` ¶

update_bit: Optional[int]

Bit position of the update bit for the mapped signal. Not all signals use an update bit. This is never used for signal groups

ISignalTriggering ¶

ISignalTriggering(element: Element)

an ISignalTriggering triggers a signal in a PDU

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

physical_channel `instance-attribute` ¶

physical_channel: PhysicalChannel

get the physical channel that contains this signal triggering

connect_to_ecu ¶

connect_to_ecu(
    ecu: EcuInstance, direction: CommunicationDirection
) -> ISignalPort

connect this signal triggering to an ECU

signal_ports ¶

signal_ports() -> Iterator[ISignalPort]

create an iterator over all signal ports that are connected to this signal triggering

InitialSdDelayConfig ¶

InitialSdDelayConfig(
    *,
    initial_delay_max_value: float,
    initial_delay_min_value: float,
    initial_repetitions_base_delay: Optional[float] = None,
    initial_repetitions_max: Optional[int] = None,
)

A InitialSdDelayConfig contains the configuration for the initial delay of an SD client or server

initial_delay_max_value `instance-attribute` ¶

initial_delay_max_value: float

maximum value of the randomized delay in seconds

initial_delay_min_value `instance-attribute` ¶

initial_delay_min_value: float

minimum value of the randomized delay in seconds

initial_repetitions_base_delay `instance-attribute` ¶

initial_repetitions_base_delay: Optional[float]

base delay for repetitions in seconds

initial_repetitions_max `instance-attribute` ¶

initial_repetitions_max: Optional[int]

maximum number of repetitions

IpduTiming ¶

IpduTiming(
    *,
    minimum_delay: Optional[float] = None,
    transmission_mode_true_timing: Optional[
        TransmissionModeTiming
    ] = None,
    transmission_mode_false_timing: Optional[
        TransmissionModeTiming
    ] = None,
)

Timing specification for an IPDU

minimum_delay `instance-attribute` ¶

minimum_delay: Optional[float]

minimum delay in seconds between two transmissions of the PDU

transmission_mode_false_timing `instance-attribute` ¶

transmission_mode_false_timing: Optional[
    TransmissionModeTiming
]

timing specification if the COM transmission mode is false

transmission_mode_true_timing `instance-attribute` ¶

transmission_mode_true_timing: Optional[
    TransmissionModeTiming
]

timing specification if the COM transmission mode is true

LocalUnicastAddress ¶

A LocalUnicastAddress is a local address (TCP or UDP) that can be used for a ProvidedServiceInstance or ConsumedServiceInstance

Tcp `instance-attribute` ¶

Tcp: Type[LocalUnicastAddress_Tcp]

Udp `instance-attribute` ¶

Udp: Type[LocalUnicastAddress_Udp]

LocalUnicastAddress_Tcp ¶

LocalUnicastAddress_Tcp(address: SocketAddress)

Bases: LocalUnicastAddress

address `instance-attribute` ¶

address: SocketAddress

LocalUnicastAddress_Udp ¶

LocalUnicastAddress_Udp(address: SocketAddress)

Bases: LocalUnicastAddress

address `instance-attribute` ¶

address: SocketAddress

MaximumMessageLengthType ¶

Types of Maximum Message Length that can be used in an FlexrayArTpChannel

I4g `instance-attribute` ¶

I4g: MaximumMessageLengthType

Iso `instance-attribute` ¶

Iso: MaximumMessageLengthType

Iso6 `instance-attribute` ¶

Iso6: MaximumMessageLengthType

MultiplexedIPdu ¶

MultiplexedIPdu(element: Element)

The multiplexed pdu contains one of serveral signal pdus

contained_ipdu_props `instance-attribute` ¶

contained_ipdu_props: Optional[ContainedIPduProps]

set the ContainedIPduProps for this IPdu This is only needed when the IPdu is contained in a ContainerIPdu

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

get or set the length of this PDU

name `instance-attribute` ¶

name: str

pdu_triggerings ¶

pdu_triggerings() -> List[PduTriggering]

list all PduTriggerings that trigger this PDU

NPdu ¶

NPdu(element: Element)

This is a Pdu of the transport layer. The main purpose of the TP layer is to segment and reassemble IPdus.

contained_ipdu_props `instance-attribute` ¶

contained_ipdu_props: Optional[ContainedIPduProps]

set the ContainedIPduProps for this IPdu This is only needed when the IPdu is contained in a ContainerIPdu

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

get or set the length of this PDU

name `instance-attribute` ¶

name: str

pdu_triggerings ¶

pdu_triggerings() -> List[PduTriggering]

list all PduTriggerings that trigger this PDU

NetworkEndpoint ¶

NetworkEndpoint(element: Element)

A network endpoint contains address information for a connection

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

add_network_endpoint_address ¶

add_network_endpoint_address(
    address: NetworkEndpointAddress,
) -> None

add a network endpoint address to this NetworkEndpoint

A NetworkEndpoint may have multiple sets of address information. The following restrictions apply:

all addresses must have the same type, i.e. all IPv4 or all IPv6
only one of them may be a Fixed address, all others must be dynamic (DHCP, automatic link local, etc.)

addresses ¶

addresses() -> Iterator[NetworkEndpointAddress]

iterator over all addresses in the NetworkEndpoint

NetworkEndpointAddress ¶

address information for a network endpoint

IPv4 `instance-attribute` ¶

IPv4: Type[NetworkEndpointAddress_IPv4]

IPv6 `instance-attribute` ¶

IPv6: Type[NetworkEndpointAddress_IPv6]

NetworkEndpointAddress_IPv4 ¶

NetworkEndpointAddress_IPv4(
    *,
    address: Optional[str] = None,
    address_source: Optional[IPv4AddressSource] = None,
    default_gateway: Optional[str] = None,
    network_mask: Optional[str] = None,
)

Bases: NetworkEndpointAddress

address `instance-attribute` ¶

address: Optional[str]

address_source `instance-attribute` ¶

address_source: Optional[IPv4AddressSource]

default_gateway `instance-attribute` ¶

default_gateway: Optional[str]

network_mask `instance-attribute` ¶

network_mask: Optional[str]

NetworkEndpointAddress_IPv6 ¶

NetworkEndpointAddress_IPv6(
    *,
    address: Optional[str] = None,
    address_source: Optional[IPv6AddressSource] = None,
    default_router: Optional[str] = None,
)

Bases: NetworkEndpointAddress

address `instance-attribute` ¶

address: Optional[str]

address_source `instance-attribute` ¶

address_source: Optional[IPv6AddressSource]

default_router `instance-attribute` ¶

default_router: Optional[str]

NmConfig ¶

NmConfig(element: Element)

The NmConfig is the root element for the network management configuration.

Only one config may exist per System, and this configuration may contain multiple NmClusters for different bus types.

Use System::create_nm_config to create a new NmConfig in a System.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

create_can_nm_cluster ¶

create_can_nm_cluster(
    name: str,
    settings: CanNmClusterSettings,
    can_cluster: CanCluster,
) -> CanNmCluster

create a new CanNmCluster

create_can_nm_cluster_coupling ¶

create_can_nm_cluster_coupling(
    nm_busload_reduction_enabled: bool,
    nm_immediate_restart_enabled: bool,
) -> CanNmClusterCoupling

create a new CanNmClusterCoupling

create_flexray_nm_cluster ¶

create_flexray_nm_cluster(
    name: str,
    settings: FlexrayNmClusterSettings,
    flexray_cluster: FlexrayCluster,
) -> FlexrayNmCluster

create a new FlexrayNmCluster

create_flexray_nm_cluster_coupling ¶

create_flexray_nm_cluster_coupling(
    nm_schedule_variant: FlexrayNmScheduleVariant,
) -> FlexrayNmClusterCoupling

create a new FlexrayNmClusterCoupling

create_nm_ecu ¶

create_nm_ecu(
    name: str, ecu_instance: EcuInstance
) -> NmEcu

create a new NmEcu

create_udp_nm_cluster ¶

create_udp_nm_cluster(
    name: str,
    settings: UdpNmClusterSettings,
    ethernet_cluster: EthernetCluster,
) -> UdpNmCluster

create a new UdpNmCluster

create_udp_nm_cluster_coupling ¶

create_udp_nm_cluster_coupling() -> UdpNmClusterCoupling

create a new UdpNmClusterCoupling

nm_cluster_couplings ¶

nm_cluster_couplings() -> Iterator[
    Union[
        CanNmClusterCoupling,
        FlexrayNmClusterCoupling,
        UdpNmClusterCoupling,
    ]
]

iterate over all NmClusterCouplings

nm_clusters ¶

nm_clusters() -> Iterator[
    Union[CanNmCluster, FlexrayNmCluster, UdpNmCluster]
]

get all NmClusters

nm_ecus ¶

nm_ecus() -> Iterator[NmEcu]

iterate over all NmEcus

NmEcu ¶

NmEcu(element: Element)

The NmEcu represents an EcuInstance wich participates in network management.

cycle_time_main_function `instance-attribute` ¶

cycle_time_main_function: Optional[float]

get or set or remove the nmCycletimeMainFunction value

ecu_instance `instance-attribute` ¶

ecu_instance: Optional[EcuInstance]

get or set the referenced EcuInstance

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

nm_bus_synchronization_enabled `instance-attribute` ¶

nm_bus_synchronization_enabled: Optional[bool]

get or set the nmBusSynchronizationEnabled flag

nm_com_control_enabled `instance-attribute` ¶

nm_com_control_enabled: Optional[bool]

get or set the nmComControlEnabled flag

NmPdu ¶

NmPdu(element: Element)

Network Management Pdu

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

get or set the length of this PDU

name `instance-attribute` ¶

name: str

pdu_triggerings ¶

pdu_triggerings() -> List[PduTriggering]

List all PduTriggerings that trigger this PDU

PduActivationRoutingGroup ¶

PduActivationRoutingGroup(element: Element)

A group of Pdus that can be activated or deactivated for transmission over a socket connection. It is used by EventHandlers in ProvidedServiceInstances and ConsumedServiceInstances.

element `instance-attribute` ¶

element: Element

event_group_control_type `instance-attribute` ¶

event_group_control_type: Optional[EventGroupControlType]

get or set the event group control type of this PduActivationRoutingGroup

name `instance-attribute` ¶

name: str

add_ipdu_identifier_tcp ¶

add_ipdu_identifier_tcp(
    ipdu_identifier: SoConIPduIdentifier,
) -> None

add a reference to a SoConIPduIdentifier for TCP communication to this PduActivationRoutingGroup

add_ipdu_identifier_udp ¶

add_ipdu_identifier_udp(
    ipdu_identifier: SoConIPduIdentifier,
) -> None

add a reference to a SoConIPduIdentifier for UDP communication to this PduActivationRoutingGroup

ipdu_identifiers_tcp ¶

ipdu_identifiers_tcp() -> Iterator[SoConIPduIdentifier]

get all SoConIPduIdentifiers for TCP communication in this PduActivationRoutingGroup

ipdu_identifiers_udp ¶

ipdu_identifiers_udp() -> Iterator[SoConIPduIdentifier]

get all SoConIPduIdentifiers for UDP communication in this PduActivationRoutingGroup

PduCollectionTrigger ¶

The collction trigger defines whether a Pdu contributes to the triggering of the data transmission if Pdu collection is enabled

Always `instance-attribute` ¶

Always: PduCollectionTrigger

Never `instance-attribute` ¶

Never: PduCollectionTrigger

PduToFrameMapping ¶

PduToFrameMapping(element: Element)

PduToFrameMapping connects a PDU to a frame

byte_order `instance-attribute` ¶

byte_order: Optional[ByteOrder]

get or set the byte order of the data in the PDU.

All PduToFrameMappings within a frame must have the same byte order. PDUs may not use the byte order value Opaque.

Note: If the byte order is swapped, then the start position must be adjusted accordingly.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

pdu `instance-attribute` ¶

pdu: Optional[Pdu]

Reference to the PDU that is mapped into the frame. The PDU reference is mandatory.

start_position `instance-attribute` ¶

start_position: Optional[int]

set the start position of the PDU data within the frame (bit position).

PDUs are byte aligned. For little-endian data the values 0, 8, 16, ... are allowed; for big-endian data the values 7, 15, 23, ... are allowed.

Note: if you intend to change both the byte order and the start position, then you should change the byte order first. New values set here must match the configured byte order.

update_bit `instance-attribute` ¶

update_bit: Optional[int]

set or clear the bit position of the update bit for the mapped PDU.

PduTriggering ¶

PduTriggering(element: Element)

a PduTriggering triggers a PDU in a frame or ethernet connection

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

pdu `instance-attribute` ¶

pdu: Optional[Pdu]

get the Pdu that is triggered by this pdu triggering

physical_channel `instance-attribute` ¶

physical_channel: PhysicalChannel

get the physical channel that contains this pdu triggering

create_pdu_port ¶

create_pdu_port(
    ecu: EcuInstance, direction: CommunicationDirection
) -> IPduPort

create an IPduPort to connect a PduTriggering to an EcuInstance

pdu_ports ¶

pdu_ports() -> Iterator[IPduPort]

create an iterator over the IPduPorts that are connected to this PduTriggering

signal_triggerings ¶

signal_triggerings() -> Iterator[ISignalTriggering]

create an iterator over the ISignalTriggerings that are triggered by this PduTriggering

ProvidedServiceInstance ¶

ProvidedServiceInstance(element: Element)

A ProvidedServiceInstance is a service that is provided by an ECU

element `instance-attribute` ¶

element: Element

instance_identifier `instance-attribute` ¶

instance_identifier: Optional[int]

get or set the instance identifier of this ProvidedServiceInstance

major_version `instance-attribute` ¶

major_version: Optional[int]

get or set the major version of this ProvidedServiceInstance

minor_version `instance-attribute` ¶

minor_version: Optional[int]

get or set the minor version of this ProvidedServiceInstance

name `instance-attribute` ¶

name: str

sd_server_instance_config `instance-attribute` ¶

sd_server_instance_config: Optional[
    SomeipSdServerServiceInstanceConfig
]

get or set the SD server instance configuration for this ProvidedServiceInstance

service_identifier `instance-attribute` ¶

service_identifier: Optional[int]

get or set the service identifier of this ProvidedServiceInstance

create_event_handler ¶

create_event_handler(
    name: str, event_group_identifier: int
) -> EventHandler

create a new EventHandler in this ProvidedServiceInstance

event_handlers ¶

event_handlers() -> Iterator[EventHandler]

get the EventHandlers in this ProvidedServiceInstance

local_unicast_addresses ¶

local_unicast_addresses() -> Iterator[LocalUnicastAddress]

iterate over the local unicast addresses

set_local_unicast_address ¶

set_local_unicast_address(address: SocketAddress) -> None

set a local unicast address for this ProvidedServiceInstance

The PSI may use two local unicast addresses, one each for UDP and TCP. The unicast address is used to assign the service to a specific ECU, and may not be empty.

ProvidedServiceInstanceV1 ¶

ProvidedServiceInstanceV1(element: Element)

A ProvidedServiceInstanceV1 is a SD service instance that is provided by this ECU.

This is the old V1 version of the service definition.

element `instance-attribute` ¶

element: Element

instance_identifier `instance-attribute` ¶

instance_identifier: Optional[int]

get or set the instance identifier of this ProvidedServiceInstance

name `instance-attribute` ¶

name: str

service_identifier `instance-attribute` ¶

service_identifier: Optional[int]

get or set the service identifier of this ProvidedServiceInstance

create_event_handler ¶

create_event_handler(name: str) -> EventHandlerV1

create a new EventHandlerV1 in this ProvidedServiceInstance

event_handlers ¶

event_handlers() -> Iterator[EventHandlerV1]

get the EventHandlerV1s in this ProvidedServiceInstance

sd_server_config ¶

sd_server_config() -> Optional[SdConfig]

get or set the SD server configuration for this ProvidedServiceInstance

set_sd_server_config ¶

set_sd_server_config(sd_server_config: SdConfig) -> None

get or set the SD server configuration for this ProvidedServiceInstance

RequestResponseDelay ¶

RequestResponseDelay(*, min_value: float, max_value: float)

A RequestResponseDelay contains the minimum and maximum delay for a request-response cycle

max_value `instance-attribute` ¶

max_value: float

set the maximum value of this RequestResponseDelay

min_value `instance-attribute` ¶

min_value: float

set the minimum value of this RequestResponseDelay

RxAcceptContainedIPdu ¶

The RxAcceptContainedIPdu enum defines whether a fixed set of contained IPdus is accepted or all contained IPdus

AcceptAll `instance-attribute` ¶

AcceptAll: RxAcceptContainedIPdu

AcceptConfigured `instance-attribute` ¶

AcceptConfigured: RxAcceptContainedIPdu

SdConfig ¶

SdConfig(
    *,
    service_major_version: int,
    service_minor_version: int,
    initial_delay_max_value: float,
    initial_delay_min_value: float,
    initial_repetitions_base_delay: Optional[float] = None,
    initial_repetitions_max: int,
    offer_cyclic_delay: Optional[float] = None,
    request_response_delay_max_value: float,
    request_response_delay_min_value: float,
    ttl: int,
)

SD configuration for a service instance

This struct is used to configure the SD server and client behavior for a service instance. it is used for the old V1 service definitions.

initial_delay_max_value `instance-attribute` ¶

initial_delay_max_value: float

The maximum delay for the initial offer

initial_delay_min_value `instance-attribute` ¶

initial_delay_min_value: float

The minimum delay for the initial offer

initial_repetitions_base_delay `instance-attribute` ¶

initial_repetitions_base_delay: Optional[float]

The base delay for offer repetitions (if aggregated by SdServerConfig) or find repetitions (if aggregated by SdClientConfig)

initial_repetitions_max `instance-attribute` ¶

initial_repetitions_max: int

The maximum number of repetitions for the initial offer or find

offer_cyclic_delay `instance-attribute` ¶

offer_cyclic_delay: Optional[float]

The delay between two offers (if aggregated by SdServerConfig) or finds (if aggregated by SdClientConfig)

request_response_delay_max_value `instance-attribute` ¶

request_response_delay_max_value: float

The maximum delay for a request-response cycle

request_response_delay_min_value `instance-attribute` ¶

request_response_delay_min_value: float

The minimum delay for a request-response cycle

service_major_version `instance-attribute` ¶

service_major_version: int

The major version of the service

service_minor_version `instance-attribute` ¶

service_minor_version: int

The minor version of the service

ttl `instance-attribute` ¶

ttl: int

The time-to-live for the service offer

SdEventConfig ¶

SdEventConfig(
    *,
    request_response_delay_max_value: float,
    request_response_delay_min_value: float,
    ttl: int,
)

Configuration for an SD event handler

request_response_delay_max_value `instance-attribute` ¶

request_response_delay_max_value: float

The maximum delay for a request-response cycle

request_response_delay_min_value `instance-attribute` ¶

request_response_delay_min_value: float

The minimum delay for a request-response cycle

ttl `instance-attribute` ¶

ttl: int

The time-to-live for the service offer

SecureCommunicationProps ¶

SecureCommunicationProps(
    *,
    auth_data_freshness_length: Optional[int] = None,
    auth_data_freshness_start_position: Optional[
        int
    ] = None,
    authentication_build_attempts: Optional[int] = None,
    authentication_retries: Optional[int] = None,
    data_id: Optional[int] = None,
    freshness_value_id: Optional[int] = None,
    message_link_length: Optional[int] = None,
    message_link_position: Optional[int] = None,
    secondary_freshness_value_id: Optional[int] = None,
    secured_area_length: Optional[int] = None,
    secured_area_offset: Optional[int] = None,
)

The properties of a SecuredIPdu

auth_data_freshness_length `instance-attribute` ¶

auth_data_freshness_length: Optional[int]

length in bits of the authentic PDU data

auth_data_freshness_start_position `instance-attribute` ¶

auth_data_freshness_start_position: Optional[int]

start position in bits of the authentic PDU data

authentication_build_attempts `instance-attribute` ¶

authentication_build_attempts: Optional[int]

number of authentication build attempts

authentication_retries `instance-attribute` ¶

authentication_retries: Optional[int]

number of additional authentication attempts. If this value is zero, the authentication is not repeated

data_id `instance-attribute` ¶

data_id: Optional[int]

numerical identifier of the secured IPdu

freshness_value_id `instance-attribute` ¶

freshness_value_id: Optional[int]

id of the freshness value

message_link_length `instance-attribute` ¶

message_link_length: Optional[int]

message link length in bits

message_link_position `instance-attribute` ¶

message_link_position: Optional[int]

message link start position in bits

secondary_freshness_value_id `instance-attribute` ¶

secondary_freshness_value_id: Optional[int]

seconday freshness value id

secured_area_length `instance-attribute` ¶

secured_area_length: Optional[int]

length in bytes of the secure area inside the payload pdu

secured_area_offset `instance-attribute` ¶

secured_area_offset: Optional[int]

start position in bytes of the secure area inside the payload pdu

SecuredIPdu ¶

SecuredIPdu(element: Element)

Wraps an IPdu to protect it from unauthorized manipulation

contained_ipdu_props `instance-attribute` ¶

contained_ipdu_props: Optional[ContainedIPduProps]

set the ContainedIPduProps for this IPdu This is only needed when the IPdu is contained in a ContainerIPdu

element `instance-attribute` ¶

element: Element

length `instance-attribute` ¶

length: Optional[int]

get or set the length of this PDU

name `instance-attribute` ¶

name: str

payload_pdu_triggering `instance-attribute` ¶

payload_pdu_triggering: Optional[PduTriggering]

get or set the PduTriggering that triggers the payload PDU

When use_as_cryptographic_ipdu is true, this attribute can be used to directly set PduTriggering of the payload PDU. When use_as_cryptographic_ipdu is false, the function set_payload_ipdu should be used to create a new PduTriggering and set it.

secure_communication_props `instance-attribute` ¶

secure_communication_props: Optional[
    SecureCommunicationProps
]

use_as_cryptographic_ipdu `instance-attribute` ¶

use_as_cryptographic_ipdu: Optional[bool]

pdu_triggerings ¶

pdu_triggerings() -> List[PduTriggering]

list all PduTriggerings that trigger this PDU

set_payload_ipdu ¶

set_payload_ipdu(
    pdu: IPdu, physical_channel: PhysicalChannel
) -> PduTriggering

set the payload PduTriggering based on an IPdu

This function should be used when useAsCryptographicIPdu is false or not set. A PduTriggering is created for the Pdu

ServiceInstanceCollectionSet ¶

ServiceInstanceCollectionSet(element: Element)

A ServiceInstanceCollectionSet contains ServiceInstances that are provided or consumed by an ECU

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

create_consumed_service_instance ¶

create_consumed_service_instance(
    name: str,
    service_identifier: int,
    instance_identifier: int,
    major_version: int,
    minor_version: str,
) -> ConsumedServiceInstance

create a new ConsumedServiceInstance in this ServiceInstanceCollectionSet

create_provided_service_instance ¶

create_provided_service_instance(
    name: str,
    service_identifier: int,
    instance_identifier: int,
    major_version: int,
    minor_version: int,
) -> ProvidedServiceInstance

create a new ProvidedServiceInstance in this ServiceInstanceCollectionSet

service_instances ¶

service_instances() -> Iterator[
    Union[ConsumedServiceInstance, ProvidedServiceInstance]
]

create an iterator over all ServiceInstances in this set

SoAdRoutingGroup ¶

SoAdRoutingGroup(element: Element)

A SoAdRoutingGroup is used to link SomeIp settings in Consumed/ProvidedServiceInstances to the SocketConnectionBundles used for transmission. SoAdRoutingGroups are part of the old way of configuring Ethernet communication in AUTOSAR.

control_type `instance-attribute` ¶

control_type: Optional[EventGroupControlType]

get or set the EventGroupControlType of this SoAdRoutingGroup

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

SoConIPduIdentifier ¶

SoConIPduIdentifier(element: Element)

A SoConIPduIdentifier describes a PDU that is transported over a static socket connection.

collection_trigger `instance-attribute` ¶

collection_trigger: Optional[PduCollectionTrigger]

get or set the collection trigger for this SoConIPduIdentifier

element `instance-attribute` ¶

element: Element

header_id `instance-attribute` ¶

header_id: Optional[int]

get or set the header id for this SoConIPduIdentifier

name `instance-attribute` ¶

name: str

pdu_triggering `instance-attribute` ¶

pdu_triggering: Optional[PduTriggering]

get the PduTriggering referenced by this SoConIPduIdentifier

timeout `instance-attribute` ¶

timeout: Optional[float]

set the timeout for this SoConIPduIdentifier

set_pdu ¶

set_pdu(pdu: Pdu, channel: EthernetPhysicalChannel) -> None

create a new PduTriggering for the pdu and reference it in this SoConIPduIdentifier

SocketAddress ¶

SocketAddress(element: Element)

A socket address establishes the link between one or more ECUs and a NetworkEndpoint. It contains all settings that are relevant for this combination.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

network_endpoint `instance-attribute` ¶

network_endpoint: Optional[NetworkEndpoint]

get the network endpoint of this SocketAddress

physical_channel `instance-attribute` ¶

physical_channel: EthernetPhysicalChannel

get the EthernetPhysicalChannel containing this SocketAddress

socket_address_type `instance-attribute` ¶

socket_address_type: Optional[SocketAddressType]

get the socket address type: unicast / multicast, as well as the connected ecus

tp_config `instance-attribute` ¶

tp_config: Optional[TpConfig]

get the transport protocol settings for this SocketAddress

add_multicast_ecu ¶

add_multicast_ecu(ecu: EcuInstance) -> None

add an EcuInstance to this multicast SocketAddress

consumed_service_instances ¶

consumed_service_instances() -> Iterator[
    ConsumedServiceInstanceV1
]

get the ConsumedServiceInstances in this SocketAddress

create_consumed_service_instance ¶

create_consumed_service_instance(
    name: str,
    provided_service_instance: ProvidedServiceInstanceV1,
) -> ConsumedServiceInstanceV1

create a ConsumedServiceInstanceV1 in this SocketAddress

Creating a ConsumedServiceInstanceV1 in a SocketAddress is part of the old way of defining services (<= Autosar 4.5.0). It is obsolete in newer versions of the standard.

When using the new way of defining services, a ConsumedServiceInstance should be created in a ServiceInstanceCollectionSet instead.

create_provided_service_instance ¶

create_provided_service_instance(
    name: str,
    service_identifier: int,
    instance_identifier: int,
) -> ProvidedServiceInstanceV1

create a ProvidedServiceInstanceV1 in this SocketAddress

Creating a ProvidedServiceInstanceV1 in a SocketAddress is part of the old way of defining services (<= Autosar 4.5.0). It is obsolete in newer versions of the standard.

When using the new way of defining services, a ProvidedServiceInstance should be created in a ServiceInstanceCollectionSet instead.

create_static_socket_connection ¶

create_static_socket_connection(
    name: str,
    remote_address: SocketAddress,
    /,
    *,
    tcp_role: Optional[TcpRole] = None,
    tcp_connect_timeout: Optional[float] = None,
) -> StaticSocketConnection

create a new StaticSocketConnection from this SocketAddress to a remote SocketAddress

provided_service_instances ¶

provided_service_instances() -> Iterator[
    ProvidedServiceInstanceV1
]

get the ProvidedServiceInstanceV1s in this SocketAddress

set_unicast_ecu ¶

set_unicast_ecu(ecu: EcuInstance) -> None

set the EcuInstance for this unicast SocketAddress

static_socket_connections ¶

static_socket_connections() -> Iterator[
    StaticSocketConnection
]

iterate over all StaticSocketConnections in this SocketAddress

SocketAddressType ¶

Describes if a [SocketAddress] is used for unicast or multicast

Multicast `instance-attribute` ¶

Multicast: Type[SocketAddressType_Multicast]

Unicast `instance-attribute` ¶

Unicast: Type[SocketAddressType_Unicast]

SocketAddressType_Multicast ¶

SocketAddressType_Multicast(ecus: List[EcuInstance] = [])

Bases: SocketAddressType

ecus `instance-attribute` ¶

ecus: List[EcuInstance]

SocketAddressType_Unicast ¶

SocketAddressType_Unicast(
    ecu: Optional[EcuInstance] = None,
)

Bases: SocketAddressType

ecu `instance-attribute` ¶

ecu: Optional[EcuInstance]

SocketConnection ¶

SocketConnection(element: Element)

A socketConnection inside a SocketConnectionBundle describes a single connection to a specific client port.

client_ip_addr_from_connection_request `instance-attribute` ¶

client_ip_addr_from_connection_request: Optional[bool]

get or set the client_ip_addr_from_connection_request attribute for this socket connection

if the value is Some(true), the attribute is set to "true" if the value is Some(false), the attribute is set to "false" if the value is None, the attribute is removed

client_port `instance-attribute` ¶

client_port: Optional[SocketAddress]

get or set the client port of this socket connection

client_port_from_connection_request `instance-attribute` ¶

client_port_from_connection_request: Optional[bool]

get or set the client_port_from_connection_request attribute for this socket connection

if the value is Some(true), the attribute is set to "true" if the value is Some(false), the attribute is set to "false" if the value is None, the attribute is removed

element `instance-attribute` ¶

element: Element

runtime_ip_address_configuration `instance-attribute` ¶

runtime_ip_address_configuration: bool

get or set the value of the RuntimeIpAddressConfiguration attribute for this socket connection

runtime_port_configuration `instance-attribute` ¶

runtime_port_configuration: bool

get or set the value of the RuntimePortConfiguration attribute for this socket connection

socket_connection_bundle `instance-attribute` ¶

socket_connection_bundle: SocketConnectionBundle

get the socket connection bundle containing this socket connection

create_socket_connection_ipdu_identifier ¶

create_socket_connection_ipdu_identifier(
    pdu: Pdu,
    header_id: int,
    /,
    *,
    timeout: Optional[float] = None,
    collection_trigger: Optional[
        PduCollectionTrigger
    ] = None,
) -> Tuple[SocketConnectionIpduIdentifier, PduTriggering]

add a PDU to the socket connection, returning a PduTriggering

pdu_triggerings ¶

pdu_triggerings() -> Iterator[PduTriggering]

create an iterator over all PDU triggerings in this socket connection

socket_connection_ipdu_identifiers ¶

socket_connection_ipdu_identifiers() -> Iterator[
    SocketConnectionIpduIdentifier
]

create an iterator over all SocketConnectionIpduIdentifiers in this socket connection

SocketConnectionBundle ¶

SocketConnectionBundle(element: Element)

A SocketConnectionBundle describes a connection between a server port and multiple client ports. It contains multiple bundled connections, each transporting one or more PDUs.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

physical_channel `instance-attribute` ¶

physical_channel: EthernetPhysicalChannel

get the physical channel containing this socket connection bundle

server_port `instance-attribute` ¶

server_port: Optional[SocketAddress]

get or set the server port of this socket connection bundle

bundled_connections ¶

bundled_connections() -> Iterator[SocketConnection]

create an iterator over all bundled connections in this socket connection bundle

create_bundled_connection ¶

create_bundled_connection(
    client_port: SocketAddress,
) -> SocketConnection

create a bundled SocketConnection between the server port and a client port

SocketConnectionIpduIdentifier ¶

SocketConnectionIpduIdentifier(element: Element)

A SocketConnectionIpduIdentifier is used to trigger a PDU in a SocketConnection.

In addition to the Pdu Triggering, it also contains associated settings like the header id, timeout and collection trigger.

collection_trigger `instance-attribute` ¶

collection_trigger: Optional[PduCollectionTrigger]

set the collection trigger for this SocketConnectionIpduIdentifier

element `instance-attribute` ¶

element: Element

header_id `instance-attribute` ¶

header_id: Optional[int]

set the header id for this SocketConnectionIpduIdentifier

pdu_triggering `instance-attribute` ¶

pdu_triggering: Optional[PduTriggering]

get the PduTriggering associated with this SocketConnectionIpduIdentifier

socket_connection `instance-attribute` ¶

socket_connection: SocketConnection

get the SocketConnection containing this SocketConnectionIpduIdentifier

timeout `instance-attribute` ¶

timeout: Optional[float]

set the timeout for this SocketConnectionIpduIdentifier

add_routing_group ¶

add_routing_group(routing_group: SoAdRoutingGroup) -> None

add a reference to a SoAdRoutingGroup to this SocketConnectionIpduIdentifier

routing_groups ¶

routing_groups() -> Iterator[SoAdRoutingGroup]

create an iterator over all SoAdRoutingGroups referenced by this SocketConnectionIpduIdentifier

trigger_pdu ¶

trigger_pdu(pdu: Pdu) -> PduTriggering

trigger a PDU in this SocketConnectionIpduIdentifier, creating a PduTriggering

SocketConnectionIpduIdentifierSet ¶

SocketConnectionIpduIdentifierSet(element: Element)

A SocketConnectionIpduIdentifierSet contains a set of SoConIPduIdentifiers, which are used in static socket connections and in SomeIp events.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

create_socon_ipdu_identifier ¶

create_socon_ipdu_identifier(
    name: str,
    pdu: Pdu,
    channel: EthernetPhysicalChannel,
    /,
    *,
    header_id: Optional[int] = None,
    timeout: Optional[float] = None,
    collection_trigger: Optional[
        PduCollectionTrigger
    ] = None,
) -> SoConIPduIdentifier

create a new SoConIPduIdentifier in this set

socon_ipdu_identifiers ¶

socon_ipdu_identifiers() -> Iterator[SoConIPduIdentifier]

create an iterator over all SoConIPduIdentifiers in this set

SomeIpMessageType ¶

message types that can be used in a SOME/IP message header, depending on the type of communication

Notification `instance-attribute` ¶

Notification: SomeIpMessageType

Request `instance-attribute` ¶

Request: SomeIpMessageType

RequestNoReturn `instance-attribute` ¶

RequestNoReturn: SomeIpMessageType

Response `instance-attribute` ¶

Response: SomeIpMessageType

SomeIpTransformationISignalProps ¶

SomeIpTransformationISignalProps(element: Element)

Properties for the SOMEIP transformation of an ISignal(Group)

dynamic_length `instance-attribute` ¶

dynamic_length: Optional[bool]

get or set the dynamic length property

element `instance-attribute` ¶

element: Element

interface_version `instance-attribute` ¶

interface_version: Optional[int]

get or set the interface version property

legacy_strings `instance-attribute` ¶

legacy_strings: Optional[bool]

get or set the legacy strings property

message_type `instance-attribute` ¶

message_type: Optional[SomeIpMessageType]

get or set the message type property

size_of_array_length `instance-attribute` ¶

size_of_array_length: Optional[int]

get or set the size of array length property

size_of_string_length `instance-attribute` ¶

size_of_string_length: Optional[int]

get or set the size of string length property

size_of_struct_length `instance-attribute` ¶

size_of_struct_length: Optional[int]

get or set the size of struct length property

size_of_union_length `instance-attribute` ¶

size_of_union_length: Optional[int]

get or set the size of union length property

transformer `instance-attribute` ¶

transformer: Optional[TransformationTechnology]

get or set the transformer reference of the E2E transformation properties

SomeIpTransformationTechnologyConfig ¶

SomeIpTransformationTechnologyConfig(
    *,
    alignment: int,
    byte_order: ByteOrder,
    interface_version: int,
)

Configuration for a SOMEIP transformation

alignment `instance-attribute` ¶

alignment: int

The alignment of the data in bits

byte_order `instance-attribute` ¶

byte_order: ByteOrder

The byte order of the data

interface_version `instance-attribute` ¶

interface_version: int

The interface version the SOME/IP transformer shall use.

SomeipSdClientEventGroupTimingConfig ¶

SomeipSdClientEventGroupTimingConfig(element: Element)

A SomeipSdClientEventGroupTimingConfig contains the configuration for the timing of a ConsumedEventGroup

This configuration is a named element that is created separately and can be used by multiple ConsumedEventGroups.

Use [ArPackage::create_someip_sd_client_event_group_timing_config] to create a new SomeipSdClientEventGroupTimingConfig.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

subscribe_eventgroup_retry_delay `instance-attribute` ¶

subscribe_eventgroup_retry_delay: Optional[float]

get or set the subscribe eventgroup retry delay of this SomeipSdClientEventGroupTimingConfig

subscribe_eventgroup_retry_max `instance-attribute` ¶

subscribe_eventgroup_retry_max: Optional[int]

get or set subscribe eventgroup retry max of this SomeipSdClientEventGroupTimingConfig

time_to_live `instance-attribute` ¶

time_to_live: Optional[int]

get or set the time to live of this SomeipSdClientEventGroupTimingConfig

request_response_delay ¶

request_response_delay() -> Optional[RequestResponseDelay]

get the request response delay of this SomeipSdClientEventGroupTimingConfig

set_request_response_delay ¶

set_request_response_delay(
    request_response_delay: RequestResponseDelay,
) -> None

set the request response delay of this SomeipSdClientEventGroupTimingConfig

SomeipSdClientServiceInstanceConfig ¶

SomeipSdClientServiceInstanceConfig(element: Element)

A SomeipSdClientServiceInstanceConfig is a configuration for a ConsumedServiceInstance

This configuration is a named element that is created separately and can be used by multiple ConsumedServiceInstances.

Use [ArPackage::create_someip_sd_client_service_instance_config] to create a new SomeipSdClientServiceInstanceConfig.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

priority `instance-attribute` ¶

priority: Optional[int]

get or set the priority of this SomeipSdClientServiceInstanceConfig

Available since R21-11 (AUTOSAR_00050)

initial_find_behavior ¶

initial_find_behavior() -> Optional[InitialSdDelayConfig]

get the initial find behavior of this SomeipSdClientServiceInstanceConfig

set_initial_find_behavior ¶

set_initial_find_behavior(
    initial_find_behavior: InitialSdDelayConfig,
) -> None

set the initial find behavior of this SomeipSdClientServiceInstanceConfig

SomeipSdServerEventGroupTimingConfig ¶

SomeipSdServerEventGroupTimingConfig(element: Element)

A SomeipSdServerEventGroupTimingConfig contains the configuration for the timing of an EventHandler

This configuration is a named element that is created separately and can be used by multiple EventHandlers.

Use [ArPackage::create_someip_sd_server_event_group_timing_config] to create a new SomeipSdServerEventGroupTimingConfig.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

request_response_delay ¶

request_response_delay() -> Optional[RequestResponseDelay]

get the request response delay of this SomeipSdServerEventGroupTimingConfig

set_request_response_delay ¶

set_request_response_delay(
    request_response_Delay: RequestResponseDelay,
) -> None

set the request response delay of this SomeipSdServerEventGroupTimingConfig

SomeipSdServerServiceInstanceConfig ¶

SomeipSdServerServiceInstanceConfig(element: Element)

A SomeipSdServerServiceInstanceConfig is a configuration for a ProvidedServiceInstance

This configuration is a named element that is created separately and can be used by multiple ProvidedServiceInstances.

Use [ArPackage::create_someip_sd_server_service_instance_config] to create a new SomeipSdServerServiceInstanceConfig.

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

offer_cyclic_delay `instance-attribute` ¶

offer_cyclic_delay: Optional[float]

get or set the offer cyclic delay of this SomeipSdServerServiceInstanceConfig

priority `instance-attribute` ¶

priority: Optional[int]

get or set the priority of this SomeipSdServerServiceInstanceConfig

Available since R21-11 (AUTOSAR_00050)

service_offer_time_to_live `instance-attribute` ¶

service_offer_time_to_live: Optional[int]

get or set the service offer time to live of this SomeipSdServerServiceInstanceConfig

initial_offer_behavior ¶

initial_offer_behavior() -> Optional[InitialSdDelayConfig]

get the initial offer behavior of this SomeipSdServerServiceInstanceConfig

request_response_delay ¶

request_response_delay() -> Optional[RequestResponseDelay]

get the request response delay of this SomeipSdServerServiceInstanceConfig

set_initial_offer_behavior ¶

set_initial_offer_behavior(
    initial_offer_behavior: InitialSdDelayConfig,
) -> None

set the initial offer behavior of this SomeipSdServerServiceInstanceConfig

set_request_response_delay ¶

set_request_response_delay(
    request_response_delay: RequestResponseDelay,
) -> None

set the request response delay of this SomeipSdServerServiceInstanceConfig

SomeipTpChannel ¶

SomeipTpChannel(element: Element)

General settings for a SomeIp TP channel

version >= AUTOSAR_00046

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

rx_timeout_time `instance-attribute` ¶

rx_timeout_time: Optional[float]

set the rxTimeoutTime for the SomeIpTpChannel

separation_time `instance-attribute` ¶

separation_time: Optional[float]

set the separationTime for the SomeIpTpChannel

SomeipTpConfig ¶

SomeipTpConfig(element: Element)

A SomipTpConfig contains the configuration of individual SomeIp TP connections

cluster `instance-attribute` ¶

cluster: Optional[
    Union[CanCluster, FlexrayCluster, EthernetCluster]
]

get the communication cluster of this SomeipTpConfig

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

create_someip_tp_channel ¶

create_someip_tp_channel(name: str) -> SomeipTpChannel

create a new SomeipTpChannel in this SomeipTpConfig

version >= AUTOSAR_00046

create_someip_tp_connection ¶

create_someip_tp_connection(
    tp_sdu: ISignalIPdu,
    transport_pdu_triggering: PduTriggering,
    /,
    *,
    tp_channel: Optional[SomeipTpChannel] = None,
) -> SomeipTpConnection

create a new SomeIp TP connection in this SomeipTpConfig

someip_tp_channels ¶

someip_tp_channels() -> Iterator[SomeipTpChannel]

iterate over all SomeipTpChannels in this SomeipTpConfig

someip_tp_connections ¶

someip_tp_connections() -> Iterator[SomeipTpConnection]

get all SomeipTpConnections in this SomeipTpConfig

SomeipTpConnection ¶

SomeipTpConnection(element: Element)

A SomeipTpConnection contains the configuration of a single SomeIp TP connection

element `instance-attribute` ¶

element: Element

someip_tp_config `instance-attribute` ¶

someip_tp_config: SomeipTpConfig

get the SomeipTpConfig that contains this SomeipTpConnection

tp_channel `instance-attribute` ¶

tp_channel: Optional[SomeipTpChannel]

set the TpChannel of this SomeipTpConnection

tp_sdu `instance-attribute` ¶

tp_sdu: Optional[ISignalIPdu]

set the TpSdu of this SomeipTpConnection

transport_pdu_triggering `instance-attribute` ¶

transport_pdu_triggering: Optional[PduTriggering]

get or set the PduTriggering for the transport PDU of this SomeipTpConnection

StaticSocketConnection ¶

StaticSocketConnection(element: Element)

A static socket connection is a connection between two sockets.

This is the new way to establish a connection. It was introduced in Autosar 4.5.0 (AUTOSAR_00048).

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

remote_socket `instance-attribute` ¶

remote_socket: Optional[SocketAddress]

get or set the remote socket of this connection

socket_address `instance-attribute` ¶

socket_address: SocketAddress

get the socket address containing this static socket connection

tcp_connect_timeout `instance-attribute` ¶

tcp_connect_timeout: Optional[float]

get or set the TCP connect timeout of this static socket connection

tcp_role `instance-attribute` ¶

tcp_role: Optional[TcpRole]

get or set the TCP role of this static socket connection

add_ipdu_identifier ¶

add_ipdu_identifier(
    identifier: SoConIPduIdentifier,
) -> None

add a SoConIPduIdentifier to this static socket connection

ipdu_identifiers ¶

ipdu_identifiers() -> Iterator[SoConIPduIdentifier]

create an iterator over all SoConIPduIdentifiers in this static socket connection

SystemSignal ¶

SystemSignal(element: Element)

The system signal represents the communication system's view of data exchanged between SW components which reside on different ECUs

Use [ArPackage::create_system_signal] to create a new system signal

compu_method `instance-attribute` ¶

compu_method: Optional[CompuMethod]

get or set the compu method for this signal

data_constr `instance-attribute` ¶

data_constr: Optional[DataConstr]

get or set the data constraint for this signal

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

signal_group `instance-attribute` ¶

signal_group: Optional[SystemSignalGroup]

get the signal group that contains this signal

unit `instance-attribute` ¶

unit: Optional[Unit]

get or set the unit for this signal

SystemSignalGroup ¶

SystemSignalGroup(element: Element)

A signal group refers to a set of signals that shall always be kept together. A signal group is used to guarantee the atomic transfer of AUTOSAR composite data types.

Use [ArPackage::create_system_signal_group] to create a new system signal group

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

add_signal ¶

add_signal(signal: SystemSignal) -> None

Add a signal to the signal group

signals ¶

signals() -> Iterator[ISignal]

Iterate over all signals in the signal group

TcpRole ¶

The role of a TCP connection in a static socket connection can either be Connect (=client) or Listen (=server).

Connect `instance-attribute` ¶

Connect: TcpRole

Listen `instance-attribute` ¶

Listen: TcpRole

TpAddress ¶

TpAddress(element: Element)

Represents an ECUs transport layer address on the referenced channel

The TpAddress element is used by FlexrayArTpConfig and FlexrayTpConfig

address `instance-attribute` ¶

address: Optional[int]

get or set the value of the address

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

TpConfig ¶

transport protocol settings of a [SocketAddress]

TcpTp `staticmethod` ¶

TcpTp(
    *,
    port_number: Optional[int] = None,
    port_dynamically_assigned: Optional[bool] = None,
) -> TpConfig_TcpTp

UdpTp `staticmethod` ¶

UdpTp(
    *,
    port_number: Optional[int] = None,
    port_dynamically_assigned: Optional[bool] = None,
) -> TpConfig_UdpTp

TpConfig_TcpTp ¶

Bases: TpConfig

port_dynamically_assigned `instance-attribute` ¶

port_dynamically_assigned: Optional[bool]

port_number `instance-attribute` ¶

port_number: Optional[int]

TpConfig_UdpTp ¶

Bases: TpConfig

port_dynamically_assigned `instance-attribute` ¶

port_dynamically_assigned: Optional[bool]

port_number `instance-attribute` ¶

port_number: Optional[int]

TransferProperty ¶

The TransferProperty defines if or how the signal influences the transfer of the PDU

Pending `instance-attribute` ¶

Pending: TransferProperty

Triggered `instance-attribute` ¶

Triggered: TransferProperty

TriggeredOnChange `instance-attribute` ¶

TriggeredOnChange: TransferProperty

TriggeredOnChangeWithoutRepetition `instance-attribute` ¶

TriggeredOnChangeWithoutRepetition: TransferProperty

TriggeredWithoutRepetition `instance-attribute` ¶

TriggeredWithoutRepetition: TransferProperty

TransformationTechnology ¶

TransformationTechnology(element: Element)

A TransformationTechnology describes how to transform signal or PDU data

data_transformation_set `instance-attribute` ¶

data_transformation_set: Optional[DataTransformationSet]

get the DataTransformationSet that contains this TransformationTechnology

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

protocol `instance-attribute` ¶

protocol: Optional[str]

Get the protocol of the TransformationTechnology. It can be set by replacing the whole config

transformer_class `instance-attribute` ¶

transformer_class: Optional[str]

Get the transformer class of the TransformationTechnology

config ¶

config() -> Optional[TransformationTechnologyConfig]

get the configuration of the TransformationTechnology

set_config ¶

set_config(config: TransformationTechnologyConfig) -> None

set the configuration of the TransformationTechnology

TransmissionModeTiming ¶

TransmissionModeTiming(
    *,
    cyclic_timing: Optional[CyclicTiming] = None,
    event_controlled_timing: Optional[
        EventControlledTiming
    ] = None,
)

Cyclic and event controlled timing parameters for an IPDU

cyclic_timing `instance-attribute` ¶

cyclic_timing: Optional[CyclicTiming]

cyclic timing parameters

event_controlled_timing `instance-attribute` ¶

event_controlled_timing: Optional[EventControlledTiming]

event controlled timing parameters

UdpNmCluster ¶

UdpNmCluster(element: Element)

Udp / Ethernet specific NmCluster

channel_sleep_master `instance-attribute` ¶

channel_sleep_master: Optional[bool]

get or set the nmChannelSleepMaster flag

communication_cluster `instance-attribute` ¶

communication_cluster: Optional[EthernetCluster]

set the referenced EthernetCluster

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

nm_cbv_position `instance-attribute` ¶

nm_cbv_position: Optional[int]

get or set the value nmCbvPosition

nm_immediate_nm_transmissions `instance-attribute` ¶

nm_immediate_nm_transmissions: Optional[int]

get or set the value nmImmediateNmTransmissions

nm_message_timeout_time `instance-attribute` ¶

nm_message_timeout_time: Optional[float]

get or set the nmMessageTimeoutTime

nm_msg_cycle_time `instance-attribute` ¶

nm_msg_cycle_time: Optional[float]

get or set the nmMsgCycleTime

nm_network_timeout `instance-attribute` ¶

nm_network_timeout: Optional[float]

get or set the NmNetworkTimeout

nm_nid_position `instance-attribute` ¶

nm_nid_position: Optional[int]

get or set the value nmNidPosition

nm_remote_sleep_indication_time `instance-attribute` ¶

nm_remote_sleep_indication_time: Optional[float]

get or set the NmRemoteSleepIndicationTime

nm_repeat_message_time `instance-attribute` ¶

nm_repeat_message_time: Optional[float]

get or set the NmRepeatMessageTime

nm_wait_bus_sleep_time `instance-attribute` ¶

nm_wait_bus_sleep_time: Optional[float]

get or set the NmWaitBusSleepTime

node_detection_enabled `instance-attribute` ¶

node_detection_enabled: Optional[bool]

get or set the nmNodeDetectionEnabled flag

node_id_enabled `instance-attribute` ¶

node_id_enabled: Optional[bool]

get or set the nmNodeIdEnabled flag

pnc_cluster_vector_length `instance-attribute` ¶

pnc_cluster_vector_length: Optional[int]

get or set the pncClusterVectorLength

pnc_participation `instance-attribute` ¶

pnc_participation: Optional[bool]

get or set the nmPncParticipation flag

repeat_msg_ind_enabled `instance-attribute` ¶

repeat_msg_ind_enabled: Optional[bool]

get or set the nmRepeatMsgIndEnabled flag

synchronizing_network `instance-attribute` ¶

synchronizing_network: Optional[bool]

get or set the nmSynchronizingNetwork flag

vlan `instance-attribute` ¶

vlan: Optional[EthernetPhysicalChannel]

get or set the Vlan associated with the cluster through an EthernetPhysicalChannel reference.

create_udp_nm_node ¶

create_udp_nm_node(
    name: str,
    controller: EthernetCommunicationController,
    nm_ecu: NmEcu,
    nm_msg_cycle_offset: float,
) -> UdpNmNode

add a UdpNmNode to the cluster

nm_nodes ¶

nm_nodes() -> Iterator[UdpNmNode]

iterate over all NmNodes in this cluster

UdpNmClusterCoupling ¶

UdpNmClusterCoupling(element: Element)

Udp / Ethernet specific NmClusterCoupling

It couples multiple UdpNmClusters and provides UdpNm-specific settings

element `instance-attribute` ¶

element: Element

nm_immediate_restart_enabled `instance-attribute` ¶

nm_immediate_restart_enabled: Optional[bool]

set or remove the nmImmediateRestartEnabled flag

add_coupled_cluster ¶

add_coupled_cluster(cluster: UdpNmCluster) -> None

add a reference to a coupled NmCluster

coupled_clusters ¶

coupled_clusters() -> Iterator[UdpNmCluster]

iterate over all coupled NmClusters

UdpNmClusterSettings ¶

UdpNmClusterSettings(
    *,
    nm_msg_cycle_time: float,
    nm_msg_timeout_time: float,
    nm_network_timeout: float,
    nm_remote_sleep_indication_time: float,
    nm_repeat_message_time: float,
    nm_wait_bus_sleep_time: float,
)

UdpNmClusterSettings encapsulates the mandatory settings for a UdpNmCluster

nm_msg_cycle_time `instance-attribute` ¶

nm_msg_cycle_time: float

Period of an NmPdu in seconds

nm_msg_timeout_time `instance-attribute` ¶

nm_msg_timeout_time: float

Timeout of a NmPdu in seconds

nm_network_timeout `instance-attribute` ¶

nm_network_timeout: float

Network Timeout for NmPdus in seconds

nm_remote_sleep_indication_time `instance-attribute` ¶

nm_remote_sleep_indication_time: float

Timeout for Remote Sleep Indication in seconds

nm_repeat_message_time `instance-attribute` ¶

nm_repeat_message_time: float

Timeout for Repeat Message State in seconds

nm_wait_bus_sleep_time `instance-attribute` ¶

nm_wait_bus_sleep_time: float

Timeout for bus calm down phase in seconds

UdpNmNode ¶

UdpNmNode(element: Element)

Udp / Ethernet specific NmNode

all_nm_messages_keep_awake `instance-attribute` ¶

all_nm_messages_keep_awake: Optional[bool]

set ot remove the allNmMessagesKeepAwake flag

If enabled is Some, the flag is set to the value of enabled. If enabled is None, the flag is removed.

communication_controller `instance-attribute` ¶

communication_controller: Optional[
    EthernetCommunicationController
]

get or set the referenced EthernetCommunicationController

element `instance-attribute` ¶

element: Element

name `instance-attribute` ¶

name: str

nm_ecu `instance-attribute` ¶

nm_ecu: Optional[NmEcu]

get or set the referenced NmEcu

nm_msg_cycle_offset `instance-attribute` ¶

nm_msg_cycle_offset: Optional[float]

get or set the NmMsgCycleOffset

node_id `instance-attribute` ¶

node_id: Optional[int]

set the nmNodeId

passive_mode `instance-attribute` ¶

passive_mode: Optional[bool]

set ot remove the nmPassiveModeEnabled flag

add_rx_nm_pdu ¶

add_rx_nm_pdu(nm_pdu: NmPdu) -> None

add an Rx NmPdu

Every NmNode must have at least one Rx NmPdu

add_tx_nm_pdu ¶

add_tx_nm_pdu(nm_pdu: NmPdu) -> None

add a Tx NmPdu

Active NmNodes must have at least one Tx NmPdu, while passive NmNodes may have none.

rx_nm_pdus ¶

rx_nm_pdus() -> Iterator[NmPdu]

iterate over all RX NmPdus

tx_nm_pdus ¶

tx_nm_pdus() -> Iterator[NmPdu]

iterate over all TX NmPdus

API Documentation: autosar_data.abstraction.communication¶

communication ¶

Cluster module-attribute ¶

CommunicationController module-attribute ¶

Frame module-attribute ¶

IPdu module-attribute ¶

Pdu module-attribute ¶

PhysicalChannel module-attribute ¶

TransformationTechnologyConfig module-attribute ¶

CanAddressingMode ¶

Extended instance-attribute ¶

Standard instance-attribute ¶

CanCluster ¶

baudrate instance-attribute ¶

can_fd_baudrate instance-attribute ¶

can_xl_baudrate instance-attribute ¶

element instance-attribute ¶

name instance-attribute ¶

physical_channel instance-attribute ¶

system instance-attribute ¶

create_physical_channel ¶

CanCommunicationConnector ¶

controller instance-attribute ¶

ecu_instance instance-attribute ¶

element instance-attribute ¶

name instance-attribute ¶

CanCommunicationController ¶

ecu_instance instance-attribute ¶

element instance-attribute ¶

name instance-attribute ¶

connect_physical_channel ¶

connected_channels ¶

CanFrame ¶

element instance-attribute ¶

length instance-attribute ¶

name instance-attribute ¶

frame_triggerings ¶

map_pdu ¶

mapped_pdus ¶

CanFrameTriggering ¶

addressing_mode instance-attribute ¶

element instance-attribute ¶

frame instance-attribute ¶

frame_type instance-attribute ¶

identifier instance-attribute ¶

name instance-attribute ¶

physical_channel instance-attribute ¶

connect_to_ecu ¶

frame_ports ¶

pdu_triggerings ¶

CanFrameType ¶

Any instance-attribute ¶

Can20 instance-attribute ¶

CanFd instance-attribute ¶

CanNmCluster ¶

channel_sleep_master instance-attribute ¶

communication_cluster instance-attribute ¶

element instance-attribute ¶

name instance-attribute ¶

nm_busload_reduction_active instance-attribute ¶

nm_immediate_nm_transmissions instance-attribute ¶

nm_message_timeout_time instance-attribute ¶

nm_msg_cycle_time instance-attribute ¶

nm_network_timeout instance-attribute ¶

nm_remote_sleep_indication_time instance-attribute ¶

nm_repeat_message_time instance-attribute ¶

nm_wait_bus_sleep_time instance-attribute ¶

node_detection_enabled instance-attribute ¶

node_id_enabled instance-attribute ¶

pnc_cluster_vector_length instance-attribute ¶

pnc_participation instance-attribute ¶

repeat_msg_ind_enabled instance-attribute ¶

synchronizing_network instance-attribute ¶

create_can_nm_node ¶

nm_nodes ¶

CanNmClusterCoupling ¶

element instance-attribute ¶

nm_busload_reduction_enabled instance-attribute ¶

nm_immediate_restart_enabled instance-attribute ¶

add_coupled_cluster ¶

Cluster `module-attribute` ¶

CommunicationController `module-attribute` ¶

Frame `module-attribute` ¶

IPdu `module-attribute` ¶

Pdu `module-attribute` ¶

PhysicalChannel `module-attribute` ¶

TransformationTechnologyConfig `module-attribute` ¶

Extended `instance-attribute` ¶

Standard `instance-attribute` ¶

baudrate `instance-attribute` ¶

can_fd_baudrate `instance-attribute` ¶

can_xl_baudrate `instance-attribute` ¶

element `instance-attribute` ¶

name `instance-attribute` ¶

physical_channel `instance-attribute` ¶

system `instance-attribute` ¶

controller `instance-attribute` ¶

ecu_instance `instance-attribute` ¶

element `instance-attribute` ¶

name `instance-attribute` ¶

ecu_instance `instance-attribute` ¶

element `instance-attribute` ¶

name `instance-attribute` ¶

element `instance-attribute` ¶

length `instance-attribute` ¶

name `instance-attribute` ¶

addressing_mode `instance-attribute` ¶

element `instance-attribute` ¶

frame `instance-attribute` ¶

frame_type `instance-attribute` ¶

identifier `instance-attribute` ¶

name `instance-attribute` ¶

physical_channel `instance-attribute` ¶

Any `instance-attribute` ¶

Can20 `instance-attribute` ¶

CanFd `instance-attribute` ¶

channel_sleep_master `instance-attribute` ¶

communication_cluster `instance-attribute` ¶

element `instance-attribute` ¶

name `instance-attribute` ¶

nm_busload_reduction_active `instance-attribute` ¶

nm_immediate_nm_transmissions `instance-attribute` ¶

nm_message_timeout_time `instance-attribute` ¶

nm_msg_cycle_time `instance-attribute` ¶

nm_network_timeout `instance-attribute` ¶

nm_remote_sleep_indication_time `instance-attribute` ¶

nm_repeat_message_time `instance-attribute` ¶

nm_wait_bus_sleep_time `instance-attribute` ¶

node_detection_enabled `instance-attribute` ¶

node_id_enabled `instance-attribute` ¶

pnc_cluster_vector_length `instance-attribute` ¶

pnc_participation `instance-attribute` ¶

repeat_msg_ind_enabled `instance-attribute` ¶

synchronizing_network `instance-attribute` ¶

element `instance-attribute` ¶

nm_busload_reduction_enabled `instance-attribute` ¶

nm_immediate_restart_enabled `instance-attribute` ¶

nm_busload_reduction_active `instance-attribute` ¶

nm_immediate_nm_transmissions `instance-attribute` ¶

nm_message_timeout_time `instance-attribute` ¶

nm_msg_cycle_time `instance-attribute` ¶

nm_network_timeout `instance-attribute` ¶

nm_remote_sleep_indication_time `instance-attribute` ¶

nm_repeat_message_time `instance-attribute` ¶

nm_wait_bus_sleep_time `instance-attribute` ¶

communication_controller `instance-attribute` ¶

element `instance-attribute` ¶

name `instance-attribute` ¶

nm_ecu `instance-attribute` ¶

node_id `instance-attribute` ¶

passive_mode `instance-attribute` ¶

cluster `instance-attribute` ¶

element `instance-attribute` ¶

name `instance-attribute` ¶

element `instance-attribute` ¶

name `instance-attribute` ¶

tp_address `instance-attribute` ¶

Extended `instance-attribute` ¶

Mixed `instance-attribute` ¶

Mixed29Bit `instance-attribute` ¶