/** * @file module_driver_sent.h * @author flagchip * @brief SENT driver type definition and API * @version 2.0.0 * @date 2024-08-20 * * SDK Version: 2.6.0 * * @copyright Copyright (c) 2020-2024 Flagchip Semiconductors Co., Ltd. * */ /* ******************************************************************************** * Revision History: * * Version Date Initials CR# Descriptions * --------- ---------- ------------ ---------- --------------- * 0.1.0 2023-12-15 Flagchip073 N/A First version for FC7300 * 2.0.0 2024-10-12 Flagchip073 N/A Change version and release ******************************************************************************** */ #ifndef _DRIVER_MODULE_DRIVER_SENT_H_ #define _DRIVER_MODULE_DRIVER_SENT_H_ #include "HwA_sent.h" #if SENT_INSTANCE_COUNT > 0U #if defined(__cplusplus) extern "C" { #endif /** * @addtogroup module_driver_sent * @{ */ /** * @name SENT API Service IDs * @brief Defines the service IDs for the FCUART module, which are used to identify different functions or services provided by the SENT layer. * These IDs are utilized when communicating with the SENT module, enabling calls to or responses from various functions. * * @{ */ #define SENT_INIT_ID 0U /**< link to "SENT_Init" API. */ #define SENT_SET_CHANNEL_CONFIG_ID 1U /**< link to "SENT_SetChannelConfig" API. */ #define SENT_SET_DMA_CONFIG_ID 2U /**< link to "SENT_SetDMAConfig" API. */ #define SENT_SET_SPC_CONFIG_ID 3U /**< link to "SENT_SetSPCConfig" API. */ #define SENT_GET_FAST_MSG_ID 4U /**< link to "SENT_GetFastMessageData" API. */ #define SENT_GET_SLOW_MSG_ID 5U /**< link to "SENT_GetSlowMessageData" API. */ #define SENT_DECODE_FAST_MSG_ID 6U /**< link to "SENT_DecodeFastMessageWithDMABuffer" API. */ #define SENT_DECODE_SLOW_MSG_ID 7U /**< link to "SENT_DecodeSlowMessageWithDMABuffer" API. */ #define SENT_ENABLE_FAST_MSG_NOTIFY_ID 8U /**< link to "SENT_EnableGlobalFastMsgNotification" API. */ #define SENT_DISABLE_FAST_MSG_NOTIFY_ID 9U /**< link to "SENT_DisableGlobalFastMsgNotification" API. */ #define SENT_ENABLE_SLOW_MSG_NOTIFY_ID 10U /**< link to "SENT_EnableGlobalSlowMsgNotification" API. */ #define SENT_DISABLE_SLOW_MSG_NOTIFY_ID 11U /**< link to "SENT_DisableGlobalSlowMsgNotification" API. */ #define SENT_ENABLE_FAST_FIFO_MSG_NOTIFY_ID 12U /**< link to "SENT_EnableGlobalFastFifoMsgNotification" API. */ #define SENT_DISABLE_FAST_FIFO_MSG_NOTIFY_ID 13U /**< link to "SENT_DisableGlobalFastFifoMsgNotification" API. */ #define SENT_CONFIG_CHANNEL_STATUS_NOITFY_ID 14U /**< link to "SENT_ConfigChannelStatusNotification" API. */ #define SENT_REQUEST_SPC_PULSE_ID 15U /**< link to "SENT_RequestSPCPulse" API. */ #define SENT_GET_FAST_MSG_READY_FLAG_ID 16U /**< link to "SENT_GetFastMsgReadyFlag" API. */ #define SENT_GET_SLOW_MSG_READY_FLAG_ID 17U /**< link to "SENT_GetSlowMsgReadyFlag" API. */ #define SENT_GET_CHANNEL_STATUS_ID 18U /**< link to "SENT_GetChannelStatus" API. */ #define SENT_CLEAR_CHANNEL_STATUS_ID 29U /**< link to "SENT_ClearChannelStatus" API. */ #define SENT_GET_SPC_BUSY_FLAG_ID 20U /**< link to "SENT_GetChannelSPCBusyFlag" API. */ /** @}*/ /** * @name SENT Dev Error Code * @brief Error Code of calling SENT apis * * @{ */ #define SENT_E_PARAM_POINTER 0x01U /**< The SENT pointer parameter is NULL. */ #define SENT_E_ALREADY_INIT 0x02U /**< The SENT has been initialized. */ #define SENT_E_UNINIT 0x03U /**< The SENT is not initialized. */ #define SENT_E_PARAM_INSTANCE 0x04U /**< The SENT instance number is out of range. */ #define SENT_E_PARAM_CHANNEL 0x05U /**< The SENT channel number is out of range. */ #define SENT_E_PARAM_GENERAL 0x06U /**< The SENT parameter is incorrect or out of range. */ #define SENT_E_INVALID_BRANCH 0x07U /**< The SENT API enter the incorrect branch. */ /** @}*/ /** * @name SENT buffer address and size in DMA mode * @{ */ #define SENT0_GET_FAST_MSG_DMA_ADDR(echannel) (&(SENT0->SENT_CHN[echannel].CHN_DFD)) #define SENT1_GET_FAST_MSG_DMA_ADDR(echannel) (&(SENT0->SENT_CHN[echannel].CHN_DFD)) #define SENT_GET_FAST_MSG_DMA_BYTELENGTH (12U) #define SENT0_GET_SLOW_MSG_DMA_ADDR(echannel) (&(SENT0->SENT_CHN[echannel].CHN_DSB3)) #define SENT1_GET_SLOW_MSG_DMA_ADDR(echannel) (&(SENT0->SENT_CHN[echannel].CHN_DSB3)) #define SENT_GET_SLOW_MSG_DMA_BYTELENGTH (12U) /** @}*/ /** * @brief SENT operation return values * */ typedef enum { SENT_RETURN_OK = 0x00U, /*!< The SENT operation is succeeded */ SENT_RETURN_E_NOT_OK = 0x01U, /*!< The SENT operation is failed */ SENT_RETURN_E_ALREADY_INIT = 0x02U, /*!< The SENT has been initialized. */ SENT_RETURN_E_UNINIT = 0x03U, /*!< The SENT is not initialized */ SENT_RETURN_E_PARAM = 0x04U, /*!< The SENT parameter is incorrect or out of range. */ }Sent_ReturnType; /** * @brief SENT Channel index * */ typedef enum { SENT_CHANNEL_0 = 0x00U, /*!< The SENT channel 0 */ SENT_CHANNEL_1 = 0x01U, /*!< The SENT channel 1 */ SENT_CHANNEL_2 = 0x02U, /*!< The SENT channel 2 */ SENT_CHANNEL_3 = 0x03U, /*!< The SENT channel 3 */ SENT_CHANNEL_MAX = SENT_CHANNEL_COUNT } Sent_ChannelType; /** * @brief SENT instance index * */ typedef enum { SENT_INSTANCE_0 = 0x00U, /*!< The SENT channel 0 */ SENT_INSTANCE_1 = 0x01U, /*!< The SENT channel 1 */ SENT_INSTANCE_MAX = SENT_INSTANCE_COUNT } Sent_InstanceType; /** * @brief SENT nibble data mode control. Refer to SENT SAE J2716 2010 for detail protocol definition * */ typedef enum { SENT_DATA_NIBBLE_MODE_A = 0x0U, /*!< Frame format A */ SENT_DATA_NIBBLE_MODE_H1 = 0x1U, /*!< Frame format H1 */ SENT_DATA_NIBBLE_MODE_H2 = 0x2U, /*!< Frame format H2 */ SENT_DATA_NIBBLE_MODE_H3 = 0x3U, /*!< Frame format H3 */ SENT_DATA_NIBBLE_MODE_H4 = 0x4U, /*!< Frame format H4 */ SENT_DATA_NIBBLE_MODE_H5 = 0x5U, /*!< Frame format H5 */ SENT_DATA_NIBBLE_MODE_H6 = 0x6U, /*!< Frame format H6 */ SENT_DATA_NIBBLE_MODE_H7 = 0x7U /*!< Frame format H7 */ } Sent_DataNibbleModeType; /** * @brief SENT calibration valid type * */ typedef enum { SENT_CALIBRATION_VALID_DISABLE = 0x0U, /*!< The successive calibration pulses diagnostic will be disabled */ SENT_CALIBRATION_VALID_WITHIN_20 = 0x1U, /*!< The difference of received calibration pulse and receiver configuration is within 20%, the message is deemed to be valid */ SENT_CALIBRATION_VALID_FROM_20_TO_25 = 0x2U, /*!< The difference of received calibration pulse and receiver configuration is more than 20% but less than 25%, the message is deemed to be valid */ } Sent_CalibrationValidType; /** * @brief SENT Successive calibration pulses diagnostic option * */ typedef enum { SENT_CALIBRATION_PULSE_DIAG_OPTION2 = 0x0U, /*!< Option 2 i.e. Low Latency Option as per SAE Specification */ SENT_CALIBRATION_PULSE_DIAG_OPTION1 = 0x1U, /*!< Option 1 i.e. Preferred but High Latency Option as per SAE Specification */ } Sent_CalDiagOptionType; /** * @brief Determines how long the bus idle flag will assert when SENT bus is idle * */ typedef enum { SENT_IDLE_COUNT_FLAG_DISABLE = 0x0U, /*!< The bus idle flag will never assert */ SENT_IDLE_COUNT_FLAG_254_TICKS = 0x1U, /*!< The bus is idle for more than 127*2 ticks, then the bus idle flag will assert */ SENT_IDLE_COUNT_FLAG_508_TICKS = 0x2U, /*!< The bus is idle for more than 127*2 ticks, then the bus idle flag will assert */ SENT_IDLE_COUNT_FLAG_1016_TICKS = 0x4U, /*!< The bus is idle for more than 127*2 ticks, then the bus idle flag will assert */ SENT_IDLE_COUNT_FLAG_2032_TICKS = 0x8U, /*!< The bus is idle for more than 127*2 ticks, then the bus idle flag will assert */ } Sent_IdleCountType; /** * @brief SENT Slow message type. * */ typedef enum { SENT_SERIAL_MESSAGE_SHORT = 0x0U, /*!< short serial data message */ SENT_SERIAL_MESSAGE_ENHANCE_12DATA_8ID = 0x1U, /*!< enhanced serial data message with 12-bit data and 8-bit ID */ SENT_SERIAL_MESSAGE_ENHANCE_16DATA_4ID = 0x2U, /*!< enhanced serial data message with 16-bit data and 4-bit ID */ } Sent_SerialMessageType; /** * @brief SENT trigger type in SPC mode * */ typedef enum { SENT_SPC_SOFTWARE_TRIGGER = 0x0U, /*!< SPC pulse triggered by software method */ SENT_SPC_EXTERNAL_TRIGGER = 0x1U, /*!< SPC pulse triggered by external trigger */ } Sent_SpcTriggerType; /** * @brief Select the tick base in SPC mode * */ typedef enum { SENT_SPC_TICK_BASE_PRE_MSG = 0x0U, /*!< Previous received message tick base */ SENT_SPC_TICK_BASE_CONFIGURED = 0x1U, /*!< SENT configured tick base */ } Sent_SpcTickBaseType; /** * @brief Sent global interrupt type. * */ typedef enum { SENT_SLOW_MSG_DMA_UF_IT = 0U, /*!< Slow message dma read underflow interrupt enable. */ SENT_FAST_MSG_DMA_DF_IT = 1U, /*!< Fast message dma read underflow interrupt enable. */ SENT_FAST_MSG_READY_IT = 2U, /*!< Fast message ready interrupt enable. */ SENT_SLOW_MSG_READY_IT = 3U, /*!< Slow message ready interrupt enable. */ SENT_FAST_MSG_FIFO_OF_IT = 4U, /*!< Fast message FIFO overflow interrupt enable. */ } Sent_GlobalInterruptType; /** * @brief Structure to enable or disable the channel interrupts. * */ typedef struct { bool bBusIdleITEn; /*!< Bus idle interrupt enable. */ bool bCalResyncErrITEn; /*!< Continuous 2 sync/calibration pulse difference exceed 1.5625% error interrupt enable. */ bool bCalFailITEn; /*!< Calibation 20% pass 25% fail interrupt enable. */ bool bSlowMsgOFITEn; /*!< Slow message overflow interrupt enable. */ bool bFastMsgOFITEn; /*!< Fast message overflow interrupt enable. */ bool bNibbleValueErrITEn; /*!< Nibble value more than 15 or less than 0 error interrupt enable. */ bool bPrePulseDiagErrITEn; /*!< Previous pulse diagnosis error interrupt enable. */ bool bCalDiagErrITEn; /*!< Calibration diagnosis over 25% error interrupt enable. */ bool bCalErrITEn; /*!< Sync/calibration pulse difference eceed 1.5625% error interrupt enable. */ bool bSlowMsgCrcErrITEn; /*!< Slow message CRC check error interrupt enable. */ bool bFastMsgCrcErrITEn; /*!< Fast message CRC check error interrupt enable. */ bool bFallingEdgeNumErrITEn; /*!< Falling edge number error interrupt enable. */ } Sent_ChannelInterruptType; /** * @brief Structure for fast message buffer. * */ typedef struct { uint8_t u8CRC; /*!< Receied fast message CRC data. */ uint8_t u8SC; /*!< Fast message status communication nibble value. */ uint32_t u32Timestamp; /*!< Fast message timestamp value. */ uint32_t u32Data; /*!< Received fast message data nibble. */ } Sent_FastMessageDataType; /** * @brief Structure for slow message buffer. * */ typedef struct { Sent_SerialMessageType eMsgType; /*!< Slow message type. */ uint8_t u8CRC; /*!< Slow message crc data. */ uint8_t u8ID; /*!< Slow message ID. */ uint16_t u16Data; /*!< Slow message data. */ uint32_t u32Timestamp; /*!< Slow message timestamp value. */ } Sent_SlowMessageDataType; /** * @brief SENT Global ISR callback function prototype * */ typedef void (*SENT_GBISRCallbackType)(Sent_ChannelType eChannel, const Sent_GlobalInterruptType eInterrupt); /** * @brief SENT Channel ISR callback function prototype * */ typedef void (*SENT_CHISRCallbackType)(Sent_ChannelType eChannel, const uint32_t u32ChannelStatus); /** * @brief structure to configure the SENT. * */ typedef struct { uint8_t u8PreScaler; /**< This value is used to divide the function clock to count the timestamp */ uint8_t u8DmaWaterMark; /**< When Fast message DMA request is enabled, the request will asserts if data number in FIFO is more than watermark */ bool bDebugModeEn; /**< If enable, the SENT will keep running under debug mode. */ bool bAutoClearReadyFlag; /*!< When enabled after data ready read of received data, crc and timestamp register will prevent the assert of data overflow flag. */ SENT_GBISRCallbackType pGBCallback; /**< Global interrupt callback function */ SENT_CHISRCallbackType pCHCallback; /**< Channel interrupt callback function */ } Sent_ConfigType; /** * @brief structure to configure the SENT channel. * */ typedef struct { uint8_t u8DataNibbleNumber; /*!< The received data number will be configured value plus 1, 0 and value bigger than 5 is forbidden. */ uint8_t u8DigitalFilterCount; /*!< The input signal needs keep stable for (filt_cnt<<2)* function_clk cycles to pass through the digital filter. */ uint16_t u16TickScaler; /*!< The value plus 1 is used to divide the function clock to tick clock. */ Sent_CalDiagOptionType eCalDiagOption; /*!< Successive calibration pulses diagnostic option. */ Sent_DataNibbleModeType eDataNibbleMode; /*!< Refer to SENT SAE J2716 2010 for detail protocol definition. */ Sent_CalibrationValidType eCalValid; /*!< Select valid Calibration pulse range */ Sent_IdleCountType eIdleCount; /*!< Select how long the bus idle flag will assert when bus is idle */ bool bFastMessageFifoEn; /*!< Enable Channel FIFO function. */ bool bTickCompensateEn; /*!< Enable the tick period compensate function. */ bool bUseAlternativeCrc; /*!< Use alternative 4-bit CRC algorithm instead of SAE CRC algorithm. */ bool bFastMsgCRCCheckEn; /*!< Enable Fast message CRC check. */ bool bFastMsgDataChangeEn; /*!< If enabled, the SENT will only assert the fast message ready flag when received data has changed compared with previous data */ bool bFastMsgCRCAugEn; /*!< Augmentation is selected for Fast Message CRC calculation. */ bool bFastMsgCRCWithSCEn; /*!< If enabled, the crc calculation will includes S&C nibble. */ bool bSlowMsgCRCAugEn; /*!< Augmentation is selected for Short Serial Message CRC calculation. */ bool bPausePulseEn; /*!< If enabled, a pause pulse will be appended at the end of a frame. */ bool bChannelEn; /*!< Enable the SENT Channel. */ } Sent_ChannelConfigType; /** * @brief structure to configure the SENT channel DMA. * */ typedef struct { bool bFastMsgDmaEn; /*!< Fast message DMA request enable. */ bool bSlowMsgDmaEn; /*!< Slow message DMA request enable. */ } Sent_DMAConfigType; /** * @brief structure to configure the SENT channel SPC. * */ typedef struct { uint8_t u8PulseWidth; /*!< Configure the width of the SPC pulse. */ uint8_t u8PulseDelay; /*!< Configure the delay between SPC-trigger assert and finally generate a SPC pulse. */ Sent_SpcTickBaseType eSpcTickBase; /*!< Select the tick base of SPC */ Sent_SpcTriggerType eSpcTrigger; /*!< Select the SPC pulse trigger type. */ bool bCalDiagEn; /*!< Enable Calibration diagnosis. */ bool bSpcModeEn; /*!< Enable SPC mode. */ } Sent_SpcConfigType; /** * @brief The structure of the SENT processing handle * */ typedef struct _Sent_HandleType { Sent_InstanceType eInstance; /**< CAN instance */ /* tStatus Can't be set by user */ struct { bool bInitStatus; /**< Sent instance initialize status */ } tStatus; struct { SENT_GBISRCallbackType pGBCallback; /**< Global interrupt callback function */ SENT_CHISRCallbackType pCHCallback; /**< Channel interrupt callback function */ } tSettings; } Sent_HandleType; /** * @brief Process sent interrupt * * @param pSentHandle The sent handle point * @param ConfigPtr The basic configurations of the SENT * @return void */ void SENT_InterruptProcess(const Sent_HandleType *pSentHandle); /** * @brief Initialize SENT configuration * * @param pSentHandle The sent handle point * @param ConfigPtr The basic configurations of the SENT * @return void */ void SENT_Init(Sent_HandleType *pSentHandle, const Sent_ConfigType *ConfigPtr); /** * @brief Set SENT channel configuration * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param ConfigPtr The channel configurations of the SENT * @return void */ void SENT_SetChannelConfig(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, const Sent_ChannelConfigType *pCfg); /** * @brief Set SENT DMA configuration * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param ConfigPtr The channel configurations of the DMA * @return void */ void SENT_SetDMAConfig(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, Sent_DMAConfigType *pCfg); /** * @brief Set SENT SPC configuration * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param ConfigPtr The channel configurations of the SPC * @return void */ void SENT_SetSPCConfig(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, const Sent_SpcConfigType *pCfg); /** * @brief Get Fast message data. * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param pMsg The Fast message structure buffer. * @return void */ void SENT_GetFastMessageData(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, Sent_FastMessageDataType *pMsg); /** * @brief Get Slow message data. * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param pMsg The slow message structure buffer. * @return void */ void SENT_GetSlowMessageData(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, Sent_SlowMessageDataType *pMsg); /** * @brief Decode the fast message with DMA buffer. * * @param pDmaBuffer The pointer for DMA buffer. the buffer length should be 12bytes. * @param u32BufferLength The byte length of dma buffer. * @param pMsg The fast message structure buffer. * @return void */ void SENT_DecodeFastMessageWithDMABuffer(uint32_t *pDmaBuffer, uint32_t u32BufferLength, Sent_FastMessageDataType *pMsg); /** * @brief Decode the slow message with DMA buffer. * * @param pDmaBuffer The pointer for DMA buffer. the buffer length should be 12bytes. * @param u32BufferLength The byte length of dma buffer. * @param pMsg The slow message structure buffer. * @return void */ void SENT_DecodeSlowMessageWithDMABuffer(uint32_t *pDmaBuffer, uint32_t u32BufferLength, Sent_SlowMessageDataType *pMsg); /** * @brief Enable the fast message ready interrupt * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @return void */ void SENT_EnableGlobalFastMsgNotification(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel); /** * @brief Disable the fast message ready interrupt * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @return void */ void SENT_DisableGlobalFastMsgNotification(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel); /** * @brief Enable the slow message ready interrupt * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @return void */ void SENT_EnableGlobalSlowMsgNotification(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel); /** * @brief Disable the slow message ready interrupt * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @return void */ void SENT_DisableGlobalSlowMsgNotification(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel); /** * @brief Enable the fast message fifo interrupt * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @return void */ void SENT_EnableGlobalFastFifoMsgNotification(const Sent_HandleType *pSentHandle); /** * @brief Disable the fast message fifo interrupt * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @return void */ void SENT_DisableGlobalFastFifoMsgNotification(const Sent_HandleType *pSentHandle); /** * @brief configure the channel interrupt. * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param sInterruptEn the structure of interrupt enable * @return void */ void SENT_ConfigChannelStatusNotification(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, const Sent_ChannelInterruptType *sInterruptEn); /** * @brief Request the SPC pulse * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @return void */ void SENT_RequestSPCPulse(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel); /** * @brief Get the fast message ready flag * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param pFlag The point of flag(true or false) * @return void */ void SENT_GetFastMsgReadyFlag(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, bool *pFlag); /** * @brief Get the slow message ready flag * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param pFlag The point of flag(true or false) * @return void */ void SENT_GetSlowMsgReadyFlag(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, bool *pFlag); /** * @brief Get the channel status * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param pStatus The point of channel status * @return void */ void SENT_GetChannelStatus(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, uint32_t *pStatus); /** * @brief Clear the channel status * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param Status The channel status, the bits are used for W1c * @return void */ void SENT_ClearChannelStatus(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, uint32_t Status); /** * @brief Get the channel SPC busy flag * * @param pSentHandle The sent handle point * @param eChannel The channel of the selected SENT instance * @param pflag The point of flag(true or false) * @return void */ void SENT_GetChannelSPCBusyFlag(const Sent_HandleType *pSentHandle, const Sent_ChannelType eChannel, bool *pflag); /** @}*/ /* module_driver_sent */ #if defined(__cplusplus) } #endif #endif /* #if SENT_INSTANCE_COUNT > 0U */ #endif