AUTOSAR Classic Communication Services
Die Communication Services bilden das nachrichten- und signalbasierte Rückgrat der BSW: Signalextraktion, PDU-Routing ohne Payload-Inspektion (PduR) und ECU-weites Kommunikations- und Kanalmanagement (ComM).
Inicialização e estado
Com_DeInitCom_GetStatusCom_GetVersionInfoCom_InitComM_DeInitComM_GetStatusComM_GetVersionInfoComM_InitComXf_DeInitComXf_GetVersionInfoComXf_InitE2EXf_DeInitE2EXf_GetVersionInfoE2EXf_InitIpduM_GetVersionInfoIpduM_InitLdCom_DeInitLdCom_GetVersionInfoLdCom_InitMip_DeInitMip_GetVersionInfoMip_InitMirror_DeInitMirror_GetVersionInfoMirror_InitNm_GetVersionInfoNm_InitPduR_GetVersionInfoPduR_InitSomeIpXf_DeInitSomeIpXf_GetVersionInfoSomeIpXf_InitXcp_GetVersionInfoXcp_InitServiços · Get…
Serviços · Inv…
Serviços · transformer…
Serviços · Nm…
Serviços · Receive…
Serviços · Send…
Serviços · Add…
Serviços · Ld…
Serviços · Network…
Serviços · Report…
Serviços · Set…
Serviços · Bus…
Serviços · Disable…
Serviços · Enable…
Serviços · Return…
Serviços · Update…
Serviços · Outros
Com_InvalidateSignalCom_InvalidateSignalGroupCom_IpduGroupStartCom_IpduGroupStopCom_SwitchIpduTxModeCom_TriggerIPDUSendCom_TriggerIPDUSendWithMetaDataComM_CommunicationAllowedComM_DCM_ActiveDiagnosticComM_DCM_InactiveDiagnosticComM_EcuM_PNCWakeUpIndicationComM_EcuM_WakeUpIndicationComM_LimitChannelToNoComModeComM_LimitECUToNoComModeComM_PnLearningRequestComM_PreventWakeUpComM_ReadInhibitCounterComM_RequestComModeComM_ResetInhibitCounterComM_ResetPncToChannelMappingIpduM_TransmitLdCom_TransmitMip_ExtractProtocolHeaderFieldsMirror_IsMirrorActiveMirror_IsSourceNetworkStartedMirror_OfflineMirror_RemoveFilterMirror_StartSourceNetworkMirror_StopSourceNetworkMirror_SwitchDestNetworkNm_CarWakeUpIndicationNm_CheckRemoteSleepIndicationNm_CoordReadyToSleepCancellationNm_CoordReadyToSleepIndicationNm_ForwardSynchronizedPncShutdownNm_ForwardSynchronizedPncShutdown#2Nm_PassiveStartUpNm_PncBitVectorTxIndicationNm_PnLearningRequestNm_PrepareBusSleepModeNm_RemoteSleepCancellationNm_RemoteSleepIndicationNm_RepeatMessageIndicationNm_RepeatMessageRequestNm_RequestSynchronizedPncShutdownNm_StateChangeNotificationNm_SynchronizationPointNm_SynchronizeModeNm_TxTimeoutExceptionSomeIpXf_ExtractProtocolHeaderFieldsXcp_LoTriggerTransmitCallbacks
Com_CbkCounterErrCom_CbkInvCom_CbkRxAckCom_CbkRxTOutCom_CbkTxAckCom_CbkTxErrCom_CbkTxPrepCom_CbkTxTOutCom_CopyRxDataCom_CopyTxDataCom_RxIndicationCom_StartOfReceptionCom_TpRxIndicationCom_TpTxConfirmationCom_TriggerTransmitCom_TxConfirmationIpduM_RxIndicationIpduM_TriggerTransmitIpduM_TxConfirmationLdCom_CopyRxDataLdCom_CopyTxDataLdCom_RxIndicationLdCom_StartOfReceptionLdCom_TpRxIndicationLdCom_TpTxConfirmationLdCom_TriggerTransmitLdCom_TxConfirmationMirror_TriggerTransmitMirror_TxConfirmationNm_PduRxIndicationNm_PncBitVectorRxIndicationNm_PncBitVectorTxConfirmationXcp_LoRxIndicationXcp_LoTxConfirmationCallouts e interfaces esperadas
<LdComUser_LdComCbkCopyRxData><LdComUser_LdComCbkCopyTxData><LdComUser_LdComCbkRxIndication><LdComUser_LdComCbkStartOfReception><LdComUser_LdComCbkTpRxIndication><LdComUser_LdComCbkTpTxConfirmation><LdComUser_LdComCbkTriggerTransmit><LdComUser_LdComCbkTxConfirmation><NmCarWakeUpCallout>Com_RxIpduCalloutCom_TxIpduCalloutCíclico
Com_MainFunctionRouteSignalsCom_MainFunctionRxCom_MainFunctionTxIpduM_MainFunctionRxIpduM_MainFunctionTxMirror_MainFunctionNm_MainFunctionXcp_MainFunctionTipos
Com_ConfigTypeCom_IpduGroupIdTypeCom_SignalGroupIdTypeCom_SignalIdTypeCom_StatusTypeComM_ConfigTypeComM_InitStatusTypeComM_ModeTypeComM_PncMembershipTypeComM_PncModeTypeComM_StateTypeComM_UserHandleArrayTypeComM_UserHandleSubArrayTypeComM_UserHandleTypeComMModeComXf_ConfigTypeE2EXf_ConfigTypeE2EXf_CSTransactionHandleTypeIpduM_ConfigTypeLdCom_ConfigTypeMirror_CanIdTypeMirror_ConfigTypeMirror_FlexRayChannelTypeMirror_NetworkTypemodeLimitationNm_BusNmTypeNm_ConfigTypeNm_ModeTypeNm_StateTypePduR_PBConfigIdTypePduR_PBConfigTypePduR_RoutingPathGroupIdTypePduR_StateTypeSomeIpXf_ConfigTypeXcp_ConfigTypeXcp_TransmissionModeType{Mip}_ConfigTypeFunções
<LdComUser_LdComCbkCopyRxData><LdComUser_LdComCbkCopyTxData><LdComUser_LdComCbkRxIndication><LdComUser_LdComCbkStartOfReception><LdComUser_LdComCbkTpRxIndication><LdComUser_LdComCbkTpTxConfirmation><LdComUser_LdComCbkTriggerTransmit><LdComUser_LdComCbkTxConfirmation><NmCarWakeUpCallout>Com_CbkCounterErrCom_CbkInvCom_CbkRxAckCom_CbkRxTOutCom_CbkTxAckCom_CbkTxErrCom_CbkTxPrepCom_CbkTxTOutCom_CopyRxDataCom_CopyTxDataCom_DeInitCom_DisableReceptionDMCom_EnableReceptionDMCom_GetStatusCom_GetVersionInfoCom_InitCom_InvalidateSignalCom_InvalidateSignalGroupCom_IpduGroupStartCom_IpduGroupStopCom_MainFunctionRouteSignalsCom_MainFunctionRxCom_MainFunctionTxCom_ReceiveDynSignalCom_ReceiveDynSignalWithMetaDataCom_ReceiveSignalCom_ReceiveSignalGroupCom_ReceiveSignalGroupArrayCom_ReceiveSignalGroupArrayWithMetaDataCom_ReceiveSignalGroupWithMetaDataCom_ReceiveSignalWithMetaDataCom_RxIndicationCom_RxIpduCalloutCom_SendDynSignalCom_SendDynSignalWithMetaDataCom_SendSignalCom_SendSignalGroupCom_SendSignalGroupArrayCom_SendSignalGroupArrayWithMetaDataCom_SendSignalGroupWithMetaDataCom_SendSignalWithMetaDataCom_StartOfReceptionCom_SwitchIpduTxModeCom_TpRxIndicationCom_TpTxConfirmationCom_TriggerIPDUSendCom_TriggerIPDUSendWithMetaDataCom_TriggerTransmitCom_TxConfirmationCom_TxIpduCalloutComM_BusSM_BusSleepModeComM_BusSM_ModeIndicationComM_CommunicationAllowedComM_DCM_ActiveDiagnosticComM_DCM_InactiveDiagnosticComM_DeInitComM_EcuM_PNCWakeUpIndicationComM_EcuM_WakeUpIndicationComM_GetCurrentComModeComM_GetCurrentPNCComModeComM_GetInhibitionStatusComM_GetMaxComModeComM_GetPncToChannelMappingComM_GetRequestedComModeComM_GetStatusComM_GetVersionInfoComM_InitComM_LimitChannelToNoComModeComM_LimitECUToNoComModeComM_Nm_BusSleepModeComM_Nm_ForwardSynchronizedPncShutdownComM_Nm_NetworkModeComM_Nm_NetworkStartIndicationComM_Nm_PncLearningBitIndicationComM_Nm_PrepareBusSleepModeComM_Nm_RepeatMessageLeftIndicationComM_Nm_RestartIndicationComM_PnLearningRequestComM_PreventWakeUpComM_ReadInhibitCounterComM_RequestComModeComM_ResetInhibitCounterComM_ResetPncToChannelMappingComM_SetECUGroupClassificationComM_UpdatePncMembershipComM_UpdatePncToChannelMappingComXf_DeInitComXf_GetVersionInfoComXf_InitComXf_Inv_transformerIdComXf_transformerIdE2EXf_DeInitE2EXf_GetVersionInfoE2EXf_InitE2EXf_Inv_transformerIdE2EXf_transformerIdIpduM_GetVersionInfoIpduM_InitIpduM_MainFunctionRxIpduM_MainFunctionTxIpduM_RxIndicationIpduM_TransmitIpduM_TriggerTransmitIpduM_TxConfirmationLdCom_CopyRxDataLdCom_CopyTxDataLdCom_DeInitLdCom_GetVersionInfoLdCom_InitLdCom_RxIndicationLdCom_StartOfReceptionLdCom_TpRxIndicationLdCom_TpTxConfirmationLdCom_TransmitLdCom_TriggerTransmitLdCom_TxConfirmationMip_DeInitMip_ExtractProtocolHeaderFieldsMip_GetVersionInfoMip_InitMip_Inv_transformerIdMip_Inv_transformerId#2Mip_Inv_transformerId#3Mip_Inv_transformerId#4Mip_transformerIdMip_transformerId#2Mip_transformerId#3Mip_transformerId#4Mirror_AddCanMaskFilterMirror_AddCanRangeFilterMirror_AddFlexRayFilterMirror_AddLinMaskFilterMirror_AddLinRangeFilterMirror_DeInitMirror_GetDestNetworkMirror_GetNetworkHandleMirror_GetNetworkIdMirror_GetNetworkTypeMirror_GetStaticFilterStateMirror_GetVersionInfoMirror_InitMirror_IsMirrorActiveMirror_IsSourceNetworkStartedMirror_MainFunctionMirror_OfflineMirror_RemoveFilterMirror_ReportCanFrameMirror_ReportFlexRayChannelStatusMirror_ReportFlexRayFrameMirror_ReportLinFrameMirror_SetStaticFilterStateMirror_StartSourceNetworkMirror_StopSourceNetworkMirror_SwitchDestNetworkMirror_TriggerTransmitMirror_TxConfirmationNm_BusSleepModeNm_CarWakeUpIndicationNm_CheckRemoteSleepIndicationNm_CoordReadyToSleepCancellationNm_CoordReadyToSleepIndicationNm_DisableCommunicationNm_EnableCommunicationNm_ForwardSynchronizedPncShutdownNm_ForwardSynchronizedPncShutdown#2Nm_GetLocalNodeIdentifierNm_GetNodeIdentifierNm_GetPduDataNm_GetStateNm_GetUserDataNm_GetVersionInfoNm_InitNm_MainFunctionNm_NetworkModeNm_NetworkReleaseNm_NetworkRequestNm_NetworkStartIndicationNm_PassiveStartUpNm_PduRxIndicationNm_PncBitVectorRxIndicationNm_PncBitVectorTxConfirmationNm_PncBitVectorTxIndicationNm_PnLearningRequestNm_PrepareBusSleepModeNm_RemoteSleepCancellationNm_RemoteSleepIndicationNm_RepeatMessageIndicationNm_RepeatMessageRequestNm_RequestSynchronizedPncShutdownNm_SetUserDataNm_StateChangeNotificationNm_SynchronizationPointNm_SynchronizeModeNm_TxTimeoutExceptionNm_UpdateIRAPduR_DisableRoutingPduR_EnableRoutingPduR_GetConfigurationIdPduR_GetVersionInfoPduR_InitReq_ReturnTypeRte_LdComCbkCopyRxData_snReq_ReturnTypeRte_LdComCbkCopyTxData_snReq_ReturnTypeRte_LdComCbkStartOfReception_snRte_LdComCbkRxIndication_snRte_LdComCbkTpRxIndication_snRte_LdComCbkTpTxConfirmation_snRte_LdComCbkTriggerTransmit_snRte_LdComCbkTxConfirmation_snSomeIpXf_DeInitSomeIpXf_ExtractProtocolHeaderFieldsSomeIpXf_GetVersionInfoSomeIpXf_InitSomeIpXf_Inv_transformerIdSomeIpXf_Inv_transformerId#2SomeIpXf_Inv_transformerId#3SomeIpXf_transformerIdSomeIpXf_transformerId#2SomeIpXf_transformerId#3Xcp_GetVersionInfoXcp_InitXcp_LoRxIndicationXcp_LoTriggerTransmitXcp_LoTxConfirmationXcp_MainFunctionXcp_SetTransmissionModeTipos
Com_ConfigTypeCom_IpduGroupIdTypeCom_SignalGroupIdTypeCom_SignalIdTypeCom_StatusTypeComM_ConfigTypeComM_InitStatusTypeComM_ModeTypeComM_PncMembershipTypeComM_PncModeTypeComM_StateTypeComM_UserHandleArrayTypeComM_UserHandleSubArrayTypeComM_UserHandleTypeComMModeComXf_ConfigTypeE2EXf_ConfigTypeE2EXf_CSTransactionHandleTypeIpduM_ConfigTypeLdCom_ConfigTypeMirror_CanIdTypeMirror_ConfigTypeMirror_FlexRayChannelTypeMirror_NetworkTypemodeLimitationNm_BusNmTypeNm_ConfigTypeNm_ModeTypeNm_StateTypePduR_PBConfigIdTypePduR_PBConfigTypePduR_RoutingPathGroupIdTypePduR_StateTypeSomeIpXf_ConfigTypeXcp_ConfigTypeXcp_TransmissionModeType{Mip}_ConfigTypeMapa de temas
Com
55ComM
47LdCom
29Mirror
32Nm
44PduR
9SomeIpXf
11Xcp
9Não há dados de elementos para esta versão
Com
This callback function corresponds to SWS_ Com_00680. It is called after recepti- on of an invalid signal or signal group respectively.
void Com_CbkInv (void);This callback represents notification class 1 of [17]. It is called immediately after the message has been stored in the receiving message object.
void Com_CbkRxAck (void);This callback corresponds to notification class 3 of [17]. It is called immediately after a message reception error has been detected by the deadline monitoring mechanism.
void Com_CbkRxTOut (void);This callback represents notification class 2 of [17]. It is called immediately after successful transmission of the I - PDU containing the message.
void Com_CbkTxAck (void);This callback corresponds to notification class 4 of [17]. It is called in case the transmission is not possible because the corresponding I - PDU group is stopped.
void Com_CbkTxErr (void);This callback function indicates that the signals/ signal groups of a dedicated Com_ Main Function Tx instance will now be prepared for transmission.
void Com_CbkTxPrep (void);This callback corresponds to notification class 4 of [17]. It is called immediately after a message transmission error has been detected by the deadline monitoring mechanism.
void Com_CbkTxTOut (void);Service Com_CopyRxData.
BufReq_ReturnType Com_CopyRxData (PduIdType id, const PduInfoType* info, PduLengthType* bufferSizePtr);Service Com_CopyTxData.
BufReq_ReturnType Com_CopyTxData (PduIdType id, const PduInfoType* info, const RetryInfoType* retry, PduLengthType* availableDataPtr);This service stops the inter - ECU communication. All started I - PDU groups are stop- ped and have to be started again, if needed, after Com_ Init is called. By a call to Com_ De Init the AUTOSAR COM module is put into an not initialized state.
void Com_DeInit (void);Disables the reception deadline monitoring for the I - PDUs within the given I - PDU group.
void Com_DisableReceptionDM (Com_IpduGroupIdType IpduGroupId);Enables the reception deadline monitoring for the I - PDUs within the given I - PDU group.
void Com_EnableReceptionDM (Com_IpduGroupIdType IpduGroupId);Returns the status of the AUTOSAR COM module. Availab le via Com.h
Com_StatusType Com_GetStatus (void);Returns the version information of this module.
void Com_GetVersionInfo (Std_VersionInfoType* versioninfo);This service initializes internal and external interfaces and variables of the AUTO- SAR COM module layer for the further processing. After calling this function the inter - ECU communication is still disabled. In configurations, in which Com is assigned to mo re than one partition (i.e. Com_ Main Functions are mapped to partitions), Com may provide one init function per AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_COM partition.
void Com_Init (const Com_ConfigType* config);The service Com_ In validate Signal invalidates the signal with the given Signal Id by setting its value to its configured Com Signal Data Invalid Value.
uint8 Com_InvalidateSignal (Com_SignalIdType SignalId);The service Co m_ Invalidate Signal Group invalidates all group signals of the signal group with the given Signal Group Id by setting their values to their configured Com Signal Data Invalid Values.
uint8 Com_InvalidateSignalGroup (Com_SignalGroupIdType SignalGroupId);Starts a preconfigured I - PDU group. For example, cyclic I - PDUs will be sent out cyclically after the call of Com_ Ipdu Group Start(). If Initialize is true all I - PDUs of the I - PDU group shall be (r e - )initialized before the I - PDU group is started. That is they shall behave like after a start - up of COM, for example the old_ value of the filter ob- jects and shadow buffers of signal groups have to be (re - )initialized.
void Com_IpduGroupStart (Com_IpduGroupIdType IpduGroupId, boolean initialize);Stops a preconfigured I - PDU group. For example, cyclic I - PDUs will be stopped after the call of Com_ Ipdu Group Stop().
void Com_IpduGroupStop (Com_IpduGroupIdType IpduGroupId);Calls the signal gateway part of the AUTOSAR COM module to forward received signals to be routed. Per configured Com Main Function Route Signals instance one Com_ Main Functi on Route Signals_ shall be implemented. Hereby is the short name of the Com Main Function Route Signals configuration container in the ECU configuration.
void Com_MainFunctionRouteSignals (void);This function performs the processing of the AUTOSAR COM module's receive processing that are not directly handled within the COM's functions invoked by the PDU - R, for example Com_ Rx Indication. Per configured Com Main Function Rx instance one Com_ Main F unction Rx_ shall be implemented. Hereby is the short name of the Com Main Function Rx configuration container in the ECU configuration.
void Com_MainFunctionRx (void);This function performs the processing of the AUTOSAR COM module's transmissi- on activities that are not directly handled within the COM's function invoked by the AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_COM RTE, for example Com_ Send Signal. Per configured Com Main Function Tx instance one Com_ Main F unction Tx_ shall be implemented. Hereby is the short name of the Com Main Function Tx configuration container in the ECU configuration.
void Com_MainFunctionTx (void);Com_ Receive Dyn Signal copies the data of the signal identified by Signal Id to the lo cation specified by Signal Data Ptr and stores the length of the dynamical length signal at the position given by the Length parameter.
uint8 Com_ReceiveDynSignal (Com_SignalIdType SignalId, void* SignalDataPtr, uint16* Length);Com_ Receive Dyn Signal With Meta Da ta copies the data of the signal identified by Signal Id to the location specified by Signal Data Ptr and stores the length of the dy- namical length signal at the position given by the Length parameter. The received meta data is stored at the position given by the Meta Data Ptr parameter.
uint8 Com_ReceiveDynSignalWithMetaData (Com_SignalIdType SignalId, void* SignalDataPtr, uint16* Length, uint8* MetaDataPtr);Com_ Receive Signal copies the data of the signal identified by Signal Id to the location specified by Signal Data Ptr.
uint8 Com_ReceiveSignal (Com_SignalIdType SignalId, void* SignalDataPtr);The service Com_ Receive Signal Group copies the received signal group from the I - PDU to the shadow buffer.
uint8 Com_ReceiveSignalGroup (Com_SignalGroupIdType SignalGroupId);The service Com_ Receive Signal Group Array copies the re ceived signal group array AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_COM representation from the PDU to the location designated by Signal Group Ar - ray Ptr.
The service Com_ Receive Signal Group Array With Meta Data copies the received si gnal group array representation from the PDU to the location designated by Signal Group Ar - ray Ptr. The received meta data is stored at the position given by the Meta Data Ptr parameter.
The service Com_ Receive Signal Group With Meta Data copies the received signal group from the I - PDU to the shadow buffer. The received meta data is stored at the position given by the Meta Data Ptr parameter.
Com_ Receive Signal With Meta Data copies the data of the signal identified by Signal Id to the location specified by Signal Data Ptr. The received meta data is stored at the position given by the Meta Data Ptr parameter. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_COM
uint8 Com_ReceiveSignalWithMetaData (Com_SignalIdType SignalId, void* SignalDataPtr, uint8* MetaDataPtr);Indication of a received PDU from a lower layer communication interface module.
void Com_RxIndication (PduIdType RxPduId, const PduInfoType* PduInfoPtr);The I - PDU callout on receiver side can be configured to implement user - defined receive filtering mechanisms.
boolean Com_RxIpduCallout (PduIdType PduId, const PduInfoType* PduInfoPtr);The service Com_ Send Dyn Signal updates the signal object identified by Signal Id with the signal referenced by the Signal Data Ptr parameter.
uint8 Com_SendDynSignal (Com_SignalIdType SignalId, const void* SignalDataPtr, uint16 Length);The service Com_ Send Dyn Signal With Meta Data updates the signal object identified by Signal Id wit h the signal referenced by the Signal Data Ptr parameter. The meta data is provided via the Meta Data Ptr parameter. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_COM
uint8 Com_SendDynSignalWithMetaData (Com_SignalIdType SignalId, void* SignalDataPtr, uint16 Length, uint8* MetaDataPtr);The service Com_ Send Signal updates the signal object identified by Signal Id with the signal referenced by the Signal Data Ptr parameter. Avai lable via Com.h
uint8 Com_SendSignal (Com_SignalIdType SignalId, const void* SignalDataPtr);The service Com_ Send Si gnal Group copies the content of the associated shadow buffer to the associated I - PDU.
uint8 Com_SendSignalGroup (Com_SignalGroupIdType SignalGroupId);The service Com_ Send Signal Group Array copies the conte nt of the provided Signal Group Array Ptr to the associated I - PDU. The provided data shall correspond to the array representation of the signal group.
The service Com_ Send Signal Group Array With Meta Data copies the content of the provided Signal Group Array Ptr to the associated I - PDU. The provided data shall c orrespond to the array representation of the signal group. The meta data is provi- ded via the Meta Data Ptr parameter.
The service Com_ Send Si gnal With Meta Data updates the signal object identified by Signal Id with the signal referenced by the Signal Data Ptr parameter. The meta data is provided via the Meta Data Ptr parameter.
uint8 Com_SendSignalWithMetaData (Com_SignalIdType SignalId, void* SignalDataPtr, uint8* MetaDataPtr);Service Com_StartReception.
BufReq_ReturnType Com_StartOfReception (PduIdType id, const PduInfoType* info, PduLengthType TpSduLength, PduLengthType* bufferSizePtr);The service Com_ Switch Ipdu Tx Mode sets the transmi ssion mode of the I - PDU refe- renced by Pdu Id to Mode. In case the transmission mode changes, the new mode shall immediately be effective (see SWS_ Com_00239). In case the requested transmission mode was already active for this I - PDU, the call will have no effect.
void Com_SwitchIpduTxMode (PduIdType PduId, booleanMode); ⚠️Called after an I - PDU has been received via the TP API, the result indicates whe- ther the transmission was successful or not.
void Com_TpRxIndication (PduIdType id, Std_ReturnType result);This function is called after the I - PDU has been transmitted on its network, the result indicates whether the transmission was successful or not.
void Com_TpTxConfirmation (PduIdType id, Std_ReturnType result);By a call to Com_ Trigger IPDUSend the I - PDU with the given ID is triggered for transmission.
Std_ReturnType Com_TriggerIPDUSend (PduIdType PduId);By a call to Com_ Trigger IPDUSend With Meta Data the AUTOSAR COM module updates its internal metadata for the I - PDU with the given ID by copying the metada- ta from the given position and with respect to length of the globally configured Meta Data Type of this I - PDU. Then the I - PDU is triggered for transmission.
Std_ReturnType Com_TriggerIPDUSendWithMetaData (PduIdType PduId, const uint8* MetaData);Within this API , the upper layer module (called module) shall check whether the available data fits into the buffer size reported by Pdu Info Ptr - >Sdu Length. If it fits, it shall copy its data into the buffer provided by Pdu Info Ptr - >Sdu Data Ptr and update the length of the actual copied data in Pdu Info Ptr - >Sdu Length. If not, it returns E_ NOT_ OK without changing Pdu Info Ptr.
Std_ReturnType Com_TriggerTransmit (PduIdType TxPduId, PduInfoType* PduInfoPtr);The lower layer communication interface module confirms the transmission of a AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_COM PDU, or the failure to transmit a PDU.
void Com_TxConfirmation (PduIdType TxPduId, Std_ReturnType result);The I - PDU callout on sender side can be configured for example to implement user - defined transmission filtering or user - defined pre - transmission - processing of the outgoing I - PDU.
boolean Com_TxIpduCallout (PduIdType PduId, PduInfoType* PduInfoPtr);This is the type of the data structure containing the initialization data for COM.
The AUTOSAR COM I - PDU module's group object identifier.
The AUTOSAR COM module's signal group object identifier.
The AUTOSAR COM module's signal object identifier.
This is a status value returned by the API service Com_ Get Status().
ComM
Notification of the corresponding Bus State Manager that the actual bus mode is Bus - Sleep. Only applicable for Com M channels with Com MNm Variant set to SLAVE_ ACTIVE or SLAVE_ PASSIVE. E.g. LIN slaves (Com MNMVariant = SLAVE_ ACTIVE) or Ethernet channels with OA TC10 compliant Ethernet hardware which act as passive communication slave (Com MNMVariant = SLAVE_ PASSIVE and Eth Trcv Act As Slave Passive Enabled set to TRUE)
void ComM_BusSM_BusSleepMode (NetworkHandleType Channel);Indication of the actual bus mode by the corresponding Bus State Manager. Com M shall propagate the indicated state to the users with means of the RTE and Bsw M.
void ComM_BusSM_ModeIndication (NetworkHandleType Channel, ComM_ModeType ComMode);Ecu M or Bsw M shall indicate to Com M when communication is allowed. If Ecu M/ Flex is used: Bsw M AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_COMManager
void ComM_CommunicationAllowed (NetworkHandleType Channel, boolean Allowed);Indication of active diagnostic by the DCM.
void ComM_DCM_ActiveDiagnostic (NetworkHandleType Channel);Indication of inactive diagnostic by the DCM.
void ComM_DCM_InactiveDiagnostic (NetworkHandleType Channel);This API de - initializes the AUTOSAR Communication Manager.
void ComM_DeInit (void);Notification of a wake up on the corresponding partial network cluster.
void ComM_EcuM_PNCWakeUpIndication (PNCHandleType PNCid);Notification of a wake up on the corresponding channel.
void ComM_EcuM_WakeUpIndication (NetworkHandleType Channel);Function to query the current Communication Mode. Com M shall use the corresponding interfaces of the Bus State Managers to get the current Communication Mode of the network. (Call to Bus State Manager API: XXXSM _ Get Current Com Mode(...))
Std_ReturnType ComM_GetCurrentComMode (ComM_UserHandleType User, ComM_ModeType* ComMode);The function returns the current Communication Mode of the corresponding PNC the affected user is assigned to.
Std_ReturnType ComM_GetCurrentPNCComMode (ComM_UserHandleType User, ComM_ModeType* ComMode);Returns the inhibition status of a Com M channel.
Std_ReturnType ComM_GetInhibitionStatus (NetworkHandleType Channel, ComM_InhibitionStatusType* Status);Function t o query the maximum allowed Communication Mode of the corresponding user.
Std_ReturnType ComM_GetMaxComMode (ComM_UserHandleType User, ComM_ModeType* ComMode);This function returns the current configuration of the ECUs PNC - to -
Std_ReturnType ComM_GetPncToChannelMapping (boolean* MappingTable, uint8* ChannelCnt, uint8* PncCnt);Function to query the currently requested Communication Mode of the corresponding user. Availa ble via Com M.h
Std_ReturnType ComM_GetRequestedComMode (ComM_UserHandleType User, ComM_ModeType* ComMode);Returns the initialization status of the AUTOSAR Communication Manager. After a call to Com M_ De Init() Com M should have status COMM_ UNINIT, and a new call to Com M_ Init needed to make sur e Com M restart internal state machines to defailt values.
Std_ReturnType ComM_GetStatus (ComM_InitStatusType* Status);This function returns the published information (for details refer to table 10.3)
void ComM_GetVersionInfo (Std_VersionInfoType* Versioninfo);Initializes the AUTOSAR Communication Manager and restarts the internal state machines.
void ComM_Init (const ComM_ConfigType* ConfigPtr);Changes the inhibition status f or the channel for changing from COMM_ NO_ COMMUNICATION to a higher Communication Mode. (See also Com M_ Limit ECUTo No Com Mode, same functionality but for all channels)
Std_ReturnType ComM_LimitChannelToNoComMode (NetworkHandleType Channel, boolean Status);Changes the inhibition status for the ECU (=all channels) for changing from COMM_ NO_ COMMUNICATION to a high er Communication Mode. (See also Com M_ Limit Channel To No Com Mode, same functionality but for a specific channels)
Std_ReturnType ComM_LimitECUToNoComMode (boolean Status);Notification that the network management has entered Bus - Sleep Mode. This callback function should perform a transition of the hardware and transceiver to bus - sleep mode.
void ComM_Nm_BusSleepMode (NetworkHandleType Channel);If an ECU in role of an intermediate PNC coordinator receives a PN shutdown message via a Nm, then Com M is immediately indicated via Com M_ Nm_ Forward Synchronized Pnc Shutdown to forward the request for a synchronized PNC shutdown of the affected PNCs. Therefore, Com M will immediately release the affected PNC state machines and forward the PN information to the affected Com M Channels and the corresponding NM channels, respectively. Note: This supports a nearly synchronized PNC shutdown across the PN topology from the top - level PNC coordinator down to the subordinated PNC node. Tags: atp.Stat us=draft
void ComM_Nm_ForwardSynchronizedPncShutdown (NetworkHandleType Channel);Notification that the network management has entered Network Mode.
void ComM_Nm_NetworkMode (NetworkHandleType Channel);Indication that a NM - message has been received in the Bus Sleep Mode, what indicates that some nodes in the network have already entered the Network Mode.
void ComM_Nm_NetworkStartIndication (NetworkHandleType Channel);Service to indicate that an NM message with set PNC Learning Bit has been received. Tags: atp.Status=draft
void ComM_Nm_PncLearningBitIndication (NetworkHandleType Channel);Notification that the network management has entered Prepare Bus - Sleep Mode.
void ComM_Nm_PrepareBusSleepMode (NetworkHandleType Channel);Notification that the state of all has left Repeat Message. This interface is used to indicate by the optional Dynamic PNC - to - channel - mapping feature to indicate that learning phase ends. Tags: atp.Status=draft
void ComM_Nm_RepeatMessageLeftIndication (NetworkHandleType Channel);If Nm If has started to shut down the coordinated busses, AND not all coordinated busses have indicated bus sleep state, AND on at least on one of the coordinated busses NM is restarted, THEN the NM Interface shall call the callback function Com M_ Nm_ Res tart Indication with the nm Network Handle of the channels which have already indicated bus sleep state.
void ComM_Nm_RestartIndication (NetworkHandleType Channel);Triggers the NM to return into NM Repe at Message State and send the Partial Network Learning Bit (in order for receiving nodes to respond) together with the Repeat Message Request Bit (in order for receiving nodes to return into NM Repeat Message State). This function is used for the optional Dynamic PNC - to - channel - mapping feature. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_COMManager Tags: atp.Status=draft
Std_ReturnType ComM_PnLearningRequest (void);Changes the inhibition status COMM_ NO_ WAKEUP for the corresponding channel.
Std_ReturnType ComM_PreventWakeUp (NetworkHandleType Channel, boolean Status);This function returns the amount of rejected COMM_ FULL_ COMMUNICATION user requests.
Std_ReturnType ComM_ReadInhibitCounter (uint16* CounterValue);Requesting of a Communication Mode by a user. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_COMManager Note: The following modes are no vaild user requests, since they are used as internal modes: - COMM_ SIL ENT_ COMMUNICATION (this mode is used for synchronization at shutdown) - COMM_ FULL_ COMMUNICATION_ WITH_ WAKEUP_ REQUEST (this mode is used internally within the Com M channel statemachine to trigger the lower layers to request a wakeup on the network if the used hardware support such a feature. (e.g. Ethernet hardware which is compatible with OA TC10). The following modes are valid user requests: - COMM_ NO_ COMMUNICATION - COMM_ FULL_ COMMUNICATION. The communication request could also be released due to
Std_ReturnType ComM_RequestComMode (ComM_UserHandleType User, ComM_ModeType ComMode);This function resets the Inhibited COMM_ FULL_ COMMUNICATION request Counter.
Std_ReturnType ComM_ResetInhibitCounter (void);This function resets dynamic entries within the ECUs PNC - to - channel - mapping to default values Tags: atp.Status=draft
Std_ReturnType ComM_ResetPncToChannelMapping (void);Changes the ECU Group Classification status (see chapter 10.2.2)
Std_ReturnType ComM_SetECUGroupClassification (ComM_InhibitionStatusType Status);This function is used by SWCs to update the PNC membership which is transmitted during PNC Learning. This function is used for the optional Dynamic PNC - to - channel - mapping feature. This function is used for the optional Dynamic PNC - to - channel - mapping feature. Tags: atp.Status=draft
Std_ReturnType ComM_UpdatePncMembership (boolean Control, const uint8* ComM_PncMembership);This function can be used to set entries within the the ECUs PNC - to - channel -
Std_ReturnType ComM_UpdatePncToChannelMapping (const boolean* MappingTable, uint8 channelCnt, uint8 PncCnt);This type contains the implementation - specific post build configuration structure.
Initialization status of Com M.
Current mode of the Communication Manager (main state of the state machine).
Array of uint8 with Elements that holds the current PNC Membership of the node.
Current mode of a PNC
State and sub - state of Com M state machine Com M states vs. Communication Modes: COMM_ NO_ COM* : Communication Mode='No Communication' COMM_ FULL_ COM*: Communication Mode='Full Communication' COMM_ SILENT_ COM: Communicatio Mode='Silent Communication'
number Of Requesters contains the number of valid user handle entries in the "handle Array" member. If no user keeps the channel requested, this is zero {LOWER - LIMIT=0, UPPER - LIMIT= MAX_ CHANNEL_ REQUESTER }
This element contains the user handles of the users which keep the channel requested (if any), starting in its first entries. The size of the array MAX_ CHANNE L_ REQUESTERS is the maximum of the number of users requesting a channel.
Handle to identify a user. For each user, a unique value must be defined at system generation time. Maximum number of users is 255. Legal user IDs are in the range 0 .. 254; user ID 255 is reserved and shall have the symbolic representation COMM_ NOT_ USED _ USER_ ID.
-
-
ComXf
This service deinitializes the transformer.
void ComXf_DeInit(void);This service returns the version information of the called transformer module.
void ComXf_GetVersionInfo(Std_VersionInfoType* VersionInfo);This service initializes the transformer for the further processing.
void ComXf_Init(const ComXf_ConfigType* config);This function deserializes a Sender/Receiver communication using the deserialization of COM Based Transformer. It takes the uint8 array containing the serialized data as input and outputs the original data element which will be passed to the Rte.
This is the type of the data structure containing the initialization data for the transformer.
E2EXf
Deinitializes the E2E transformer.
void E2EXf_DeInit(void);Returns the version information of this module.
void E2EXf_GetVersionInfo(Std_VersionInfoType* versioninfo);Initializes the state of the E2E Transformer. The main part of it is the initialization of the E2E library state structures, which is done by calling all init-functions from E2E library.
void E2EXf_Init(const E2EXf_ConfigType* config);Checks the received data. If the data can be used by the caller, then the function returns E_OK.
Protects the array/buffer to be transmitted, using the in-place transformation.
uint8 E2EXf_<transformerId>([Std_TransformerForwardCode forwardedCode], [Std_ExtractProtocolHeaderFieldsType extractProtocolHeaderFields], [const E2EXf_CSTransactionHandleType* csTransactionHandle], uint8* buffer, uint32* bufferLength, [const uint8* inputBuffer], uint32 inputBufferLength);Parent container for the configuration of E2E Transformer. The content is implementation-specific.
Transaction handle for the C/S method call. - Used to tunnel the E2E Source ID and the E2E Counter from the request to the response at the server side via the RTE.
IpduM
Service returns the version information of this module.
void IpduM_GetVersionInfo(Std_VersionInfoType* versioninfo);Initializes the I-PDU Multiplexer. In configurations, in which IpduM is assigned to more than one partition (i.e. IpduM_Main Functions are mapped to partitions), IpduM may provide one init function per partition.
void IpduM_Init(const IpduM_ConfigType* config);This function performs the processing of the reception activities that are not directly handled within the calls from PduR. Per configured IpduMMainFunctionRx instance one IpduM_MainFunctionRx_<shortName> shall be implemented. Hereby <shortName> is the short name of the IpduMMainFunctionRx configuration container in the ECU configuration.
void IpduM_MainFunctionRx(void);This function performs the processing of the transmission activities that are not directly handled within the calls from PduR. Per configured IpduMMainFunctionTx instance one IpduM_MainFunctionTx_<shortName> shall be implemented. Hereby <shortName> is the short name of the IpduMMainFunctionTx configuration container in the ECU configuration.
void IpduM_MainFunctionTx(void);Indication of a received PDU from a lower layer communication interface module.
void IpduM_RxIndication(PduIdType RxPduId, const PduInfoType* PduInfoPtr);Requests transmission of a PDU.
Std_ReturnType IpduM_Transmit(PduIdType TxPduId, const PduInfoType* PduInfoPtr);Within this API, the upper layer module (called module) shall check whether the available data fits into the buffer size reported by PduInfoPtr->SduLength. If it fits, it shall copy its data into the buffer provided by PduInfoPtr->SduDataPtr and update the length of the actual copied data in PduInfoPtr->SduLength. If not, it returns E_NOT_OK without changing PduInfoPtr.
Std_ReturnType IpduM_TriggerTransmit(PduIdType TxPduId, PduInfoType* PduInfoPtr);The lower layer communication interface module confirms the transmission of a PDU, or the failure to transmit a PDU.
void IpduM_TxConfirmation(PduIdType TxPduId, Std_ReturnType result);This is the type of the data structure containing the initialization data for the I-PDU multiplexer.
LdCom
This function is called to provide the received data of an I-PDU segment (N-PDU) to the upper layer. Each call to this function provides the next part of the I-PDU data. The size of the remaining data is written to the position indicated by bufferSizePtr. Tags: atp.Status=draft
BufReq_ReturnType <LdComUser_LdComCbkCopyRxData>(CbkHandleIdType LdComUserCbkHandleId, const PduInfoType* info, PduLengthType* bufferSizePtr);This function is called to acquire the transmit data of an I-PDU segment (N-PDU). Each call to this function provides the next part of the I-PDU data unless retry->TpDataState is TP_ DATARETRY. In this case the function restarts to copy the data beginning at the offset from the current position indicated by retry->TxTpDataCnt. The size of the remaining data is written to the position indicated by availableDataPtr Tags: atp.Status=draft
BufReq_ReturnType <LdComUser_LdComCbkCopyTxData>(CbkHandleIdType LdComUserCbkHandleId, const PduInfoType* info, const RetryInfoType* retry, PduLengthType* availableDataPtr);Indication of a received PDU from a lower layer communication interface module. Tags: atp.Status=draft
void <LdComUser_LdComCbkRxIndication>(CbkHandleIdType LdComUserCbkHandleId, const PduInfoType* PduInfoPtr);This function is called at the start of receiving an N-SDU. The N-SDU might be fragmented into multiple N-PDUs (FF with one or more following CFs) or might consist of a single N-PDU (SF). The service shall provide the currently available maximum buffer size when invoked with TpSdu Length equal to 0. Tags: atp.Status=draft
BufReq_ReturnType <LdComUser_LdComCbkStartOfReception>(CbkHandleIdType LdComUserCbkHandleId, const PduInfoType* info, PduLengthType TpSduLength, PduLengthType* bufferSizePtr);Called after an I-PDU has been received via the TP API, the result indicates whether the transmission was successful or not. Tags: atp.Status=draft
void <LdComUser_LdComCbkTpRxIndication>(CbkHandleIdType LdComUserCbkHandleId, Std_ReturnType result);This function is called after a Signal has been transmitted via the TP-API on its network. Tags: atp.Status=draft
void <LdComUser_LdComCbkTpTxConfirmation>(CbkHandleIdType LdComUserCbkHandleId, Std_ReturnType result);Within this API, the upper layer module (called module) shall check whether the available data fits into the buffer size reported by PduInfoPtr->SduLength. If it fits, it shall copy its data into the buffer provided by PduInfoPtr->SduDataPtr and update the length of the actual copied data in PduInfoPtr->SduLength. If not, it returns E_NOT_OK without changing PduInfoPtr. Tags: atp.Status=draft
Std_ReturnType <LdComUser_LdComCbkTriggerTransmit>(CbkHandleIdType LdComUserCbkHandleId, PduInfoType* PduInfoPtr);The lower layer communication interface module confirms the transmission of a PDU, or the failure to transmit a PDU. Tags: atp.Status=draft
void <LdComUser_LdComCbkTxConfirmation>(CbkHandleIdType LdComUserCbkHandleId, Std_ReturnType result);This function is called to provide the received data of an I-PDU segment (N-PDU) to the upper layer. Each call to this function provides the next part of the I-PDU data. The size of the remaining buffer is written to the position indicated by bufferSizePtr.
BufReq_ReturnType LdCom_CopyRxData(PduIdType id, const PduInfoType* info, PduLengthType* bufferSizePtr);This function is called to acquire the transmit data of an I-PDU segment (N-PDU). Each call to this function provides the next part of the I-PDU data unless retry->TpDataState is TP_ DATARETRY. In this case the function restarts to copy the data beginning at the offset from the current position indicated by retry->TxTpDataCnt. The size of the remaining data is written to the position indicated by availableDataPtr.
BufReq_ReturnType LdCom_CopyTxData(PduIdType id, const PduInfoType* info, const RetryInfoType* retry, PduLengthType* availableDataPtr);With a call to LdCom_DeInit the AUTOSAR LdCom module is put into an not initialized state.
void LdCom_DeInit(void);Returns the version information of this module.
void LdCom_GetVersionInfo(Std_VersionInfoType* versioninfo);This service initializes internal and external interfaces and variables of the AUTOSAR LdCom module for the further processing.
void LdCom_Init(const LdCom_ConfigType* config);Indication of a received PDU from a lower layer communication interface module.
void LdCom_RxIndication(PduIdType RxPduId, const PduInfoType* PduInfoPtr);This function is called at the start of receiving an N-SDU. The N-SDU might be fragmented into multiple N-PDUs (FF with one or more following CFs) or might consist of a single N-PDU (SF). The service shall provide the currently available maximum buffer size when invoked with TpSdu Length equal to 0.
BufReq_ReturnType LdCom_StartOfReception(PduIdType id, const PduInfoType* info, PduLengthType TpSduLength, PduLengthType* bufferSizePtr);Called after an I-PDU has been received via the TP API, the result indicates whether the transmission was successful or not.
void LdCom_TpRxIndication(PduIdType id, Std_ReturnType result);This function is called after the I-PDU has been transmitted on its network, the result indicates whether the transmission was successful or not.
void LdCom_TpTxConfirmation(PduIdType id, Std_ReturnType result);Requests transmission of a signal.
Std_ReturnType LdCom_Transmit(PduIdTypeId, const PduInfoType* InfoPtr);Within this API, the upper layer module (called module) shall check whether the available data fits into the buffer size reported by PduInfoPtr->SduLength. If it fits, it shall copy its data into the buffer provided by PduInfoPtr->SduDataPtr and update the length of the actual copied data in PduInfoPtr->SduLength. If not, it returns E_NOT_OK without changing PduInfoPtr.
Std_ReturnType LdCom_TriggerTransmit(PduIdType TxPduId, PduInfoType* PduInfoPtr);The lower layer communication interface module confirms the transmission of a PDU, or the failure to transmit a PDU.
void LdCom_TxConfirmation(PduIdType TxPduId, Std_ReturnType result);{OBSOLETE} Service Name Rte_ Ld Com Cbk Copy Rx Data_<sn> (obsolete) Syntax Buf Req_ Return Type Rte_ Ld Com Cbk Copy Rx Data_<sn> ( const Pdu Info Type* info, Pdu Length Type* buffer Size Ptr ) Sync/ Async Synchronous Reentrancy Non Reentrant for same sn, otherwise Reentrant Parameters (in) info Provides the source buffer (Sdu Data Ptr) and the number of bytes to be copied (Sdu Length). An Sdu Length of 0 can be used to query the current amount of available buffer in the upper layer module. In this case, the Sdu Data Ptr may be a NULL_ PTR. Param eters (inout) None Parameters (out) buffer Size Ptr Available receive buffer after data has been copied. Return value Buf Req _ - Return - Type BUFREQ_ OK: Data copied successfully BUFREQ_ E_ NOT_ OK: Data was not copied because an error occurred. Descript ion This function is called to provide the received data of an I - PDU segment (N - PDU) to the upper layer. Each call to this function provides the next part of the I - PDU data. The size of the remaining data is written to the position indicated by buffer Size Ptr. Tags: atp.Status=obsolete Available via Rte_ Cbk.h
BufReq_ReturnType Rte_LdComCbkCopyRxData_<sn>(const PduInfoType* info, PduLengthType* bufferSizePtr);This function is called to acquire the transmit data of an I - PDU segment (N - PDU). Each call to this function provides the next part of the I - PDU data u nless retry - >Tp Data State is TP_ DATARETRY. In this case the function restarts to copy the data beginning at the offset from the current position indicated by retry - >Tx Tp Data Cnt. The size of the remaining data is written to the position indicated by av ailable Data Ptr Tags: atp.Status=obsolete
BufReq_ReturnType Rte_LdComCbkCopyTxData_<sn>(const PduInfoType* info, const RetryInfoType* retry, PduLengthType* availableDataPtr);This function is called at the start of receiving an N - SDU. The N - SDU might be fragmented into multiple N - PDUs (FF with one or more following CFs) or might consist of a single N - PDU (SF). The service shall provide the currently available maximum buffer size when invoked with Tp Sdu Length equal to 0. Tags: atp.Status=obsolete A vailable via Rte_ Cbk.h
BufReq_ReturnType Rte_LdComCbkStartOfReception_<sn>(const PduInfoType* info, PduLengthType TpSduLength, PduLengthType* bufferSizePtr);Indication of a received PDU from a lower layer communication interface module. Tags: atp.Status=obsolete
void Rte_LdComCbkRxIndication_<sn>(const PduInfoType* PduInfoPtr);Called after an I - PDU has been received via the TP API, the result indicates whether the transmission was successful or not. Tags: atp.Status=obsolete
void Rte_LdComCbkTpRxIndication_<sn>(Std_ReturnType result);This function is called after a Signal has been transmitted via the TP - API on its network. Tags: atp.Status=obsolete
void Rte_LdComCbkTpTxConfirmation_<sn>(Std_ReturnType result);Within this API, the upper layer module (called module) shall check whether the available data fits into the buffer size reported by Pdu Info Ptr - >Sdu Length. If it fits, it shall copy its data into the buffer provided by Pdu Info Ptr - >Sdu Data Ptr and update the length of the actual copied data in Pdu Info Ptr - >Sdu Length. If not, it returns E_ NOT_ OK without changing Pdu Info Ptr. Tags: atp.Status=obsolete
Std_ReturnType Rte_LdComCbkTriggerTransmit_<sn>(PduInfoType* PduInfoPtr);The lower layer communication interface module confirms the transmission of a PDU, or the failure to transmit a PDU. Tags: atp.Status=obsolete
void Rte_LdComCbkTxConfirmation_<sn>(Std_ReturnType result);This type contains the implementation-specific post build configuration structure.
Mirror
Creates a CAN ID mask filter.
Std_ReturnType Mirror_AddCanMaskFilter(NetworkHandleType network, uint8* filterId, Can_IdType id, Can_IdType mask);Creates a CAN ID range filter.
Std_ReturnType Mirror_AddCanRangeFilter(NetworkHandleType network, uint8* filterId, Can_IdType lowerId, Can_IdType upperId);Creates a FlexRay filter.
Std_ReturnType Mirror_AddFlexRayFilter(NetworkHandleType network, uint8* filterId, uint16 lowerSlotId, uint16 upperSlotId, uint8 lowerBaseCycle, uint8 upperBaseCycle, uint8 cycleRepetition, Fr_ChannelType frChannel);Creates a LIN frame ID mask filter.
Std_ReturnType Mirror_AddLinMaskFilter(NetworkHandleType network, uint8* filterId, uint8 id, uint8 mask);Creates a LIN frame ID range filter.
Std_ReturnType Mirror_AddLinRangeFilter(NetworkHandleType network, uint8* filterId, uint8 lowerId, uint8 upperId);This function resets the Bus Mirroring module to the uninitialized state.
void Mirror_DeInit(void);Returns the currently selected destination bus.
NetworkHandleType Mirror_GetDestNetwork(void);Returns the network handle (ComMChannel) of the bus identified by the given network type and network ID, or MIRROR_INVALID_NETWORK.
NetworkHandleType Mirror_GetNetworkHandle(Mirror_NetworkType networkType, uint8 networkId);Returns the network ID of the given network.
uint8 Mirror_GetNetworkId(NetworkHandleType network);Returns the network type of the given network.
Mirror_NetworkType Mirror_GetNetworkType(NetworkHandleType network);Returns the state of a pre-configured filter.
Std_ReturnType Mirror_GetStaticFilterState(NetworkHandleType network, uint8 filterId, boolean* isActive);Returns the version information of this module.
void Mirror_GetVersionInfo(Std_VersionInfoType* versionInfo);This function initializes the Bus Mirroring module. In configurations, in which Mirror is assigned to more than one partition (i.e. Mirror_Main Functions are mapped to partitions), Mirror may provide one init function per partition.
void Mirror_Init(const Mirror_ConfigType* configPtr);Returns the global mirroring state.
boolean Mirror_IsMirrorActive(void);Returns the state of a source bus.
boolean Mirror_IsSourceNetworkStarted(NetworkHandleType network);Main function of the Bus Mirroring module. Used for scheduling purposes and timeout supervision. Per configured MirrorMainFunction instance one Mirror_MainFunction_<shortName> shall be implemented. Hereby <shortName> is the short name of the MirrorMainFunction configuration container in the ECU configuration.
void Mirror_MainFunction(void);Completely disables any mirroring activities. Source buses are reset to disabled, queued messages are purged, and the destination bus is reset to the default destination. Pre-configured filters are disabled, and filters added at runtime are removed.
void Mirror_Offline(void);Removes a CAN, LIN, or FlexRay filter that was added at runtime.
Std_ReturnType Mirror_RemoveFilter(NetworkHandleType network, uint8 filterId);Reports a received or transmitted CAN frame. All received CAN frames that pass the hardware acceptance filter are reported, independent of the software filter configuration. Transmitted CAN frames are reported when the transmission is confirmed.
void Mirror_ReportCanFrame(uint8 controllerId, Can_IdType canId, uint8 length, const uint8* payload);Reports a received or transmitted FlexRay frame or a Tx conflict.
void Mirror_ReportFlexRayFrame(uint8 controllerId, uint16 slotId, uint8 cycle, Fr_ChannelType frChannel, const PduInfoType* frame, boolean txConflict);Reports a received or transmitted LIN frame.
void Mirror_ReportLinFrame(NetworkHandleType network, Lin_FramePidType pid, const PduInfoType* pdu, Lin_StatusType status);Sets the state of a pre-configured filter.
Std_ReturnType Mirror_SetStaticFilterState(NetworkHandleType network, uint8 filterId, boolean isActive);Activates a source bus.
Std_ReturnType Mirror_StartSourceNetwork(NetworkHandleType network);Deactivates a source bus.
Std_ReturnType Mirror_StopSourceNetwork(NetworkHandleType network);Changes the destination bus to the given ComM channel. The previously active destination bus and all source buses are disabled.
Std_ReturnType Mirror_SwitchDestNetwork(NetworkHandleType network);Within this API, the upper layer module (called module) shall check whether the available data fits into the buffer size reported by PduInfoPtr->SduLength. If it fits, it shall copy its data into the buffer provided by PduInfoPtr->SduDataPtr and update the length of the actual copied data in PduInfoPtr->SduLength. If not, it returns E_NOT_OK without changing PduInfoPtr.
Std_ReturnType Mirror_TriggerTransmit(PduIdType TxPduId, PduInfoType* PduInfoPtr);The lower layer communication interface module confirms the transmission of a PDU, or the failure to transmit a PDU.
void Mirror_TxConfirmation(PduIdType TxPduId, Std_ReturnType result);Local representation for Can_IdType Variation –
This is the base type for the configuration of the Bus Mirroring module. A pointer to an instance of this structure will be used in the initialization of the Bus Mirroring module. The content of this structure is defined in chapter 10 Configuration specification.
This type represents the assignment of a FlexRay frame to the channels A and B of a FlexRay network. Variation –
This type represents the bus types that are supported as source or destination buses for the Bus Mirroring module. The invalid type is used as a return value if a function cannot return a valid type. Variation –
Nm
Callout function to be called by Nm_CarWakeUpIndication()
void <NmCarWakeUpCallout>(NetworkHandleType nmNetworkHandle);Notification that the network management has entered Bus-Sleep Mode.
void Nm_BusSleepMode(NetworkHandleType nmNetworkHandle);This function is called by a <Bus>Nm to indicate reception of a CWU request.
void Nm_CarWakeUpIndication(NetworkHandleType nmChannelHandle);Check if remote sleep indication takes place or not. For that purpose <Bus>Nm_CheckRemote SleepIndication shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM. (e.g. CanNm_CheckRemoteSleepIndication function is called if channel is configured as CAN).
Std_ReturnType Nm_CheckRemoteSleepIndication(NetworkHandleType nmNetworkHandle, boolean* nmRemoteSleepIndPtr);Cancels an indication, when the NM Coordinator Sleep Ready bit in the Control Bit Vector is set back to 0.
void Nm_CoordReadyToSleepCancellation(NetworkHandleType nmChannelHandle);Sets an indication, when the NM Coordinator Sleep Ready bit in the Control Bit Vector is set
void Nm_CoordReadyToSleepIndication(NetworkHandleType nmChannelHandle);Disables the NM PDU transmission ability. For that purpose <Bus>Nm_DisableCommunication shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM (e.g. CanNm_Disable Communication function is called if channel is configured as CAN).
Std_ReturnType Nm_DisableCommunication(NetworkHandleType NetworkHandle);Enables the NM PDU transmission ability. For that purpose <Bus>Nm_EnableCommunication shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM. (e.g. CanNm_Enable Communication function is called if channel is configured as CAN).
Std_ReturnType Nm_EnableCommunication(NetworkHandleType NetworkHandle);Notification that the network management has received a PN shutdown message on a particular NM-channel. This is used to grant a nearly synchronized PNC shutdown across the entire PN topology. Tags: atp.Status=draft
void Nm_ForwardSynchronizedPncShutdown(void);Notification that the network management has received a PN shutdown message on a particular NM-channel. This is used to grant a nearly synchronized PNC shutdown across the entire PN topology.
void Nm_ForwardSynchronizedPncShutdown(NetworkHandleType NetworkHandle, const uint8* PncBitVectorPtr);Get node identifier configured for the local node. For that purpose <Bus>Nm_GetLocalNode Identifier shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM. (e.g. Can Nm_GetLocalNodeIdentifier function is called if channel is configured as CAN).
Std_ReturnType Nm_GetLocalNodeIdentifier(NetworkHandleType NetworkHandle, uint8* nmNodeIdPtr);Get node identifier out of the last successfully received NM-message. The function <Bus>Nm_ GetNodeIdentifier shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM. (e.g. CanNm_GetNodeIdentifier function is called if channel is configured as CAN).
Std_ReturnType Nm_GetNodeIdentifier(NetworkHandleType NetworkHandle, uint8* nmNodeIdPtr);Get the whole PDU data out of the most recently received NM message. For that purpose <Bus Nm>_GetPduData shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM. (e.g. CanNm_GetPduData function is called if channel is configured as CAN).
Std_ReturnType Nm_GetPduData(NetworkHandleType NetworkHandle, uint8* nmPduData);Returns the state of the network management. The function <Bus>Nm_GetState shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM. (e.g. CanNm_GetState function is called if channel is configured as CAN).
Std_ReturnType Nm_GetState(NetworkHandleType nmNetworkHandle, Nm_StateType* nmStatePtr, Nm_ModeType* nmModePtr);Get user data out of the last successfully received NM message. For that purpose <Bus>Nm_ GetUserData shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM. (e.g. CanNm_GetUserData function is called if channel is configured as CAN).
Std_ReturnType Nm_GetUserData(NetworkHandleType NetworkHandle, uint8* nmUserDataPtr);This service returns the version information of this module.
void Nm_GetVersionInfo(Std_VersionInfoType* nmVerInfoPtr);Initializes the NM Interface.
void Nm_Init(const Nm_ConfigType* ConfigPtr);This function implements the processes of the NM Interface, which need a fix cyclic scheduling.
void Nm_MainFunction(void);Notification that the network management has entered Network Mode.
void Nm_NetworkMode(NetworkHandleType nmNetworkHandle);This function calls the <Bus>Nm_NetworkRelease bus specific function in case NmBusType is not set to NM_BUSNM_LOCALNM (e.g. CanNm_NetworkRelease function is called if channel is configured as CAN).
Std_ReturnType Nm_NetworkRelease(NetworkHandleType NetworkHandle);This function calls the <Bus>Nm_NetworkRequest (e.g. CanNm_NetworkRequest function is called if channel is configured as CAN) function in case NmBusType is not set to NM_BUSNM_ LOCALNM.
Std_ReturnType Nm_NetworkRequest(NetworkHandleType NetworkHandle);Notification that a NM-message has been received in the Bus-Sleep Mode, what indicates that some nodes in the network have already entered the Network Mode.
void Nm_NetworkStartIndication(NetworkHandleType nmNetworkHandle);This function calls the <Bus>Nm_PassiveStartUp function in case NmBusType is not set to NM_BUSNM_LOCALNM (e.g. CanNm_PassiveStartUp function is called for NM_BUSNM_ CANNM).
Std_ReturnType Nm_PassiveStartUp(NetworkHandleType NetworkHandle);Notification that a NM message has been received.
void Nm_PduRxIndication(NetworkHandleType nmNetworkHandle);Indication that a bus specific network management has received a NM message on a particular NM-channel that contain a PNC bit vector. This is used to aggregate the external PNC requests. The function evaluate if a relevant PNC request (PNC bit set to '1') is available in the given PNC bit vector. If a relevant PNC request is available (PNC bit passes the PNC bit vector filter), then the RelevantPncRequestDetectedPtr refers to a boolean with value set to TRUE. Otherwise refer to booelan with value set to FALSE. RelevantPncRequestDetectedPtr is evaluated by the callee <Bus>Nm module to qualify the further processing of the received NM-PDU.
void Nm_PncBitVectorRxIndication(NetworkHandleType NetworkHandle, const uint8* PncBitVectorPtr, boolean* RelevantPncRequestDetectedPtr);Function called by <Bus>Nms to confirm the state of the transmission for the given PNC bit vector on the given NM-Channel.
void Nm_PncBitVectorTxConfirmation(NetworkHandleType NetworkHandle, const uint8* PncBitVectorPtr, Std_ReturnType result);Function called by <Bus>Nms to request the aggregated internal PNC requests for transmission within the Nm message.
void Nm_PncBitVectorTxIndication(NetworkHandleType NetworkHandle, uint8* PncBitVectorPtr);Set Repeat Message Request Bit and Partial Network Learning Bit for NM messages transmitted next on the bus. For that purpose <Bus>Nm_PnLearningRequest shall be called (e.g. CanNm_PnLearningRequest function if channel is configured as CAN). This will force all nodes to enter the PNC Learning Phase and re-enter Repeat Message Stat. This is needed for the optional Dynamic PNC-to-channel-mapping feature.
Std_ReturnType Nm_PnLearningRequest(NetworkHandleType NetworkHandle);Notification that the network management has entered Prepare Bus-Sleep Mode.
void Nm_PrepareBusSleepMode(NetworkHandleType nmNetworkHandle);Notification that the network management has detected that not all other nodes on the network are longer ready to enter Bus-Sleep Mode.
void Nm_RemoteSleepCancellation(NetworkHandleType nmNetworkHandle);Notification that the network management has detected that all other nodes on the network are ready to enter Bus-Sleep Mode.
void Nm_RemoteSleepIndication(NetworkHandleType nmNetworkHandle);Service to indicate that an NM message with set Repeat Message Re- quest Bit has been received. This is needed for node detection and the Dynamic PNC-to-channel-mapping feature.
void Nm_RepeatMessageIndication(NetworkHandleType nmNetworkHandle, boolean pnLearningBitSet);Set Repeat Message Request Bit for NM messages transmitted next on the bus. For that purpose <Bus>Nm_RepeatMessageRequest shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM. (e.g. CanNm_RepeatMessageRequest function is called if channel is configured as CAN). This will force all nodes on the bus to transmit NM messages so that they can be identified.
Std_ReturnType Nm_RepeatMessageRequest(NetworkHandleType NetworkHandle);This function store the request for a synchronized PNC shutdown of a particular PNC given by PncId per given NM-Channel. The handling of the synchronized PNC shutdown process is mainly done in the context of the Nm_Mainfunction. The function call is only valid if NmStandardBusType is not set to NM_BUSNM_LOCALNM as a <Bus>Nm like CanNm is needed to transmit the PNC shutdown requests.
Std_ReturnType Nm_RequestSynchronizedPncShutdown(NetworkHandleType NetworkHandle, PNCHandleType PncId);Set user data for NM messages transmitted next on the bus. For that purpose <Bus>Nm_Set UserData shall be called in case NmBusType is not set to NM_BUSNM_LOCALNM. (e.g. Can Nm_SetUserData function is called if channel is configured as CAN).
Std_ReturnType Nm_SetUserData(NetworkHandleType NetworkHandle, const uint8* nmUserDataPtr);Notification that the state of the lower layer <Bus>Nm has changed.
void Nm_StateChangeNotification(NetworkHandleType nmNetworkHandle, Nm_StateType nmPreviousState, Nm_StateType nmCurrentState);Notification to the NM Coordinator functionality that this is a suitable point in time to initiate the coordinated shutdown on.
void Nm_SynchronizationPoint(NetworkHandleType nmNetworkHandle);Notification that the network management has entered Synchronize Mode.
void Nm_SynchronizeMode(NetworkHandleType nmNetworkHandle);Service to indicate that an attempt to send an NM message failed.
void Nm_TxTimeoutException(NetworkHandleType nmNetworkHandle);Indication by ComM of internal PNC requests. This is used to aggregate the internal PNC requests.
void Nm_UpdateIRA(NetworkHandleType NetworkHandle, const uint8* PncBitVectorPtr);BusNm Type
Configuration data structure of the Nm module.
Operational modes of the network management.
States of the network management state machine.
PduR
Disables a routing path group.
void PduR_DisableRouting (PduR_RoutingPathGroupIdType id, boolean initialize);Enables a routing path group.
void PduR_EnableRouting (PduR_RoutingPathGroupIdType id);Returns the unique identifier of the post-build time configuration of the PDU Router
PduR_PBConfigIdType PduR_GetConfigurationId (void);Returns the version information of this module.
void PduR_GetVersionInfo (Std_VersionInfoType* versionInfo);Initializes the PDU Router
void PduR_Init (const PduR_PBConfigType* ConfigPtr);Identification of the post-build configuration currently used for routing I-PDUs. An ECU may contain several configurations (post-build selectable), each have unique Id.
Data structure containing post-build-time configuration data of the PDU Router.
Identification of a Routing Table
States of the PDU Router
SomeIpXf
This service deinitializes the transformer.
void SomeIpXf_DeInit(void);Function to extract the relevant SOME/IP protocol header fields of the message and the type of the message result. - At the time being, this is limited to the types used for C/S communication (i.e., REQUEST and RESPONSE and OK and ERROR).
Std_ReturnType SomeIpXf_ExtractProtocolHeaderFields(const uint8* buffer, uint32 bufferLength, Std_MessageTypeType* messageType, Std_MessageResultType* messageResult);This service returns the version information of the called transformer module.
void SomeIpXf_GetVersionInfo(Std_VersionInfoType* VersionInfo);This service initializes the transformer for the further processing.
void SomeIpXf_Init(const SomeIpXf_ConfigType* config);This function deserializes a Sender/Receiver communication using the deserialization of SOME/IP. It takes the uint8 array containing the serialized data as input and outputs the original data element which will be passed to the RTE.
This function deserializes a Client/Server communication using the deserialization of SOME/IP. It takes the uint8 array containing the serialized data as input and outputs the return value of the server runnable and the operation arguments which have to be passed from the server to the client.
uint8 SomeIpXf_Inv_<transformerId>(Rte_Cs_TransactionHandleType* TransactionHandle, const uint8* buffer, uint32 bufferLength, [ Std_ReturnType* returnValue ], [ <paramtype> data ]);This function transforms a Sender/Receiver communication using the serialization of SOME/IP. It takes the data element as input and outputs a uint8 array containing the serialized data. The length of the serialized data shall be calculated by the transformer during runtime and returned in the OUT-parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.
This function transforms a Client/Server communication using the serialization of SOME/IP. It takes the operation arguments and optionally the return value as input and outputs a uint8 array containing the serialized data. The length of the serialized data shall be calculated by the transformer during runtime and returned in the OUT-parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.
uint8 SomeIpXf_<transformerId>(const Rte_Cs_TransactionHandleType* TransactionHandle, uint8* buffer, uint32* bufferLength, [ Std_ReturnType returnValue ], <paramtype> data_1, ... <paramtype> data_n);This function transforms an external trigger event using the serialization of SOME/IP. It takes trigger as input and outputs a uint8 array. The length of the transformed data shall be calculated by the transformer during runtime and returned in the OUT parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.
This is the type of the data structure containing the initialization data for the transformer.
Xcp
Returns the version information of this module.
void Xcp_GetVersionInfo(Std_VersionInfoType* versioninfo);This service initializes interfaces and variables of the AUTOSAR XCP layer.
void Xcp_Init(const Xcp_ConfigType* Xcp_ConfigPtr);Indication of a received PDU from a lower layer communication interface module.
void Xcp_<Lo>RxIndication(PduIdType RxPduId, const PduInfoType* PduInfoPtr); ⚠️Within this API , the upper layer module (called module) shall check whether the available data fits into the buffer size reported by Pdu Info Ptr - >Sdu Length. If it fits, it shall copy its data into the buffer provided by Pdu Info Ptr - >Sdu Data Ptr and update the length of the actual copied data in Pdu Info Ptr - >Sdu Length. If not, it returns E_ NOT_ OK without changing Pdu Info Ptr.
Std_ReturnType Xcp_<Lo>TriggerTransmit(PduIdType TxPduId, PduInfoType* PduInfoPtr); ⚠️The lower layer communication interface module confirms the transmission of a PDU, or the failure to transmit a PDU.
void Xcp_< Lo>TxConfirmation(PduIdType TxPduId, Std_ReturnType result); ⚠️Scheduled function of the XCP module
void Xcp_MainFunction(void);This API is used to turn on and off of the TX capabilities of used communication bus channel in XCP module.
void Xcp_SetTransmissionMode(NetworkHandleType Channel, Xcp_TransmissionModeType Mode);This is the type of the data structure containing the initialization data for XCP.
Handles the enabling and disabling of the transmission mode
Xfrm
This service deinitializes the transformer.
void <Mip>_DeInit(void);Function to extract the relevant protocol header fields of the message and the type of the message result of a transformer. - At the time being, this is limited to the types used for C/S communication (i.e., REQUEST and RESPONSE and OK and ERROR).
Std_ReturnType <Mip>_ExtractProtocolHeaderFields(const uint8* buffer, uint32 bufferLength, Std_MessageTypeType* messageType, Std_MessageResultType* messageResult);This service returns the version information of the called transformer module.
void <Mip>_GetVersionInfo(Std_VersionInfoType* VersionInfo);This service initializes the transformer for the further processing.
void <Mip>_Init(const {Mip}_ConfigType* config);This function is the interface of the first transformer in a transformer chain of Client/Server communication (this is the last executed transformer on the receiving side!). It takes the constant buffer (IN parameter buffer) of length (IN parameter bufferLength which may be smaller than the maximum buffer size used by the RTE for buffer allocation) as input and outputs the operation arguments and optionally the return value (OUT parameters data_1, ..., data_n, and returnValue).
uint8 <Mip>_Inv_<transformerId>([ <datatype>* csTransactionHandle ], Rte_Cs_TransactionHandleType* TransactionHandle, const uint8* buffer, uint32 bufferLength, [ Std_ReturnType* returnValue ], [ <paramtype> data ]);This function is the interface of a transformer which is not the first transformer in a transformer chain. It takes the output of an earlier transformer in the chain and transforms the data. The length of the transformed data shall be calculated by the transformer during runtime and returned in the OUT parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.
This function is the interface of the first transformer in a transformer chain of Sender/Receiver communication. The length of the transformed data shall be calculated by the transformer during runtime and returned in the OUT parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.
This function is the interface of the first transformer in a transformer chain of Client/Server communication. It takes the operation arguments and optionally the return value as input and outputs a uint8 array containing the transformed data. The length of the transformed data shall be calculated by the transformer during runtime and returned in the OUT parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.
uint8 <Mip>_<transformerId>([ const <datatype>* csTransactionHandle ], const Rte_Cs_TransactionHandleType* TransactionHandle, uint8* buffer, uint32* bufferLength, [ Std_ReturnType returnValue ], [ <paramtype> data_1, ... <paramtype> data_n ]);This function is the interface of the first transformer in a transformer chain of Sender/Receiver communication. The length of the transformed data shall be calculated by the transformer during runtime and returned in the OUT parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation. 5 General 4
This function is the interface of the first transformer in a transformer chain of external trigger events. The length of the transformed data shall be calculated by the transformer during runtime and returned in the OUT parameter bufferLength. It may be smaller than the maximum buffer size used by the RTE for buffer allocation.
This is the type of the data structure containing the initialization data for the transformer.
Guia do clusterGERADO POR IA
Coordena o roteamento de PDUs, o processamento de sinais e o gerenciamento de modo de rede da pilha de comunicação.
Coordena o roteamento de PDUs, o processamento de sinais e o gerenciamento de modo de rede da pilha de comunicação.
O cluster de módulos «Communication Services» reúne com com, comm e pdur o processamento central de sinais, o roteamento de PDUs e o gerenciamento do modo de rede da AUTOSAR Classic Platform SWS_PDURouter p. 24. Ele assegura que os sinais da aplicação sejam empacotados de forma consistente, que as I-PDUs sejam encaminhadas às interfaces de comunicação de maneira independente de protocolo por meio de tabelas estáticas de roteamento e que os recursos de barramento sejam ativados conforme a necessidade [SWS_Com_00197], [SWS_PduR_00160]. Além disso, por meio de interfaces padronizadas, são coordenados o roteamento seletivo de redes parciais, o monitoramento de prazos e os mecanismos de degradação para a operação com economia de energia da ECU [SWS_ComM_00110].
O cluster de módulos «Communication Services» forma a espinha dorsal de processamento de mensagens e sinais da AUTOSAR Classic Platform. Ele integra os três módulos de software básico com, comm e pdur no Services Layer: enquanto o módulo com serializa, filtra e monitora sinais e grupos de sinais da RTE em I-PDUs [SWS_Com_00197], o pdur assume, como instância de encaminhamento independente de protocolo, o roteamento 1:1 e 1:n de I-PDUs entre usuários superiores e as interfaces de barramento sem modificação dos dados úteis [SWS_PduR_00160]. O módulo comm coordena o estado de comunicação avaliando requisições de SW-Cs ou canais de diagnóstico e ativando os canais sob demanda por meio de Bus State Managers [SWS_ComM_00110], [SWS_ComM_00873].
Diagrama de arquitetura: relações entre módulos e integração do cluster Communication Services no software básico. Fontes: SWS_PDURouter p. 24, SWS_COMManager p. 30
No fluxo de transmissão e recepção, os módulos operam em estreita cooperação. Em requisições de transmissão, o com encaminha I-PDUs via PduR_ComTransmit para o pdur, que traduz os IDs de I-PDU e comanda os drivers de destino [SWS_PduR_00406], [SWS_PduR_00766]. Em interfaces com temporização cíclica (p. ex., LIN), o driver inferior solicita dados sob demanda via TriggerTransmit, o que o PDU Router repassa de forma não bufferizada até o com [SWS_Com_00001], [SWS_PduR_00430]. O pdur entrega I-PDUs recebidas via RxIndication ao com para desempacotamento de sinais e pode replicá-las simultaneamente para outros barramentos por meio de rotas de gateway [SWS_Com_00123], [SWS_PduR_00362].
O ciclo de vida é determinado de forma decisiva pelos estados do comm e do pdur. Após a inicialização do sistema, o PduR_Init comuta o roteador de PDUR_UNINIT para PDUR_ONLINE [SWS_PduR_00308], [SWS_PduR_00326]. O Communication Manager gerencia os canais por meio dos estados principais COMM_NO_COMMUNICATION, COMM_FULL_COMMUNICATION e COMM_SILENT_COMMUNICATION [SWS_ComM_00871]. O cluster suporta degradação seletiva e estados de economia de energia por meio de mecanismos como Communication Inhibition (p. ex., ComM_LimitChannelToNoComMode) e grupos dinâmicos de caminhos de roteamento (PduR_EnableRouting / PduR_DisableRouting) [SWS_ComM_00163], [SWS_PduR_00615].
Arquitetura do sistema & papel do cluster de módulos
O cluster de módulos «Communication Services» forma o centro funcional da pilha de comunicação da AUTOSAR Classic Platform (Release R20-11) dentro do Services Layer. Ele é composto pelos três módulos de software básico estreitamente interligados com (AUTOSAR COM), comm (Communication Manager) e pdur (PDU Router). Em conjunto, esses módulos encapsulam o gerenciamento independente de barramento, o encaminhamento e a abstração de sinais da rede de ECUs em relação ao ambiente de tempo de execução (RTE) e aos componentes de software de aplicação (SW-Cs), em conformidade com a arquitetura em camadas AUTOSAR SWS_PDURouter p. 24. Para baixo, o cluster interage diretamente com as interfaces da camada de abstração de hardware de comunicação (CanIf, LinIf, FrIf, EthIf), bem como com os protocolos de transporte (CanTp, FrTp, LinTp) de acordo com normas como ISO 11898 (CAN), ISO 17987 (LIN), ISO 10681 (FlexRay) e ISO 15765-2 (Transport Layer) AUTOSAR_CP_SWS_PDURouter p. 110.
O módulo com realiza o processamento de dados orientado a sinais: ele transforma sinais e grupos de sinais da RTE em unidades de interação (I-PDUs), assume o empacotamento e desempacotamento (Signal Packing), a conversão de endianness e sinal numérico, bem como a filtragem e o monitoramento de prazos de transmissão (Deadline Monitoring) [SWS_Com_00197], [SWS_Com_00784]. O módulo pdur atua como instância de encaminhamento independente de protocolo, que repassa I-PDUs sem modificação de conteúdo entre módulos de serviço superiores (Com, DCM) e interfaces de comunicação inferiores ou protocolos de transporte, atende a caminhos locais de multicast 1:n e implementa gateways diretos [SWS_PduR_00160], [SWS_PduR_00406]. O comm assume o controle orientado a recursos e estados: ele agrega requisições de comunicação de componentes de software, do gerenciador de modo BSW (BswM) e de serviços de diagnóstico (DCM conforme ISO 14229 / UDS) e coordena os modos de operação de canais físicos e redes parciais (Partial Network Clusters, PNC) [SWS_ComM_00110], [SWS_ComM_00873].
Diagrama de arquitetura: relações entre módulos e integração do cluster Communication Services no software básico. Fontes: SWS_PDURouter p. 24, SWS_COMManager p. 30, SWS_RTE p. 329
Interação e caminhos de interação entre os módulos
A interação dentro do cluster ocorre por meio de cadeias de chamadas claramente definidas para caminhos de transmissão, recepção e confirmação. Na transmissão, a RTE chama APIs de transmissão específicas do módulo com, por exemplo Com_SendSignal ou Com_SendSignalGroup, para disponibilizar dados de forma atômica [SWS_Com_00197], [SWS_Com_00200]. O módulo com empacota os sinais na I-PDU correspondente e a transfere de forma síncrona ao PDU Router por meio de PduR_ComTransmit [SWS_PduR_00406]. O PDU Router consulta a I-PDU de destino em suas tabelas estáticas de roteamento, converte o ID da I-PDU e repassa a ordem de transmissão inalterada à camada inferior responsável, por exemplo via CanIf_Transmit [SWS_PduR_00161], [SWS_PduR_00766]. Após o envio bem-sucedido no barramento, a interface confirma a transferência ao pdur por meio de PduR_<User:Lo>TxConfirmation [SWS_PduR_00365], o qual encaminha a chamada para Com_TxConfirmation [SWS_Com_00124].
Para sistemas de barramento acionados por tempo ou baseados em consulta, como LIN ou FlexRay, a pilha desacopla a requisição de transmissão por meio do procedimento TriggerTransmit: o módulo com inicia a prontidão de transmissão, mas armazena os dados úteis internamente AUTOSAR_CP_SWS_PDURouter p. 101. Assim que o escalonador do barramento (por exemplo, no LinIf ou FrIf) atinge o instante de transmissão, a camada inferior chama PduR_<User:Lo>TriggerTransmit [SWS_PduR_00430]. O PDU Router delega essa chamada imediatamente e de forma não bufferizada ao Com_TriggerTransmit [SWS_Com_00001], após o que o com copia os dados atuais diretamente para o buffer do driver SWS_PDURouter p. 107.
No caminho de recepção, a interface de comunicação inferior sinaliza a chegada de uma I-PDU via PduR_<User:Lo>RxIndication [SWS_PduR_00362]. O PDU Router encaminha a PDU sincronamente via Com_RxIndication para o com [SWS_Com_00123], onde os sinais são desempacotados, filtrados e disponibilizados para a RTE AUTOSAR_CP_SWS_PDURouter p. 97. Simultaneamente, o pdur suporta gatewaying: uma I-PDU recebida pode ser entregue localmente ao com e, em paralelo, ser encaminhada para uma interface de rede de saída [SWS_PduR_00621], SWS_PDURouter p. 114. No caso de PDUs de protocolo de transporte (p. ex., CanTp ou DCM), o pdur orquestra a transmissão segmentada por meio de StartOfReception, CopyRxData e TpRxIndication [SWS_PduR_00507], [SWS_Com_00691], [SWS_Com_00692].
Diagrama de sequência: caminho de transmissão de I-PDU controlado e fluxo TriggerTransmit via PduR. Fontes: SWS_PDURouter p. 107, AUTOSAR_SWS_COM p. 114
Sincronização, reentrância e contextos de tarefas
Os módulos do cluster operam em um contexto de execução híbrido composto por chamadas de função síncronas e processamento periódico de tarefas. Callbacks de recepção (RxIndication) e confirmações de transmissão (TxConfirmation) são frequentemente disparados no contexto de interrupção dos drivers subjacentes ou no contexto de tarefa das interfaces de comunicação. Por esse motivo, as funções de encaminhamento do PDU Router são projetadas estritamente como reentrantes SWS_PDURouter p. 88. O cancelamento de transmissões em andamento via PduR_<User:Up>CancelTransmit é especificado como reentrante para IDs de PDU diferentes, mas como não reentrante para IDs de PDU idênticos [SWS_PduR_00769].
No módulo comm, a interface de usuário primária ComM_RequestComMode é explicitamente projetada para chamadas concorrentes por múltiplos Runnables (canbeInvokedConcurrently = TRUE) e implementada como reentrante [SWS_ComM_00110], SWS_COMManager p. 107. Consultas de status como ComM_GetRequestedComMode [SWS_ComM_00079] e ComM_GetMaxComMode [SWS_ComM_00085] também estão disponíveis como reentrantes. Em contrapartida, funções administrativas como ComM_SetECUGroupClassification [SWS_ComM_00552], ComM_GetInhibitionStatus [SWS_ComM_00619], bem como APIs de associação dinâmica (p. ex., ComM_UpdatePncToChannelMapping [SWS_ComM_01037]), são definidas como não reentrantes e exigem a chamada a partir de níveis protegidos de tarefa.
Para evitar inconsistências de dados em acessos múltiplos a sinais, a AUTOSAR prescreve o processamento atômico de sinais por meio de grupos de sinais para tipos de dados compostos [SWS_Com_00197], [SWS_Com_00200]. A RTE divide os sinais e os serializa de forma consistente em buffers de sombra locais antes que o Com_SendSignalGroup libere a I-PDU SWS_RTE p. 329. Atividades cíclicas de transmissão e monitoramentos de prazos são processados por meio de MainFunctions periódicas dos módulos, sendo que grupos de I-PDUs são ativados ou parados sob demanda pelo BswM via Com_IpduGroupStart e Com_IpduGroupStop [SWS_Com_00784], SWS_BSWModeManager p. 93.
Ciclos de vida típicos e modos de operação
O ciclo de vida do cluster de módulos segue uma sequência rigorosa de inicialização e operação. Durante a inicialização, o PDU Router encontra-se inicialmente no estado PDUR_UNINIT, no qual nenhum roteamento é permitido [SWS_PduR_00325], [SWS_PduR_00330]. Por meio da chamada de PduR_Init, todos os buffers internos são alocados e inicializados, e o módulo transita para o estado PDUR_ONLINE [SWS_PduR_00308], [SWS_PduR_00742]. O módulo comm inicia de forma análoga no estado COMM_UNINIT [SWS_ComM_00668]. Por meio de ComM_Init, parâmetros persistentes (p. ex., contadores de inibição e mapeamentos de PNC) são lidos da NVRAM e as máquinas de estados de canal são transferidas para o estado padrão COMM_NO_COM_NO_PENDING_REQUEST [SWS_ComM_00146], [SWS_ComM_00674].
A máquina de estados de canal no comm controla três modos de comunicação superiores: COMM_NO_COMMUNICATION, COMM_SILENT_COMMUNICATION e COMM_FULL_COMMUNICATION [SWS_ComM_00871]. Os usuários só podem solicitar comunicação total ou nenhuma comunicação [SWS_ComM_00110]. Se uma requisição de usuários ou do DCM for recebida em COMM_NO_COM_NO_PENDING_REQUEST (ComM_DCM_ActiveDiagnostic), a máquina de estados muda para COMM_NO_COM_REQUEST_PENDING [SWS_ComM_00873]. Assim que houver permissão de comunicação, ocorre a transição para COMM_FULL_COM_NETWORK_REQUESTED, momento em que o comm solicita a prontidão de transmissão e recepção por meio do respectivo Bus State Manager [SWS_ComM_01018], SWS_COMManager p. 64.
Se a comunicação total for liberada por todos os usuários, o canal comuta para COMM_FULL_COM_READY_SLEEP e, em caso de gerenciamento de rede completo, solicita Nm_NetworkRelease SWS_COMManager p. 78. Para a preparação do Bus-Sleep, a máquina de estados transita para COMM_SILENT_COM, na qual a transmissão é inibida, mas a recepção permanece ativa para sincronização [SWS_ComM_00391], [SWS_ComM_00829]. Ao ser sinalizado ComM_<Bus>SM_BusSleepMode, alcança-se novamente COMM_NO_COM_NO_PENDING_REQUEST [SWS_ComM_91000]. Um despertar pelo EcuM é processado via ComM_EcuM_WakeUpIndication ou ComM_EcuM_PNCWakeUpIndication [SWS_ComM_91001]. Um shutdown da ECU via ComM_DeInit só é permitido quando todos os canais estiverem completamente desinicializados em COMM_NO_COMMUNICATION [SWS_ComM_00147].
Diagrama de estados: modelo de estados e transição de modo de operação de um canal de comunicação ComM. Fontes: SWS_COMManager p. 112, SWS_COMManager p. 63, SWS_COMManager p. 71
Tratamento de erros, rastreamento pelo DET e degradação
O gerenciamento de erros e degradação do cluster baseia-se em notificações padronizadas ao Development Error Tracer (DET), bem como em mecanismos configuráveis de restrição (Communication Inhibition). Se a detecção de desenvolvimento estiver ativada, o pdur reporta chamadas não inicializadas por meio do código de erro PDUR_E_UNINIT [SWS_PduR_00100], [SWS_PduR_00119]. IDs de tabelas de roteamento com falha em chamadas de controle são sinalizados com PDUR_E_ROUTING_PATH_GROUP_ID_INVALID [SWS_PduR_00648], enquanto parâmetros de ponteiro inválidos são reportados como PDUR_E_PARAM_POINTER SWS_PDURouter p. 72. No módulo comm, a chamada de APIs de monitoramento antes da inicialização concluída resulta no retorno do status COMM_UNINIT [SWS_ComM_00242], [SWS_ComM_00668].
Para degradação controlada e redução do consumo de corrente, o comm oferece interfaces para limitação de comunicação: por meio de ComM_LimitChannelToNoComMode ou ComM_LimitECUToNoComMode, a transição para comunicação total pode ser bloqueada para canais individuais ou para toda a ECU [SWS_ComM_00124], [SWS_ComM_00163]. Além disso, o ComM_PreventWakeUp suprime o despertar da ECU baseado em rede [SWS_ComM_00156]. A autorização desses bloqueios é controlada por meio de bits de máscara (ComM_SetECUGroupClassification [SWS_ComM_00552]). Requisições de comunicação total rejeitadas são registradas em um contador de memória de erros não volátil, diagnosticável via ComM_ReadInhibitCounter e ComM_ResetInhibitCounter [SWS_ComM_00108], [SWS_ComM_00224]. Requisições de diagnóstico do DCM sobrepõem temporariamente as restrições ativas de comunicação para manter a ECU sempre acessível [SWS_ComM_00873], SWS_COMManager p. 69.
Durante a operação contínua, caminhos de comunicação no PDU Router podem ser degradados ou ativados dinamicamente: por meio de PduR_EnableRouting e PduR_DisableRouting, o BswM comuta imediatamente grupos de caminhos de roteamento configurados [SWS_PduR_00615], [SWS_PduR_00617], [SWS_PduR_00715]. Se um caminho de roteamento estiver desativado, as chamadas de transmissão e recepção das I-PDUs afetadas rejeitam imediatamente a transmissão de dados com E_NOT_OK ou BUFREQ_E_NOT_OK SWS_PDURouter p. 69. Em configurações post-build, o pdur monitora a integridade da configuração via PduR_GetConfigurationId para excluir alocações incorretas em limites alterados de tabelas e buffers na RAM e na NVRAM [SWS_PduR_00341], [SWS_PduR_00771], SWS_PDURouter p. 160.
Este guia de cluster foi gerado de forma automatizada com base nas especificações da AUTOSAR Classic Platform (Release R20-11) para os módulos com, comm e pdur.
Module im Cluster
AUTOSAR COM
The AUTOSAR COM module provides signal-based communication services for inter-ECU exchange across diverse bus systems.
Communication Manager (ComM)
Manages communication states and channel modes across multiple network interfaces.
COM Based Transformer (ComXf)
AUTOSAR Classic Communication Services-Modul COM Based Transformer (ComXf, Spezifikation: AUTOSAR_CP_SWS_COMBasedTransformer.pdf, AUTOSAR_SWS_COMBasedTransformer.pdf).
Data Distribution Service (Dds)
AUTOSAR Classic Communication Services-Modul Data Distribution Service (Dds, Spezifikation: AUTOSAR_CP_SWS_DataDistributionService.pdf, AUTOSAR_SWS_ClassicPlatformDataDistributionService.pdf).
Data Distribution Service Transformer (DdsXf)
AUTOSAR Classic Communication Services-Modul Data Distribution Service Transformer (DdsXf, Spezifikation: AUTOSAR_CP_SWS_DataDistributionServiceTransformer.pdf).
E2E Transformer (E2EXf)
AUTOSAR Classic Communication Services-Modul E2E Transformer (E2EXf, Spezifikation: AUTOSAR_CP_SWS_E2ETransformer.pdf, AUTOSAR_SWS_E2ETransformer.pdf).
IPDU Multiplexer (IpduM)
AUTOSAR Classic Communication Services-Modul IPDU Multiplexer (IpduM, Spezifikation: AUTOSAR_CP_SWS_IPDUMultiplexer.pdf, AUTOSAR_SWS_IPDUM.pdf, AUTOSAR_SWS_IPDUMultiplexer.pdf).
Large Data COM (LdCom)
AUTOSAR Classic Communication Services-Modul Large Data COM (LdCom, Spezifikation: AUTOSAR_CP_SWS_LargeDataCOM.pdf, AUTOSAR_SWS_LargeDataCOM.pdf).
LSDU Router (LSduR)
AUTOSAR Classic Communication HW Abstraction-Modul LSDU Router (LSduR, Spezifikation: AUTOSAR_CP_SWS_LSduRouter.pdf).
Bus Mirroring (Mirror)
AUTOSAR Classic Communication Services-Modul Bus Mirroring (Mirror, Spezifikation: AUTOSAR_CP_SWS_BusMirroring.pdf, AUTOSAR_SWS_BusMirroring.pdf).
Network Management Interface (Nm)
AUTOSAR Classic Communication Services-Modul Network Management Interface (Nm, Spezifikation: AUTOSAR_CP_SWS_NetworkManagementInterface.pdf, AUTOSAR_SWS_NMInterface.pdf, AUTOSAR_SWS_NetworkManagementInterface.pdf).
PDU Router (PduR)
The PDU Router routes I-PDUs between communication interfaces, transport protocols, and upper layers without payload inspection.
SOME/IP Transformer (SomeIpXf)
AUTOSAR Classic Communication Services-Modul SOME/IP Transformer (SomeIpXf, Spezifikation: AUTOSAR_CP_SWS_SOMEIPTransformer.pdf, AUTOSAR_SWS_SOMEIPTransformer.pdf).
AUTOSAR Xcp
AUTOSAR Classic Communication Services-Modul XCP (Xcp, Spezifikation: AUTOSAR_CP_SWS_XCP.pdf, AUTOSAR_SWS_XCP.pdf).
General Transformer Specification (Xfrm)
AUTOSAR Classic Communication Services-Modul General Transformer Specification (Xfrm, Spezifikation: AUTOSAR_ASWS_TransformerGeneral.pdf, AUTOSAR_CP_ASWS_TransformerGeneral.pdf).
gemini-3.8-flash-low· 2026-10-13 · Original em alemão