AUTOSAR Classic CAN

Das CAN-Cluster (Controller Area Network) stellt hardwarenahe Treiber, standardisierte Hardware-Abstraktion (CanIf), State-Management und ISO 15765-2 Transportprotokolle (CanTp) für klassische CAN-, CAN FD- und CAN XL-Netzwerke bereit.

Themenkarte

Detailansicht

Wähle in der Gliederung einen Eintrag aus.

Für dieses Release liegen keine Elementdaten vor

Can

<LPDU_CalloutName> function

boolean <LPDU_CalloutName> (uint8 Hrh, Can_IdType CanId, uint8 CanDataLegth, const uint8* CanSduPtr);

Can_CheckWakeup function

This function checks if a wakeup has occurred for the given controller.

Std_ReturnType Can_CheckWakeup (uint8 Controller);

Can_DeInit function

This function de - initializes the module.

void Can_DeInit (void);

Can_DisableControllerInterrupts function

This function disables all interrupts for this CAN controller.

void Can_DisableControllerInterrupts (uint8 Controller);

Can_EnableControllerInterrupts function

This function enables all allowed interrupts.

void Can_EnableControllerInterrupts (uint8 Controller);

Can_GetControllerErrorState function

This service obtains the error state of the CAN controller.

Std_ReturnType Can_GetControllerErrorState (uint8 ControllerId, Can_ErrorStateType* ErrorStatePtr);

Can_GetControllerMode function

This service reports about the current status of the requested CAN controller.

Std_ReturnType Can_GetControllerMode (uint8 Controller, Can_ControllerStateType* ControllerModePtr);

Can_GetControllerRxErrorCounter function

Returns the Rx error counter for a CAN controller. This value might not be available for all CAN controllers, in which cas e E_ NOT_ OK would be returned. Please note that the value of the counter might not be correct at the moment the API returns it, because the Rx counter is handled asynchronously in hardware. Applications should not trust this value for any assumption about the current bus state.

Std_ReturnType Can_GetControllerRxErrorCounter (uint8 ControllerId, uint8* RxErrorCounterPtr);

Can_GetControllerTxErrorCounter function

Returns the Tx error counter for a CAN controller. This value might not be available for all CAN controllers, in which case E_ NOT_ OK would be returned. Please note that the value of the counter might not be correct at the moment the API returns it, because the Tx counter is handled asynchronously in hardware. Applications should not trust this value for any assumption about the current bus state.

Std_ReturnType Can_GetControllerTxErrorCounter (uint8 ControllerId, uint8* TxErrorCounterPtr);

Can_GetVersionInfo function

This function returns the version information of this module.

void Can_GetVersionInfo (Std_VersionInfoType* versioninfo);

Can_Init function

This function initializes the module.

void Can_Init (const Can_ConfigType* Config);

Can_MainFunction_BusOff function

This function performs the polling of bus - off events that are configured statically as 'to be polled'.

void Can_MainFunction_BusOff (void);

Can_MainFunction_Mode function

This function performs the polling of CAN controller mode transitions.

void Can_MainFunction_Mode (void);

Can_MainFunction_Read function

This function performs the polling of RX indications when CAN_ RX_ PROCESSING is set to POLLING.

void Can_MainFunction_Read (void);

Can_MainFunction_Wakeup function

This function performs the polling of wake - up events that are configured statically as 'to be polled'.

void Can_MainFunction_Wakeup (void);

Can_MainFunction_Write function

This function performs the polling of TX confirmation when CAN_ TX_ PROCESSING is set to POLLING.

void Can_MainFunction_Write (void);

Can_SetBaudrate function

This service shall set the baud rate configuration of the CAN controller. Depending on necessary baud rate modifications the controller might have to reset.

Std_ReturnType Can_SetBaudrate (uint8 Controller, uint16 BaudRateConfig ID); ⚠️

Can_SetControllerMode function

This function performs software triggered state transitions of the CAN controller State machine.

Std_ReturnType Can_SetControllerMode (uint8 Controller, Can_ControllerStateType Transition);

Can_Write function

This function is called by Can If to pass a CAN message to Can Drv for transmission.

Std_ReturnType Can_Write (Can_HwHandleType Hth, const Can_PduType* PduInfo);

Can_ConfigType type

This is the type of the external data structure containing the overall initialization data for the CAN driver and SFR settings affecting all controllers. Furthermore it contains pointers to controller configuration structures. The contents of the initializ ation data structure are CAN hardware specific.

Can_ControllerStateType type

States that are used by the several Controller Mode functions.

Can_ErrorStateType type

Error states of a CAN controller.

Can_ErrorType type

The enumeration represents a superset of CAN Error Types which typical CAN HW is able to report. That means not all CAN HW will be able to support the complete set.

Can_HwHandleType type

Represents the hardware object handles of a CAN hardware unit. For CAN hardware units with more than 255 HW objects use extended range.

Can_HwType type

This type defines a data structure which clearly provides an Hardware Object Handle including its corresponding CAN Controller and therefore Can Drv as well as the specific Can Id.

Can_IdType type

Represents the Identifier of an L - PDU. The two most significant bits specify the frame type: 00 CAN message with Standard CAN ID 01 CAN FD frame with Standard CAN ID 10 CAN message with Extended CAN ID 11 CAN FD frame with Extended CAN ID

Can_PduType type

This type unites Pdu Id (sw Pdu Handle), Sdu Length (length), Sdu Data (sdu), and Can Id (id) for any CAN L - SDU.

CanIf

<User_CheckTrcvWakeFlagIndication> function

This service indicates that the wake up flag in the CAN transceiver is set. This function is called in CanIf_CheckTrcvWakeFlagIndication.

void <User_CheckTrcvWakeFlagIndication> (uint8 TransceiverId);

<User_ClearTrcvWufFlagIndication> function

This service indicates that the CAN transceiver has cleared the WufFlag. This function is called in CanIf_ClearTrcvWufFlagIndication.

void <User_ClearTrcvWufFlagIndication> (uint8 TransceiverId);

<User_ConfirmPnAvailability> function

This service indicates that the CAN transceiver is running in PN communication mode.

void <User_ConfirmPnAvailability> (uint8 TransceiverId);

<User_ControllerBusOff> function

This service indicates a bus-off event to the corresponding upper layer module (mainly the CAN State Manager module).

void <User_ControllerBusOff> (uint8 ControllerId);

<User_ControllerModeIndication> function

This service indicates a CAN controller state transition to the corresponding upper layer module (mainly the CAN State Manager module).

void <User_ControllerModeIndication> (uint8 ControllerId, Can_ControllerStateType ControllerMode);

<User_RxIndication> function

Indication of a received PDU from a lower layer communication interface module.

void <User_RxIndication> (PduIdType RxPduId, const PduInfoType* PduInfoPtr);

<User_TrcvModeIndication> function

This service indicates a CAN transceiver state transition to the corresponding upper layer module (mainly the CAN State Manager module).

void <User_TrcvModeIndication> (uint8 TransceiverId, CanTrcv_TrcvModeType TransceiverMode);

<User_TriggerTransmit> function

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 <User_TriggerTransmit> (PduIdType TxPduId, PduInfoType* PduInfoPtr);

<User_TxConfirmation> function

The lower layer communication interface module confirms the transmission of a PDU, or the failure to transmit a PDU.

void <User_TxConfirmation> (PduIdType TxPduId, Std_ReturnType result);

<User_ValidateWakeupEvent> function

This service indicates if a wake up event initiated from the wake up source (CAN controller or transceiver) after a former request to the CAN Driver or CAN Transceiver Driver module is valid.

void <User_ValidateWakeupEvent> (EcuM_WakeupSourceType sources);

CanIf_CheckTrcvWakeFlag function

Requests the CanIf module to check the Wake flag of the designated CAN transceiver.

Std_ReturnType CanIf_CheckTrcvWakeFlag (uint8 TransceiverId);

CanIf_CheckTrcvWakeFlagIndication function

This service indicates that the check of the transceiver's wake-up flag has been finished by the corresponding CAN transceiver with the abstract CanIf TransceiverId. This indication is used to cope with the asynchronous transceiver communication.

void CanIf_CheckTrcvWakeFlagIndication (uint8 TransceiverId);

CanIf_CheckValidation function

This service is performed to validate a previous wakeup event.

Std_ReturnType CanIf_CheckValidation (EcuM_WakeupSourceType WakeupSource);

CanIf_CheckWakeup function

This service checks, whether an underlying CAN driver or a CAN transceiver driver already signals a wakeup event.

Std_ReturnType CanIf_CheckWakeup (EcuM_WakeupSourceType WakeupSource);

CanIf_ClearTrcvWufFlag function

Requests the CanIf module to clear the WUF flag of the designated CAN transceiver.

Std_ReturnType CanIf_ClearTrcvWufFlag (uint8 TransceiverId);

CanIf_ClearTrcvWufFlagIndication function

This service indicates that the transceiver has cleared the WufFlag referring to the corresponding CAN transceiver with the abstract CanIf TransceiverId.

void CanIf_ClearTrcvWufFlagIndication (uint8 TransceiverId);

CanIf_ConfirmPnAvailability function

This service indicates that the transceiver is running in PN communication mode referring to the corresponding CAN transceiver with the abstract CanIf TransceiverId.

void CanIf_ConfirmPnAvailability (uint8 TransceiverId);

CanIf_ControllerBusOff function

This service indicates a Controller BusOff event referring to the corresponding CAN Controller with the abstract CanIf ControllerId.

void CanIf_ControllerBusOff (uint8 ControllerId);

CanIf_ControllerErrorStatePassive function

The function derives the ErrorCounterTreshold from RxErrorCounter/ TxErrorCounter values and reports it to the IdsM as security event CANIF_SEV_ERRORSTATE_PASSIVE to the IdsM. It also prepares the context data for the respective security event.

void CanIf_ControllerErrorStatePassive (uint8 ControllerId, uint16 RxErrorCounter, uint16 TxErrorCounter);

CanIf_ControllerModeIndication function

This service indicates a controller state transition referring to the corresponding CAN controller with the abstract CanIf ControllerId.

void CanIf_ControllerModeIndication (uint8 ControllerId, Can_ControllerStateType ControllerMode);

CanIf_DeInit function

De-initializes the CanIf module.

void CanIf_DeInit (void);

CanIf_EnableBusMirroring function

Enables or disables mirroring for a CAN controller.

Std_ReturnType CanIf_EnableBusMirroring (uint8 ControllerId, boolean MirroringActive);

CanIf_ErrorNotification function

The function shall derive the bus error source rx or tx from the parameter CanError and report the bus error as security event CANIF_SEV_TX_ERROR_DETECTED or CANIF_SEV_RX_ ERROR_DETECTED. It also prepares the context data for the respective security event.

void CanIf_ErrorNotification (uint8 ControllerId, Can_ErrorType Can_ErrorType);

CanIf_GetControllerErrorState function

This service calls the corresponding CAN Driver service for obtaining the error state of the CAN controller.

Std_ReturnType CanIf_GetControllerErrorState (uint8 ControllerId, Can_ErrorStateType* ErrorStatePtr);

CanIf_GetControllerMode function

This service calls the corresponding CAN Driver service for obtaining the current status of the CAN controller.

Std_ReturnType CanIf_GetControllerMode (uint8 ControllerId, Can_ControllerStateType* ControllerModePtr);

CanIf_GetControllerRxErrorCounter function

This service calls the corresponding CAN Driver service for obtaining the Rx error counter of the CAN controller.

Std_ReturnType CanIf_GetControllerRxErrorCounter (uint8 ControllerId, uint8* RxErrorCounterPtr);

CanIf_GetControllerTxErrorCounter function

This service calls the corresponding CAN Driver service for obtaining the Tx error counter of the CAN controller.

Std_ReturnType CanIf_GetControllerTxErrorCounter (uint8 ControllerId, uint8* TxErrorCounterPtr);

CanIf_GetPduMode function

This service reports the current mode of a requested PDU channel.

Std_ReturnType CanIf_GetPduMode (uint8 ControllerId, CanIf_PduModeType* PduModePtr);

CanIf_GetTrcvMode function

This function invokes CanTrcv_GetOpMode and updates the parameter TransceiverModePtr with the value OpMode provided by CanTrcv.

Std_ReturnType CanIf_GetTrcvMode (uint8 TransceiverId, CanTrcv_TrcvModeType* TransceiverModePtr);

CanIf_GetTrcvWakeupReason function

This service returns the reason for the wake up of the transceiver TransceiverId, via calling the corresponding CAN Transceiver Driver service.

Std_ReturnType CanIf_GetTrcvWakeupReason (uint8 TransceiverId, CanTrcv_TrcvWakeupReasonType* TrcvWuReasonPtr);

CanIf_GetTxConfirmationState function

This service reports, if any TX confirmation has been done for the whole CAN controller since the last CAN controller start.

CanIf_NotifStatusType CanIf_GetTxConfirmationState (uint8 ControllerId);

CanIf_GetVersionInfo function

This service returns the version information of the called CAN Interface module.

void CanIf_GetVersionInfo (Std_VersionInfoType* VersionInfo);

CanIf_Init function

This service Initializes internal and external interfaces of the CAN Interface for the further processing.

void CanIf_Init (const CanIf_ConfigType* ConfigPtr);

CanIf_ReadRxNotifStatus function

This service returns the indication status (indication occurred or not) of a specific CAN Rx L-PDU, requested by the CanIfRxSduId.

CanIf_NotifStatusType CanIf_ReadRxNotifStatus (PduIdType CanIfRxSduId);

CanIf_ReadRxPduData function

This service provides the Data Length and the received data of the requested CanIfRxSduId to the calling upper layer.

Std_ReturnType CanIf_ReadRxPduData (PduIdType CanIfRxSduId, PduInfoType* CanIfRxInfoPtr);

CanIf_ReadTxNotifStatus function

This service returns the confirmation status (confirmation occurred or not) of a specific static or dynamic CAN Tx L-PDU, requested by the CanIfTxSduId.

CanIf_NotifStatusType CanIf_ReadTxNotifStatus (PduIdType CanIfTxSduId);

CanIf_RxIndication function

This service indicates a successful reception of a received CAN Rx L-PDU to the CanIf after passing all filters and validation checks.

void CanIf_RxIndication (const Can_HwType* Mailbox, const PduInfoType* PduInfoPtr);

CanIf_SetBaudrate function

This service shall set the baud rate configuration of the CAN controller. Depending on necessary baud rate modifications the controller might have to reset.

Std_ReturnType CanIf_SetBaudrate (uint8 ControllerId, uint16 BaudRateConfigID);

CanIf_SetControllerMode function

This service calls the corresponding CAN Driver service for changing of the CAN controller mode.

Std_ReturnType CanIf_SetControllerMode (uint8 ControllerId, Can_ControllerStateType ControllerMode);

CanIf_SetDynamicTxId function

This service reconfigures the corresponding CAN identifier of the requested CAN L-PDU.

void CanIf_SetDynamicTxId (PduIdType CanIfTxSduId, Can_IdType CanId);

CanIf_SetPduMode function

This service sets the requested mode at the L-PDUs of a predefined logical PDU channel.

Std_ReturnType CanIf_SetPduMode (uint8 ControllerId, CanIf_PduModeType PduModeRequest);

CanIf_SetTrcvMode function

This service changes the operation mode of the tansceiver TransceiverId, via calling the corresponding CAN Transceiver Driver service.

Std_ReturnType CanIf_SetTrcvMode (uint8 TransceiverId, CanTrcv_TrcvModeType TransceiverMode);

CanIf_SetTrcvWakeupMode function

This function shall call CanTrcv_SetTrcvWakeupMode.

Std_ReturnType CanIf_SetTrcvWakeupMode (uint8 TransceiverId, CanTrcv_TrcvWakeupModeType TrcvWakeupMode);

CanIf_Transmit function

Requests transmission of a PDU.

Std_ReturnType CanIf_Transmit (PduIdType TxPduId, const PduInfoType* PduInfoPtr);

CanIf_TrcvModeIndication function

This service indicates a transceiver state transition referring to the corresponding CAN transceiver with the abstract CanIf TransceiverId.

void CanIf_TrcvModeIndication (uint8 TransceiverId, CanTrcv_TrcvModeType TransceiverMode);

CanIf_TriggerTransmit function

Std_ReturnType CanIf_TriggerTransmit (PduIdType TxPduId, PduInfoType* PduInfoPtr);

CanIf_TxConfirmation function

This service confirms a previously successfully processed transmission of a CAN TxPDU.

void CanIf_TxConfirmation (PduIdType CanTxPduId);

CanIf_ConfigType type

This type defines a data structure for the post build parameters of the CAN interface for all underlying CAN drivers. At initialization the CanIf gets a pointer to a structure of this type to get access to its configuration data, which is necessary for initialization.

CanIf_NotifStatusType type

Type CanIf_NotifStatusType.

CanIf_PduModeType type

The PduMode of a channel defines its transmit or receive activity. Communication direction (transmission and/or reception) of the channel can be controlled separately or together by upper layers.

CanNm

CanNm_ActivateTxPnShutdownMsg function

NM indicate to activate the transmission of PN shutdown messages on the given NM - Channel. This results in transmission of a NM - PD U with PNSR bit set to 1 (PN shutdown message).

Std_ReturnType CanNm_ActivateTxPnShutdownMsg(NetworkHandleType nmChannelHandle);

CanNm_CheckRemoteSleepIndication function

Check if remote sleep indication takes place or not.

Std_ReturnType CanNm_CheckRemoteSleepIndication(NetworkHandleType nmChannelHandle, boolean* nmRemoteSleepIndPtr);

CanNm_ConfirmPnAvailability function

Enables the PN filter functionality on the indicated NM channel. Availability: The API is only available if Can Nm Global Pn Support is TRUE.

void CanNm_ConfirmPnAvailability(NetworkHandleType nmChannelHandle);

CanNm_DeactivateTxPnShutdownMsg function

NM indicate to deactive the transmission of PN shutdown messages on the given NM - Channel. This result in transmission of a usual NM - PDUs with PNSR bit set to 0.

Std_ReturnType CanNm_DeactivateTxPnShutdownMsg(NetworkHandleType nmChannelHandle);

CanNm_DeInit function

De - initializes the Can Nm module.

void CanNm_DeInit(void);

CanNm_DisableCommunication function

Disable the NM PDU transmission ability due to a ISO14229 Communication Control (28hex) service

Std_ReturnType CanNm_DisableCommunication(NetworkHandleType nmChannelHandle);

CanNm_EnableCommunication function

Enable the NM PDU transmission ability due to a ISO14229 Communication Control (28hex) service

Std_ReturnType CanNm_EnableCommunication(NetworkHandleType nmChannelHandle);

CanNm_GetLocalNodeIdentifier function

Get node identifier configured for the local node.

Std_ReturnType CanNm_GetLocalNodeIdentifier(NetworkHandleType nmChannelHandle, uint8* nmNodeIdPtr);

CanNm_GetNodeIdentifier function

Get node identifier out of the most recently received N M PDU.

Std_ReturnType CanNm_GetNodeIdentifier(NetworkHandleType nmChannelHandle, uint8* nmNodeIdPtr);

CanNm_GetPduData function

Get the whole PDU data out of the most recently received NM PDU.

Std_ReturnType CanNm_GetPduData(NetworkHandleType nmChannelHandle, uint8* nmPduDataPtr);

CanNm_GetState function

Returns the state and the mode of the network management.

Std_ReturnType CanNm_GetState(NetworkHandleType nmChannelHandle, Nm_StateType* nmStatePtr, Nm_ModeType* nmModePtr);

CanNm_GetUserData function

Get user data out of the most recently received NM PDU.

Std_ReturnType CanNm_GetUserData(NetworkHandleType nmChannelHandle, uint8* nmUserDataPtr);

CanNm_GetVersionInfo function

This service returns the version information of this module.

void CanNm_GetVersionInfo(Std_VersionInfoType* versioninfo);

CanNm_Init function

Initialize the Can Nm module.

void CanNm_Init(const CanNm_ConfigType* cannmConfigPtr);

CanNm_MainFunction function

Main function of the Can Nm which processes the algorithm describes in that document.

void CanNm_MainFunction(void);

CanNm_NetworkRelease function

Release the network, since ECU doesn't have to communicate on the bus.

Std_ReturnType CanNm_NetworkRelease(NetworkHandleType nmChannelHandle);

CanNm_NetworkRequest function

Request the network, since ECU needs to communicate on the bus.

Std_ReturnType CanNm_NetworkRequest(NetworkHandleType nmChannelHandle);

CanNm_PassiveStartUp function

Passive startup of the AUTOSAR CAN NM. It triggers the transition from Bus - Sleep Mode or Prepare Bus Sleep Mode to the Network Mode in Repeat Message State. Caveats: Can Nm is initia lized correctly.

Std_ReturnType CanNm_PassiveStartUp(NetworkHandleType nmChannelHandle);

CanNm_PnLearningRequest function

Set Repeat Message Request Bit and Partial Network Learning Bit for NM messages transmitted next on the bus. This will force all nodes to enter the PNC Learning Phase. This is needed for the optional Dynamic PNC - to - channel - mapping feature.

Std_ReturnType CanNm_PnLearningRequest(NetworkHandleType nmChannelHandle);

CanNm_RepeatMessageRequest function

Set Repeat Message Request Bit for NM PDUs transmitted next on the bus.

Std_ReturnType CanNm_RepeatMessageRequest(NetworkHandleType nmChannelHandle);

CanNm_RequestBusSynchronization function

Request bus synchronization.

Std_ReturnType CanNm_RequestBusSynchronization(NetworkHandleType nmChannelHandle);

CanNm_RequestSynchronizedPncShutdown function

Requests transmission of a NM - PDU with PNSR bit set to 1 (PN shutdown message) Tags: atp.Status=draft

Std_ReturnType CanNm_RequestSynchronizedPncShutdown(NetworkHandleType nmChannelHandle, PNCHandleType pncId);

CanNm_RxIndication function

Indication of a receive d PDU from a lower layer communication interface module.

void CanNm_RxIndication(PduIdType RxPduId, const PduInfoType* PduInfoPtr);

CanNm_SetSleepReadyBit function

Set the NM Coordinator S leep Ready bit in the Control Bit Vector

Std_ReturnType CanNm_SetSleepReadyBit(NetworkHandleType nmChannelHandle, boolean nmSleepReadyBit);

CanNm_SetUserData function

Set user data for NM PDUs transmitted next on the bus.

Std_ReturnType CanNm_SetUserData(NetworkHandleType nmChannelHandle, const uint8* nmUserDataPtr);

CanNm_Transmit function

Requests transmission of a PDU.

Std_ReturnType CanNm_Transmit(PduIdType TxPduId, const PduInfoType* PduInfoPtr);

CanNm_TriggerTransmit function

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 CanNm_TriggerTransmit(PduIdType TxPduId, PduInfoType* PduInfoPtr);

CanNm_TxConfirmation function

The lower layer communication interface module confirms the transmission of a PDU, or the failure to transmit a PDU.

void CanNm_TxConfirmation(PduIdType TxPduId, Std_ReturnType result);

CanNm_ConfigType type

This type shall contain at least all parameters that are post - build able according to chapter 10.

CanSM

<User_Get Bus Off Delay> function

This callout function returns the number of Can SM base cycles to wait additionally to L1/ L2 after a Bus Off occurred.

void <User_Get Bus Off Delay>(NetworkHandleType network, uint8* delayCyclesPtr);

CanSM_CheckTransceiverWakeFlagIndication function

This callback function indicates the Can If_ Check Trcv Wake Flag API process end for the notified CAN Transceiver.

void CanSM_CheckTransceiverWakeFlagIndication(uint8 Transceiver);

CanSM_ClearTrcvWufFlagIndication function

This callback function shall indicate the Can If_ Clear Trcv Wuf Flag API process end for the notified CAN Transceiver.

void CanSM_ClearTrcvWufFlagIndication(uint8 Transceiver);

CanSM_ConfirmCtrlPnAvailability function

This callback function indicates that the controller is running in PN communication mode. Tags: atp.Status=draft

void CanSM_ConfirmCtrlPnAvailability(uint8 ControllerId);

CanSM_ConfirmPnAvailability function

This callback function indicates that the transceiver is running in PN communication mode.

void CanSM_ConfirmPnAvailability(uint8 TransceiverId);

CanSM_ControllerBusOff function

This callback function notifies the Can SM about a bus - off event on a certain CAN controller, which needs to be considered with the specified bus - off recovery handling for th e impacted CAN network.

void CanSM_ControllerBusOff(uint8 ControllerId);

CanSM_ControllerModeIndication function

This callback shall notify the Can SM module about a CAN controller mode change.

void CanSM_ControllerModeIndication(uint8 ControllerId, Can_ControllerStateType ControllerMode);

CanSM_CurrentIcomConfiguration function

This service shall inform about the change of the Icom Configuration of a CAN network.

void CanSM_CurrentIcomConfiguration(uint8 ControllerId, IcomConfigIdType ConfigurationId, IcomSwitch_ErrorType Error);

CanSM_DeInit function

This service de - initializes the Can SM module.

void CanSM_DeInit(void);

CanSM_GetCurrentComMode function

This service shall put out the current communication mode of a CAN network.

Std_ReturnType CanSM_GetCurrentComMode(NetworkHandleType network, ComM_ModeType* ComM_ModePtr);

CanSM_GetVersionInfo function

This service puts out the version information of this module (module ID, vendor ID, vendor specific version numbers related to BSW00407)

void CanSM_GetVersionInfo(Std_VersionInfoType* VersionInfo);

CanSM_Init function

This service initializes the Can SM module

void CanSM_Init(const CanSM_ConfigType* ConfigPtr);

CanSM_MainFunction function

Scheduled function of the Can SM

void CanSM_MainFunction(void);

CanSM_RequestComMode function

This service shall change the communication mode of a CAN network to the requested one.

Std_ReturnType CanSM_RequestComMode(NetworkHandleType network, ComM_ModeType ComM_Mode);

CanSM_SetBaudrate function

This service shall start an asynchronous process to change the baud rate for the configured CAN controllers of a certain CAN network. Depending on necessary baud rate modifications the controllers might have to reset.

Std_ReturnType CanSM_SetBaudrate(NetworkHandleType Network, uint16 BaudRateConfig ID); ⚠️

CanSM_SetEcuPassive function

Service Name Can SM_ Set Ecu Passive Syntax Std_ Return Type Can SM_ Set Ecu Passive ( boolean Can SM_ Passive ) Service ID [hex] 0x13 Sync/ Async Synchronous Reentrancy Non Reentrant Parameters (in) Can SM_ Passive TRUE: set all Can SM channels to passive, i.e. receive only FALSE: set all Can SM channels back to non - passive Parameters (inout) None Parameters (out) None Return value Std _ Return - E_ OK: Request accepted Type E_ NOT_ OK: Request not accepted Descr iption This function can be used to set all Can SM channels of the ECU to a receive only mode. Available via Can SM.h

Std_ReturnType CanSM_SetEcuPassive(boolean CanSM_Passive);

CanSM_SetIcomConfiguration function

This service shall change the Icom Configuration of a CAN network to the requested one.

Std_ReturnType CanSM_SetIcomConfiguration(NetworkHandleType Network, IcomConfigIdType ConfigurationId);

CanSM_StartWakeupSource function

This function shall be called by Ecu M when a wakeup source shall be started.

Std_ReturnType CanSM_StartWakeupSource(NetworkHandleType network);

CanSM_StopWakeupSource function

This function shall be called by Ecu M when a wakeup source shall be stopped.

Std_ReturnType CanSM_StopWakeupSource(NetworkHandleType network);

CanSM_TransceiverModeIndication function

This callback shall notify the Can SM module about a CAN transceiver mode change.

void CanSM_TransceiverModeIndication(uint8 TransceiverId, CanTrcv_TrcvModeType TransceiverMode);

CanSM_TxTimeoutException function

This function shall notify the Can SM module, that the Can Nm has detected for the affected partial CAN network a tx timeout exception, which shall be recovered within the respective network state machine of the Can SM module.

void CanSM_TxTimeoutException(NetworkHandleType Channel);

CanSM_BswMCurrentStateType type

Can specific communication modes / states notified to the Bsw M module

CanSM_ConfigType type

This type defines a data structure for the post build parameters of the Can SM. At initialization the Can SM gets a pointer to a structure of this type to get access to its configuration data, which is neces sary for initialization. Available Can SM.h via

CanSM_StateType type

Defines the values of the internal states of the Can SM module

CanTp

CanTp_CancelReceive function

Requests cancellation of an ongoing reception of a PDU in a lower layer transport protocol module.

Std_ReturnType CanTp_CancelReceive (PduIdType RxPduId);

CanTp_CancelTransmit function

Requests cancellation of an ongoing transmission of a PDU in a lower layer communication module.

Std_ReturnType CanTp_CancelTransmit (PduIdType TxPduId);

CanTp_ChangeParameter function

Request to change a specific transport protocol parameter (e.g. block size).

Std_ReturnType CanTp_ChangeParameter (PduIdType id, TPParameterType parameter, uint16 value);

CanTp_GetVersionInfo function

This function returns the version information of the Can Tp module.

void CanTp_GetVersionInfo (Std_VersionInfoType* versioninfo);

CanTp_Init function

This function initializes the Can Tp module.

void CanTp_Init (const CanTp_ConfigType* CfgPtr);

CanTp_MainFunction function

The main function for scheduling the CAN TP.

void CanTp_MainFunction (void);

CanTp_ReadParameter function

This service is used to read the current value of reception parameters BS and STmin for a specified N - SDU.

Std_ReturnType CanTp_ReadParameter (PduIdType id, TPParameterType parameter, uint16* value);

CanTp_RxIndication function

Indication of a received PDU from a lower layer communication interface module.

void CanTp_RxIndication (PduIdType RxPduId, const PduInfoType* PduInfoPtr);

CanTp_Shutdown function

This function is called to shutdown the Can Tp module.

void CanTp_Shutdown (void);

CanTp_Transmit function

Requests transmission of a PDU.

Std_ReturnType CanTp_Transmit (PduIdType TxPduId, const PduInfoType* PduInfoPtr);

CanTp_TxConfirmation function

The lower layer communication interface module confirms the transmission of a PDU, or the failure to transmit a PDU.

void CanTp_TxConfirmation (PduIdType TxPduId, Std_ReturnType result);

CanTp_ConfigType type

Data structure type for the post - build configuration parameters.

CanTrcv

CanTrcv_CheckWakeFlag function

Requests to check the status of the wakeup flag from the transceiver hardware.

Std_ReturnType CanTrcv_CheckWakeFlag (uint8 Transceiver);

CanTrcv_CheckWakeup function

Service is called by underlying CANIF in case a wake up interrupt is detected.

Std_ReturnType CanTrcv_CheckWakeup (uint8 Transceiver);

CanTrcv_ClearTrcvTimeoutFlag function

Clears the status of the timeout flag in the transceiver hardware. This API shall exist only if Can Trcv Hw Pn Support = TRUE.

Std_ReturnType CanTrcv_ClearTrcvTimeoutFlag (uint8 Transceiver);

CanTrcv_ClearTrcvWufFlag function

Clears the WUF flag in the transceiver hardware. This API shall exist only if Can Trcv Hw Pn Support = TRUE.

Std_ReturnType CanTrcv_ClearTrcvWufFlag (uint8 Transceiver);

CanTrcv_DeInit function

De - initializes the Can Trcv module.

void CanTrcv_DeInit (void);

CanTrcv_GetBusWuReason function

Gets the wakeup reason for the Transceiver and returns it in parameter Reason.

Std_ReturnType CanTrcv_GetBusWuReason (uint8 Transceiver, CanTrcv_TrcvWakeupReasonType* reason);

CanTrcv_GetOpMode function

Gets the mode of the Transceiver and returns it in Op Mode.

Std_ReturnType CanTrcv_GetOpMode (uint8 Transceiver, CanTrcv_TrcvModeType* OpMode);

CanTrcv_GetTrcvSystemData function

Reads the transceiver configuration/ status data and returns it through parameter Trcv Sys Data. This API shall exist only if Can Trcv Hw Pn Support = TRUE.

Std_ReturnType CanTrcv_GetTrcvSystemData (uint8 Transceiver, uint32* TrcvSysData);

CanTrcv_GetVersionInfo function

Gets the version of the module and returns it in Version Info.

void CanTrcv_GetVersionInfo (Std_VersionInfoType* versioninfo);

CanTrcv_Init function

Initializes the Can Trcv module.

void CanTrcv_Init (const CanTrcv_ConfigType* ConfigPtr);

CanTrcv_MainFunction function

Service to scan all busses for wake up events and perform these event.

void CanTrcv_MainFunction (void);

CanTrcv_MainFunctionDiagnostics function

Reads the transceiver diagnostic status periodically and sets product/ development accordingly.

void CanTrcv_MainFunctionDiagnostics (void);

CanTrcv_ReadTrcvSilenceFlag function

Reads the status of the silence flag from the transceiver hardware. This API shall exi st only if Can Trcv Hw Pn Support = TRUE.

Std_ReturnType CanTrcv_ReadTrcvSilenceFlag (uint8 Transceiver, CanTrcv_TrcvFlagStateType* FlagState);

CanTrcv_ReadTrcvTimeoutFlag function

Reads the status of the tim eout flag from the transceiver hardware. This API shall exist only if Can Trcv Hw Pn Support = TRUE.

Std_ReturnType CanTrcv_ReadTrcvTimeoutFlag (uint8 Transceiver, CanTrcv_TrcvFlagStateType* FlagState);

CanTrcv_SetOpMode function

Sets the mode of the Transceiver to the value Op Mode.

Std_ReturnType CanTrcv_SetOpMode (uint8 Transceiver, CanTrcv_TrcvModeType OpMode);

CanTrcv_SetPNActivationState function

The API configures the wake - up of the transceiver for Standby and Sleep Mode: Either the CAN transceiver is woken up by a remote wake - up pattern (standard CAN wake - up) or by the configured remote wake - up frame.

Std_ReturnType CanTrcv_SetPNActivationState (CanTrcv_PNActivationType ActivationState);

CanTrcv_SetWakeupMode function

En ables, disables or clears wake - up events of the Transceiver according to Trcv Wakeup Mode.

Std_ReturnType CanTrcv_SetWakeupMode (uint8 Transceiver, CanTrcv_TrcvWakeupModeType TrcvWakeupMode);

CanTrcv_ConfigType type

This is the type of the external data structure containing the overall initialization data for the CAN transceiver driver and settings affecting all transceivers. Furthermore it contains pointers to transceiver configuration structures. The con tents of the initialization data structure are CAN transceiver hardware specific.

CanTrcv_PNActivationType type

Datatype used for describing whether PN wakeup functionality in Can Trcv is enabled or disabled.

CanTrcv_TrcvFlagStateType type

Provides the state of a flag in the transceiver hardware.

CanTrcv_TrcvModeType type

Operating modes of the CAN Transceiver Driver.

CanTrcv_TrcvWakeupModeType type

This type shall be used to control the CAN transceiver concerning wake up events and wake up notifications.

CanTrcv_TrcvWakeupReasonType type

This type denotes the wake up reason detected by the CAN transceiver in detail. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CANTransceiverDriver

CanXL

CanXL_ImmediateTransmit function

Request transmission of an Ethernet frame, where each upper layer a header part as element of a single linked list. All headers together with the payload form an entire Ethernet frame Tags: atp.Status=draft

Std_ReturnType CanXL_ImmediateTransmit(uint8 CtrlIdx, Eth_BufIdxType TxHandleId, uint8 Priority, ListElemStructType* HeaderListPtr, uint8* PayloadPtr, uint16 PayloadLength);

CanXL_ReleaseRxBuffer function

Indication from the upper layer to release the reception buffer (ingress queue element) of the given physical Ethernet controller. Tags: atp.Status=draft

void CanXL_ReleaseRxBuffer(uint8 CtrlIdx, Eth_BufIdxType RxHandleId);

Ttcan

Can_TTAckTimeMark function

Acknowledges the time mark interrupt by resetting the flag in the interrupt vector register.

void Can_TTAckTimeMark(uint8 Controller);

Can_TTCancelTimeMark function

Cancels the time mark.

void Can_TTCancelTimeMark(uint8 Controller);

Can_TTDisableTimeMarkIRQ function

Disables the time mark interrupt.

void Can_TTDisableTimeMarkIRQ(uint8 Controller);

Can_TTEnableTimeMarkIRQ function

Enables the time mark interrupt.

void Can_TTEnableTimeMarkIRQ(uint8 Controller);

Can_TTGetControllerTime function

Gets the current values for the global, local and cycle time and the cycle count of the controller

void Can_TTGetControllerTime(uint8 Controller, Can_TTTimeType* Can_TTGlobalTime, Can_TTTimeType* Can_TTLocalTime, Can_TTTimeType* Can_TTCycleTime, uint8* Can_TTCycleCount);

Can_TTGetErrorLevel function

Gets the error level. This includes the severity of the error level (S0-S3) and the minimum and maximum value of the message status count.

void Can_TTGetErrorLevel(uint8 Controller, Can_TTErrorLevelType* Can_TTErrorLevel);

Can_TTGetMasterState function

Gets the master state. The master state includes the sync mode (sync_off, synchronizing, in_ gap, in_schedule) the master-slave mode (master_off, slave, backup_master, current_master) and the current value for ref trigger offset.

void Can_TTGetMasterState(uint8 Controller, Can_TTMasterStateType* Can_TTMasterState);

Can_TTGetNTUActual function

Gets the actual value of NTU (network time unit). Together with the local oscillator period, the actual value of NTU can be derived from the actual value of TUR.

void Can_TTGetNTUActual(uint8 Controller, Can_TTTURType* Can_TTTURAct);

Can_TTGetSyncQuality function

Gets the synchronization quality.

void Can_TTGetSyncQuality(uint8 Controller, boolean* Can_TTClockSpeed, boolean* Can_TTGlobalTimePhase);

Can_TTGetTimeMarkIRQStatus function

Gets the IRQ status of the time mark.

void Can_TTGetTimeMarkIRQStatus(uint8 Controller, boolean* Can_TTIRQStatus);

Can_TTGlobalTimePreset function

Sets the value of "global time preset".

void Can_TTGlobalTimePreset(uint8 Controller, Can_TTTimeType Can_TTGlobalTimePreset);

Can_TTMainFunction_IRQ function

Polls the interrupt flags specific to TTCAN

void Can_TTMainFunction_IRQ(void);

Can_TTReceive function

Reads received data from the controller by returning the pointer of the CanID, the DLC and the Data of the message in the requested HRH.

void Can_TTReceive(uint8 Controller, uint8 Hrh, Can_IdType* CanId, uint8* CanDlc, uint8* CanSduPtr);

Can_TTSetEndOfGap function

Signals the end of a gap.

void Can_TTSetEndOfGap(uint8 Controller);

Can_TTSetExtClockSyncCommand function

Adjusts the NTU (network time unit) according to the value given by "NTU adjust". Together with the local oscillator period, "TUR adjust" can be derived from "NTU adjust".

void Can_TTSetExtClockSyncCommand(uint8 Controller);

Can_TTSetNextIsGap function

Sets the "Next_is_Gap" bit.

void Can_TTSetNextIsGap(uint8 Controller);

Can_TTSetNTUAdjust function

Sets the value of "NTU adjust". Together with the local oscillator period, "TUR adjust" can be derived from "NTU adjust".

void Can_TTSetNTUAdjust(uint8 Controller, Can_TTTURType Can_TTTURAdjust);

Can_TTSetTimeCommand function

Adjusts the global time at the beginning of the next basic cycle by the amount of "global time preset"

void Can_TTSetTimeCommand(uint8 Controller);

Can_TTSetTimeMark function

Sets a new value for the time mark for the given time source.

void Can_TTSetTimeMark(uint8 Controller, Can_TTTimeType Can_TTTimeMark, Can_TTTimeSourceType Can_TTTimeSource);

Can_TTErrorLevelEnumType type

Error level (S0-S3)

Can_TTErrorLevelType type

TTCAN error level including min and max values of message status count

Can_TTMasterSlaveModeType type

Master-Slave Mode

Can_TTMasterStateType type

Master state type including sync mode, master-slave mode and current ref trigger offset

Can_TTSyncModeEnumType type

Sync mode

Can_TTTimeSourceType type

Time source

Can_TTTimeType type

16 bit value representing time values of TTCAN, e.g. cycle, local or global time

TtcanIf

<User_TriggerTransmit> (TtcanIf) function

Std_ReturnType <User_TriggerTransmit>(PduIdType TxPduId, PduInfoType* PduInfoPtr);

CanIf_TTAckTimeMark function

Acknowledges the time mark interrupt by resetting the flag in the interrupt vector register.

Std_ReturnType CanIf_TTAckTimeMark(uint8 ControllerId);

CanIf_TTApplWatchdogError function

Reports an application watchdog error.

Std_ReturnType CanIf_TTApplWatchdogError(uint8 ControllerId);

CanIf_TTCancelTimeMark function

Cancels the time mark.

Std_ReturnType CanIf_TTCancelTimeMark(uint8 ControllerId);

CanIf_TTDisableTimeMarkIRQ function

Disables the time mark interrupt.

Std_ReturnType CanIf_TTDisableTimeMarkIRQ(uint8 ControllerId);

CanIf_TTEnableTimeMarkIRQ function

Enables the time mark interrupt.

Std_ReturnType CanIf_TTEnableTimeMarkIRQ(uint8 ControllerId);

CanIf_TTGap function

Reports the occurrence of a gap.

Std_ReturnType CanIf_TTGap(uint8 ControllerId);

CanIf_TTGetControllerTime function

Gets the current values for the global, local and cycle time and the cycle count of the controller

Std_ReturnType CanIf_TTGetControllerTime(uint8 ControllerId, CanIf_TTTimeType* CanIf_TTGlobalTime, CanIf_TTTimeType* CanIf_TTLocalTime, CanIf_TTTimeType* CanIf_TTCycleTime, uint8* CanIf_TTCycleCount);

CanIf_TTGetErrorLevel function

Gets the error level. This includes the severity of the error level (S0-S3) and the minimum and maximum value of the message status count.

Std_ReturnType CanIf_TTGetErrorLevel(uint8 ControllerId, CanIf_TTErrorLevelType* CanIf_TTErrorLevel);

CanIf_TTGetMasterState function

Std_ReturnType CanIf_TTGetMasterState(uint8 ControllerId, CanIf_TTMasterStateType* CanIf_TTMasterState);

CanIf_TTGetNTUActual function

Gets the actual value of NTU (network time unit). Together with the local oscillator period, the actual value of NTU can be derived from the actual value of TUR.

Std_ReturnType CanIf_TTGetNTUActual(uint8 ControllerId, float32 CanIf_TTNTUAct);

CanIf_TTGetSyncQuality function

Gets the synchronization quality.

Std_ReturnType CanIf_TTGetSyncQuality(uint8 ControllerId, boolean* CanIf_TTClockSpeed, boolean* CanIf_TTGlobalTimePhase);

CanIf_TTGetTimeMarkIRQStatus function

Gets the IRQ status of the time mark.

Std_ReturnType CanIf_TTGetTimeMarkIRQStatus(uint8 ControllerId, boolean* CanIf_TTIRQStatus);

CanIf_TTGlobalTimePreset function

Sets the value of "global time preset".

Std_ReturnType CanIf_TTGlobalTimePreset(uint8 ControllerId, CanIf_TTTimeType CanIf_TTGlobalTimePreset);

CanIf_TTJobListExec_Controller function

Processes the job list of the TTCAN controller <Controller>.

void CanIf_TTJobListExec_<Controller>(void);

CanIf_TTMasterStateChange function

Reports change of the master state between potential and current master.

Std_ReturnType CanIf_TTMasterStateChange(uint8 ControllerId, CanIf_TTMasterStateType CanIf_TTMasterState);

CanIf_TTSetEndOfGap function

Signals the end of a gap.

Std_ReturnType CanIf_TTSetEndOfGap(uint8 ControllerId);

CanIf_TTSetExtClockSyncCommand function

Adjusts the NTU (network time unit) according to the value given by "NTU adjust". Together with the local oscillator period, "TUR adjust" can be derived from "NTU adjust".

Std_ReturnType CanIf_TTSetExtClockSyncCommand(uint8 ControllerId);

CanIf_TTSetNextIsGap function

Sets the "Next_is_Gap" bit.

Std_ReturnType CanIf_TTSetNextIsGap(uint8 ControllerId);

CanIf_TTSetNTUAdjust function

Sets the value of "NTU adjust". Together with the local oscillator period, "TUR adjust" can be derived from "NTU adjust".

Std_ReturnType CanIf_TTSetNTUAdjust(uint8 ControllerId, float32 CanIf_TTNTUAdjust);

CanIf_TTSetTimeCommand function

Adjusts the global time at the beginning of the next basic cycle by the amount of "global time preset"

Std_ReturnType CanIf_TTSetTimeCommand(uint8 ControllerId);

CanIf_TTSetTimeMark function

Sets a new value for the time mark for the given time source.

Std_ReturnType CanIf_TTSetTimeMark(uint8 ControllerId, CanIf_TTTimeType CanIf_TTTimeMark, CanIf_TTTimeSourceType CanIf_TTTimeSource);

CanIf_TTSevereError function

Reports one of the following errors: • failed to serve appl. watchdog • config error • watch trigger reached

void CanIf_TTSevereError(uint8 ControllerId, CanIf_TTSevereErrorEnumType CanIf_TTSevereError);

CanIf_TTStartOfCycle function

Reports the start of a basic cycle.

Std_ReturnType CanIf_TTStartOfCycle(uint8 ControllerId, uint8 CanIf_TTCycleCount);

CanIf_TTTimeDisc function

Reports a time discontinuity.

Std_ReturnType CanIf_TTTimeDisc(uint8 ControllerId);

CanIf_TTTimingError function

Reports one of the following errors: • Change of error level • Tx overflow / underflow • Synchronization failed • Init watch trigger

Std_ReturnType CanIf_TTTimingError(uint8 ControllerId, CanIf_TTTimingErrorIRQType CanIf_TTTimingErrorIRQ);

CanIf_TTErrorLevelEnumType type

Error level (S0-S3)

CanIf_TTErrorLevelType type

TTCAN error level including min and max values of message status count

CanIf_TTEventEnumType type

Event that causes a Timing/Error IRQ

CanIf_TTMasterSlaveModeType type

Master-Slave Mode

CanIf_TTMasterStateType type

Master state type including sync mode, master-slave mode and current ref trigger offset

CanIf_TTSevereErrorEnumType type

Event that causes a severe error

CanIf_TTSyncModeEnumType type

Sync mode

CanIf_TTTimeSourceType type

Time source of time values in TTCAN

CanIf_TTTimeType type

16 bit value representing time values of TTCAN, e.g. cycle, local or global time

CanIf_TTTimingErrorIRQType type

Combines all events that are reported by CanIf_TTTimingError (event indication and error level)

Klicke auf einen Eintrag, um seine Bezüge zu sehen.

Cluster GuideKI-GENERIERT

Stellt Hardwaretreiber, Schnittstellenabstraktion, Segmentierung und Transceiversteuerung für CAN bereit.

KI-GENERIERT ungeprüft Modell: claude-opus-5-5 · Aufwand: high · Temperatur: nicht steuerbar · Prompt: fa3308e420a5 Herkunft Offene Fragen (2)

KI-generiertclaude-opus-5-5 · 2026-10-13

Stellt Hardwaretreiber, Schnittstellenabstraktion, Segmentierung und Transceiversteuerung für CAN bereit.

Der Cluster verbindet CAN-Treiber, CAN Interface, das Transportprotokoll nach ISO 15765-2 und den Transceiver-Treiber zum unteren Teil des CAN-Kommunikationsstacks. Obere Schichten senden über CanIf_Transmit(). CanIf bildet die L-PDUs auf Hardwareobjekte ab, puffert sie bei belegter Hardware und verteilt Empfangs- und Bestätigungsmeldungen [SWS_CANIF_00005]. CanTp segmentiert große Nachrichten und holt die Daten schrittweise über PduR [SWS_CanTp_00086]. Gesendet wird nur, wenn der Controller im Zustand CAN_CS_STARTED und der PDU-Kanal sendebereit ist; die Modi steuert CanSM über CanIf.

Der Cluster bildet den unteren Teil des CAN-Kommunikationsstacks. Can steuert Controller und Mailboxen, CanIf abstrahiert Treiber, Controller und Transceiver, CanTp segmentiert nach ISO 15765-2, und CanTrcv verwaltet die Betriebsmodi des Transceivers. CanIf greift auf Hardwarepuffer nur über Treiberdienste zu [SWS_CANIF_00023]. Für obere Schichten stellt es einheitliche Bereiche für ControllerId und TransceiverId bereit [SWS_CANIF_00653] [SWS_CANIF_00655].

Kontextdiagramm: CanIf vermittelt zwischen PduR, CanTp, CanSM und EcuM einerseits und den Treibern Can und CanTrcv andererseits. Quellen: [SWS_CANIF_00005] [SWS_CANIF_00006] [SWS_CANIF_00358]

Beim Senden ruft CanIf_Transmit() mit der passenden HTH Can_Write() auf [SWS_CANIF_00318]. Meldet der Treiber CAN_BUSY, puffert CanIf die L-PDU [SWS_CANIF_00381]. Während der Sendebestätigung sendet es den höchstpriorisierten gepufferten Eintrag nach [SWS_CANIF_00668]. Empfangene L-PDUs durchlaufen in CanIf Softwarefilter und Datenlängenprüfung, bevor CanIf sie an CanTp oder PduR weiterleitet [SWS_CANIF_00389] [SWS_CANIF_00390]. CanTp puffert keine Nutzdaten selbst, sondern holt sie über PduR_CanTpCopyTxData() bzw. übergibt sie über PduR_CanTpCopyRxData() [SWS_CanTp_00086] [SWS_CanTp_00269].

Sequenzdiagramm: direkter Versand oder Pufferung bei CAN_BUSY, gefolgt vom Nachsenden aus dem Puffer in CanIf_TxConfirmation. Quellen: [SWS_CANIF_00381] [SWS_CANIF_00183]

Can arbeitet interrupt- oder pollinggesteuert über seine MainFunctions [SWS_Can_00225] [SWS_Can_00226]. CanTp_RxIndication() muss im Interrupt-Kontext aufrufbar sein [SWS_CanTp_00235], während CanTp_MainFunction() die Protokoll-Timeouts überwacht [SWS_CanTp_00164]. CanIf schützt gemeinsame Puffer gegen präemptive Zugriffe [SWS_CANIF_00064].

Nach der Initialisierung stehen alle CanIf-Kanäle auf CANIF_OFFLINE [SWS_CANIF_00864]. CanSM schaltet die Controller über CanIf_SetControllerMode() [SWS_CANIF_00308]. SLEEP erzwingt CANIF_OFFLINE, STOPPED oder BusOff erzwingen CANIF_TX_OFFLINE [SWS_CANIF_00865] [SWS_CANIF_00866]. Einen BusOff meldet CanIf an CanSM [SWS_CANIF_00724]. Fehler gehen an DET; CanTrcv meldet zusätzlich CANTRCV_E_BUS_ERROR an DEM [SWS_CanTrcv_00206]. CanTp bricht Sitzungen bei Timeouts mit negativer Bestätigung ab [SWS_CanTp_00310].

Systemarchitektur und Rolle des Clusters

Der Cluster „CAN Communication“ bildet den unteren Teil des AUTOSAR-Kommunikationsstacks für CAN. Er reicht vom hardwarenahen CAN-Treiber bis zum Transportprotokoll, auf das PduR und DCM aufsetzen. Kern ist das CAN Interface, das obere Schichten von Treiber- und Hardwaredetails entkoppelt. Es greift auf hardwarespezifische Kommunikationspuffer ausschließlich über die Dienste des Treibers zu [SWS_CANIF_00023]. Controller und Transceiver mehrerer Treiberinstanzen abstrahiert es über eigene Bereiche für ControllerId und TransceiverId [SWS_CANIF_00653] [SWS_CANIF_00655].

Modul	Rolle im Cluster	Belege
`Can`	Zugriff auf CAN-Controller und Mailboxen, Senden über `Can_Write()`, Zustandsmaschine je Controller	[SWS_Can_00233] [SWS_Can_91013]
`CanIf`	Abbildung von L-PDUs auf HTH/HRH, Softwarefilter, Sendepuffer, Verwaltung der Modi von Controllern, PDU-Kanälen und Transceivern	[SWS_CANIF_00662] [SWS_CANIF_00137]
`CanTp`	Segmentierung und Reassemblierung nach ISO 15765-2, Flusskontrolle, mehrere parallele Verbindungen	[SWS_CanTp_00033] [SWS_CanTp_00096]
`CanTrcv`	Betriebsmodi NORMAL, STANDBY und SLEEP, Weckursachen, Diagnose des Transceivers	[SWS_CanTrcv_00102] [SWS_CanTrcv_00107]

CanIf adressiert die Hardware über zwei Arten von Handles: HTH für Sendeobjekte und HRH für Empfangsobjekte [SWS_CANIF_00291] [SWS_CANIF_00292]. Mehrere CAN-Treiber bindet CanIf über Funktionszeiger je Treiber ein [SWS_CANIF_00378]. Bei Callbacks erkennt CanIf den aufrufenden Treiber an der ControllerId in der Can_HwType-Struktur CanIf S. 68. Für jeden Transceiver-Hardwaretyp gibt es genau eine CanTrcv-Instanz [SWS_CanTrcv_00016].

Kontextdiagramm: CanIf ist die zentrale Drehscheibe zwischen den oberen Schichten (PduR, CanTp, CanSM, EcuM) und den Treibern Can und CanTrcv. Quellen: [SWS_CANIF_00005] [SWS_CANIF_00006] [SWS_CANIF_00358] [SWS_CANIF_00724] [SWS_CanTp_00216] [SWS_CanTrcv_00206]

Zusammenspiel und Interaktionspfade

Senden: Eine obere Schicht ruft CanIf_Transmit() auf [SWS_CANIF_00005]. CanIf ermittelt die HTH zur TxPduId und ruft Can_Write() mit einer Can_PduType-Struktur auf [SWS_CANIF_00318] [SWS_Can_00415]. Liefert Can_Write() E_OK, gibt auch CanIf_Transmit() E_OK zurück [SWS_CANIF_00162]. Ist kein Sendeobjekt frei, meldet der Treiber CAN_BUSY [SWS_Can_00039]. Bei aktivierter Sendepufferung legt CanIf die L-PDU dann im CanIfTxBuffer ab [SWS_CANIF_00381] [SWS_CANIF_00063] CanIf S. 138.

Sendebestätigung: Nach erfolgreichem Versand ruft Can CanIf_TxConfirmation() auf [SWS_CANIF_00007]. Dazu merkt sich der Treiber das swPduHandle aus Can_Write() Can S. 40. CanIf prüft dabei, ob für die frei gewordene HTH Einträge gepuffert sind. Den nach ISO 11898-1 höchstpriorisierten Eintrag sendet es nach und entfernt ihn sofort aus dem Puffer [SWS_CANIF_00386] [SWS_CANIF_00070] [SWS_CANIF_00668] [SWS_CANIF_00183]. Anschließend erhält die obere Schicht <User_TxConfirmation>(E_OK) [SWS_CANIF_00383].

Sequenzdiagramm: Sendeanforderung mit direktem Versand oder Pufferung bei CAN_BUSY und Nachsenden aus dem Puffer während der Sendebestätigung. Quellen: [SWS_CANIF_00318] [SWS_CANIF_00381] [SWS_CANIF_00668] [SWS_CANIF_00183] CanIf S. 157

Empfangen: Can meldet eine empfangene L-PDU über CanIf_RxIndication() [SWS_CANIF_00006]. Bei BasicCAN-HRHs führt CanIf zuerst die Softwarefilterung und danach die Datenlängenprüfung durch [SWS_CANIF_00389] [SWS_CANIF_00390] [SWS_CANIF_00663]. Danach leitet es die Indikation an den konfigurierten Empfänger weiter [SWS_CANIF_00415] [SWS_CANIF_00056], etwa an CanTp_RxIndication [SWS_CANIF_00448] oder an PduR_CanIfRxIndication [SWS_CANIF_00442].

Transportprotokoll: CanTp_Transmit() [SWS_CanTp_00212] startet eine segmentierte Übertragung, wenn die Daten nicht in eine N-PDU passen [SWS_CanTp_00232]. CanTp puffert die Nutzdaten nicht selbst, sondern holt sie für jeden SF, FF und CF über PduR_CanTpCopyTxData() [SWS_CanTp_00086] [SWS_CanTp_00298]. Die Frames übergibt es über CanIf_Transmit() [SWS_CanTp_00216]. Beim Empfang eines SF oder FF fragt CanTp mit PduR_CanTpStartOfReception() den verfügbaren Puffer ab [SWS_CanTp_00079] [SWS_CanTp_00080]. Jeden CF kopiert es mit PduR_CanTpCopyRxData() [SWS_CanTp_00269]. Reicht der Puffer für den nächsten Block nicht, sendet CanTp Flow Control WAIT [SWS_CanTp_00082] [SWS_CanTp_00325] CanTp S. 37.

Transceiver: CanIf_SetTrcvMode() reicht Moduswünsche an CanTrcv_SetOpMode() weiter [SWS_CANIF_00358]. Nach dem Wechsel ruft CanTrcv CanIf_TrcvModeIndication() auf [SWS_CanTrcv_00158], und CanIf gibt die Meldung an CanSM weiter [SWS_CANIF_00712]. Ebenso delegieren CanIf_GetTrcvWakeupReason() und CanIf_SetTrcvWakeupMode() an CanTrcv [SWS_CANIF_00368] [SWS_CANIF_00372].

Synchronisation, Reentranz und Task-Kontexte

CanIf_Transmit() ist für verschiedene PduIds reentrant, für dieselbe PduId nicht [SWS_CANIF_00005]. CanIf muss präemptive Zugriffe auf gemeinsame Ressourcen gegeneinander schützen [SWS_CANIF_00064]. Das betrifft insbesondere die Sendepuffer [SWS_CANIF_00033], die CanId dynamischer L-PDUs während CanIf_SetDynamicTxId() [SWS_CANIF_00673] und den Empfangspuffer während CanIf_ReadRxPduData() [SWS_CANIF_00199].

Can unterstützt Interrupt- und Polling-Betrieb. Die MainFunctions pollen je nach Konfiguration Sendebestätigungen, Empfang, BusOff, Wakeup und den Controllermodus [SWS_Can_00225] [SWS_Can_00226] [SWS_Can_00227] [SWS_Can_00228] [SWS_Can_00368] CanIf S. 152. Callbacks wie CanIf_ControllerBusOff() laufen daher wahlweise auf Interrupt- oder auf Task-Ebene CanIf S. 119. Can_DisableControllerInterrupts() und Can_EnableControllerInterrupts() wirken verschachtelt: Jede Sperre erfordert eine eigene Freigabe [SWS_Can_00231] [SWS_Can_00232] Can S. 61.

CanTp_RxIndication() und CanTp_TxConfirmation() müssen im Interrupt-Kontext aufrufbar sein [SWS_CanTp_00235] [SWS_CanTp_00236]. CanTp_MainFunction() bedient zyklisch die Timer N_As, N_Bs, N_Cs, N_Ar, N_Br, N_Cr und STmin [SWS_CanTp_00213] [SWS_CanTp_00164]. Ihr Takt folgt dem Parameter CanTpMainFunctionPeriod [SWS_CanTp_00300]. Interpretation: Diese Periode bestimmt vermutlich die erreichbare Auflösung der Timeouts. Frage Q-6ee587d8a8f38bff (offen) Jede Verbindung nutzt eigene Puffer, Timer und eine eigene Zustandsmaschine [SWS_CanTp_00122] CanTp S. 42. CanTrcv_MainFunction() sucht zyklisch auf Bussen in STANDBY und SLEEP nach Weckereignissen [SWS_CanTrcv_00013] [SWS_CanTrcv_00112].

Lebenszyklen und Betriebsmodi

EcuM initialisiert CanIf mit CanIf_Init() und die Treiber Can und CanTrcv jeweils separat CanIf S. 40 [SWS_Can_00223] [SWS_CanTrcv_00001]. CanTrcv_Init() versetzt jeden Transceiver je nach Konfiguration in SLEEP oder STANDBY [SWS_CanTrcv_00148]. Die von CanTrcv genutzten Treiber müssen zuvor bereit sein [SWS_CanTrcv_00099]. Nach der Initialisierung erwartet CanIf die Controller im Zustand STOPPED und schaltet alle Kanäle auf CANIF_OFFLINE [SWS_CANIF_00864]. Dienstaufrufe vor der Initialisierung lehnt CanIf ab [SWS_CANIF_00661]. Interpretation: Can und CanTrcv dürften deshalb vor CanIf zu initialisieren sein. Frage Q-4af03fca13da9a5b (offen) CanTp wechselt mit CanTp_Init() von CANTP_OFF nach CANTP_ON [SWS_CanTp_00027] [SWS_CanTp_00170]. Segmentiert wird nur im Zustand CANTP_ON [SWS_CanTp_00238] CanTp S. 27.

Moduswechsel steuert CanSM: CanIf_SetControllerMode() ruft Can_SetControllerMode() auf [SWS_CANIF_00003] [SWS_CANIF_00308]. Den Abschluss meldet Can asynchron über CanIf_ControllerModeIndication(), und CanIf reicht ihn an CanSM weiter [SWS_CANIF_00699] [SWS_CANIF_00711]. Die Controller-Zustände sind UNINIT, STOPPED, STARTED und SLEEP [SWS_Can_91013] Can S. 38. Darüber liegen die PDU-Kanalmodi von CanIf [SWS_CANIF_00137]. CanIf_SetPduMode() wird nur im Zustand CAN_CS_STARTED angenommen [SWS_CANIF_00874]. SLEEP erzwingt CANIF_OFFLINE; STOPPED oder BusOff erzwingen CANIF_TX_OFFLINE [SWS_CANIF_00865] [SWS_CANIF_00866].

Zustandsdiagramm: Die PDU-Kanalmodi von CanIf werden durch CanIf_SetPduMode und durch Wechsel des Controllermodus bestimmt. Quellen: [SWS_CANIF_00137] [SWS_CANIF_00864] [SWS_CANIF_00865] [SWS_CANIF_00866] [SWS_CANIF_00874] CanIf S. 61

Für das Wecken fragt CanIf_CheckWakeup() die Treiber über Can_CheckWakeup() bzw. CanTrcv_CheckWakeup() ab [SWS_CANIF_00395] [SWS_Can_00360] [SWS_CanTrcv_00143]. CanIf_CheckValidation() meldet ein Weckereignis an <User_ValidateWakeupEvent> nur dann, wenn seit dem Wecken ein gültiger Empfang gespeichert wurde [SWS_CANIF_00178] [SWS_CANIF_00179] [SWS_CANIF_00286] CanIf S. 102. Bei Partial Networking sperrt der PnTxFilter nach CAN_CS_SLEEP alle Sendungen außer den PN-Filter-PDUs. Erst eine Sendebestätigung oder ein Empfang hebt die Sperre auf [SWS_CANIF_00749] [SWS_CANIF_00750] [SWS_CANIF_00751] [SWS_CANIF_00896]. Vor dem Wechsel in einen Stromsparmodus löscht CanSM über CanIf_ClearTrcvWufFlag() das WUF-Flag, damit kein Frame-Wakeup verloren geht [SWS_CANIF_00766] [SWS_CanTrcv_00194] [SWS_CanTrcv_00195] CanTrcv S. 57. Die Module werden mit Can_DeInit(), CanIf_DeInit() und CanTrcv_DeInit() beendet [SWS_Can_91002] [SWS_CANIF_91002] [SWS_CanTrcv_91001].

Fehlerbehandlung, DET-Tracing und Degradation

Alle Module des Clusters melden Entwicklungsfehler an DET. CanIf tut dies etwa bei einer ungültigen TxPduId oder einem Null-Zeiger [SWS_CANIF_00319] [SWS_CANIF_00320]. CanTp liefert dabei zusätzlich E_NOT_OK zurück [SWS_CanTp_00294]; Can und CanTrcv verwenden eigene Fehlercodes [SWS_Can_91019] [SWS_CanTrcv_00050]. Laufzeitfehler betreffen unter anderem abgelehnte Datenlängen [SWS_CANIF_00168], Sendeversuche auf Kanälen im Modus CANIF_OFFLINE [SWS_CANIF_00382], verlorene Empfangsnachrichten [SWS_Can_91020] und fehlende Kommunikation mit dem Transceiver [SWS_CanTrcv_00113].

Von den betrachteten Belegen nennt nur CanTrcv einen DEM-Eintrag: CanTrcv_MainFunctionDiagnostics() setzt CANTRCV_E_BUS_ERROR je nach BUSERR-Flag auf FAILED oder PASSED [SWS_CanTrcv_00218] [SWS_CanTrcv_00206] [SWS_CanTrcv_00227] CanTrcv S. 48.

Einen BusOff meldet Can über CanIf_ControllerBusOff() [SWS_CANIF_00218]. CanIf setzt daraufhin den Kanal auf CANIF_TX_OFFLINE und informiert CanSM [SWS_CANIF_00866] [SWS_CANIF_00724] CanIf S. 147. Beim Eintritt in CAN_CS_STOPPED leert CanIf die Sendepuffer und bestätigt offene Sendungen negativ [SWS_CANIF_00485] [SWS_CANIF_00739]. Für die Recovery kann CanSM mit CanIf_GetTxConfirmationState() abfragen, ob seit dem letzten Controllerstart eine Sendebestätigung erfolgte [SWS_CANIF_00734] [SWS_CANIF_00740] CanIf S. 103. Fehlerzustand und Fehlerzähler sind über CanIf abfragbar [SWS_CANIF_91001] [SWS_Can_91003] [SWS_CANIF_91003]. Ist das Security-Event-Reporting aktiviert, meldet CanIf Busfehler sowie Error-Passive- und BusOff-Ereignisse an IdsM [SWS_CANIF_00913] [SWS_CANIF_00915] [SWS_CANIF_00917] [SWS_CANIF_00918].

Sequenzdiagramm: Die BusOff-Meldung läuft vom Controller über Can und CanIf zu CanSM; CanIf sperrt dabei den Sendepfad und setzt die Sendepuffer zurück. Quellen: [SWS_CANIF_00218] [SWS_CANIF_00724] [SWS_CANIF_00866] [SWS_CANIF_00918] [SWS_CANIF_00734] CanIf S. 147

CanTp bricht Sitzungen bei Timeouts ab und benachrichtigt die obere Schicht negativ, zum Beispiel bei N_As, N_Bs oder N_Cr [SWS_CanTp_00310] [SWS_CanTp_00316] [SWS_CanTp_00313]. Ebenso verfährt CanTp nach WFTmax aufeinanderfolgenden FC(WAIT) [SWS_CanTp_00223] oder bei einem FC mit Overflow [SWS_CanTp_00309]. Als Degradationsmodus bestätigt CanIf im Modus CANIF_TX_OFFLINE_ACTIVE Sendungen gegenüber den oberen Schichten, ohne auf den Bus zu senden [SWS_CANIF_00072].

KI-generierter Leitfaden auf Basis der AUTOSAR-Spezifikationen der Module Can, CanIf, CanTp und CanTrcv (Classic Platform R20-11). Normativ sind ausschließlich die verlinkten Requirements; als Interpretation gekennzeichnete Aussagen sind nicht durch die Quellen belegt.

AUTOSAR Classic CAN

Themenkarte

Can

CanIf

CanNm

CanSM

CanTp

CanTrcv

CanXL

Ttcan

TtcanIf

Detailansicht

Can

CanIf

CanNm

CanSM

CanTp

CanTrcv

CanXL

Ttcan

TtcanIf

Cluster GuideKI-GENERIERT

Systemarchitektur und Rolle des Clusters

Zusammenspiel und Interaktionspfade

Synchronisation, Reentranz und Task-Kontexte

Lebenszyklen und Betriebsmodi

Fehlerbehandlung, DET-Tracing und Degradation

Module im Cluster

CAN Driver (Can)

CAN Interface (CanIf)

CAN Network Management (CanNm)

CAN State Manager (CanSM)

CAN Transport Layer (CanTp)

CAN Transceiver Driver (CanTrcv)

CAN XL Driver (CanXL)

CAN XL Transceiver Driver (CanXLTrcv)

TTCAN Driver (Ttcan)

TTCAN Interface (TtcanIf)

AUTOSAR Classic CAN

Themenkarte

Detailansicht

Cluster GuideKI-GENERIERT🔍

Systemarchitektur und Rolle des Clusters

Zusammenspiel und Interaktionspfade

Synchronisation, Reentranz und Task-Kontexte

Lebenszyklen und Betriebsmodi

Fehlerbehandlung, DET-Tracing und Degradation

Module im Cluster

CAN Driver (Can)

CAN Interface (CanIf)

CAN Network Management (CanNm)

CAN State Manager (CanSM)

CAN Transport Layer (CanTp)

CAN Transceiver Driver (CanTrcv)

CAN XL Driver (CanXL)

CAN XL Transceiver Driver (CanXLTrcv)

TTCAN Driver (Ttcan)

TTCAN Interface (TtcanIf)

Cluster GuideKI-GENERIERT