HVAC_M7
/
PeripheralDriver_Flagchip_FC7240
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
PeripheralDriver_Flagchip_F.../Src/fc7xxx_driver_sent.c

897 lines
30 KiB
C
Raw Blame History

/**
* @file fc7xxx_driver_sent.c
* @author Flagchip
* @brief FC7xxx SENT driver source code
* @version 0.2.0
* @date 2022-12-30
*
* @copyright Copyright (c) 2022 Flagchip Semiconductors Co., Ltd.
*
*/
/* ********************************************************************************
* Revision History:
*
* Version Date Author CR# Descriptions
* --------- ---------- ------------ ---------- ---------------
* 0.1.0 2022-12-14 Flagchip N/A First version for FC7300 SENT
* 0.2.0 2022-12-30 Flagchip N/A Support SPC mode for SENT
******************************************************************************** */
#include "fc7xxx_driver_sent.h"
#include "interrupt_manager.h"
#include "HwA_sent.h"
#define SENT_GLBL_CTL_PRESCALER_MAX 255U
#define SENT_GLBL_CTL_WATERMARK_MAX 16U
static SENT_Type* const aSent_Base[] = SENT_BASE_PTRS;
static bool aSentInit[SENT_INSTANCE_COUNT] = {0u};
static SENT_GBISRCallbackType aGBISRCallback[SENT_INSTANCE_MAX] = {NULL};
static SENT_CHISRCallbackType aCHISRCallback[SENT_INSTANCE_MAX] = {NULL};
void SENT0_IRQHandler(void);
void SENT1_IRQHandler(void);
static void SENT_IRQ_Handler(const Sent_InstanceType eInstance)
{
uint8_t u8Channel;
uint32_t u32ChannelStatus;
SENT_Type *pSent = aSent_Base[eInstance];
for(u8Channel = 0U; u8Channel < SENT_CHANNEL_COUNT; u8Channel++)
{
if(true == SENT_HWA_GetChannelReceive(pSent, u8Channel))
{
if(true == SENT_HWA_GetSLowMessageUnderflowFlag(pSent, u8Channel))
{
if(NULL != aGBISRCallback[eInstance])
{
SENT_HWA_ClearSLowMessageUnderflowFlag(pSent, u8Channel);
aGBISRCallback[eInstance]((Sent_ChannelType)u8Channel, SENT_SLOW_MSG_DMA_UF_IT);
}
}
if(true == SENT_HWA_GetFastMessageReadyFlag(pSent, u8Channel))
{
if(NULL != aGBISRCallback[eInstance])
{
SENT_HWA_ClearFastMessageReadyFlag(pSent, u8Channel);
aGBISRCallback[eInstance]((Sent_ChannelType)u8Channel, SENT_FAST_MSG_READY_IT);
}
}
if(true == SENT_HWA_GetSlowMessageReadyFlag(pSent, u8Channel))
{
if(NULL != aGBISRCallback[eInstance])
{
SENT_HWA_ClearSlowMessageReadyFlag(pSent, u8Channel);
aGBISRCallback[eInstance]((Sent_ChannelType)u8Channel, SENT_SLOW_MSG_READY_IT);
}
}
if(true == SENT_HWA_GetFastMessageFIFOOverflowFlag(pSent, u8Channel))
{
if(NULL != aGBISRCallback[eInstance])
{
SENT_HWA_ClearFastMessageFIFOOverflowFlag(pSent, u8Channel);
aGBISRCallback[eInstance]((Sent_ChannelType)u8Channel, SENT_FAST_MSG_FIFO_OF_IT);
}
}
if(true == SENT_HWA_GetFastMessageDMAUnderflowFlag(pSent, u8Channel))
{
if(NULL != aGBISRCallback[eInstance])
{
SENT_HWA_ClearFastMessageDMAUnderflowFlag(pSent, u8Channel);
aGBISRCallback[eInstance]((Sent_ChannelType)u8Channel, SENT_FAST_MSG_DMA_DF_IT);
}
}
u32ChannelStatus = SENT_HWA_GetChannelStatus(pSent, u8Channel);
if(0U != u32ChannelStatus)
{
if(NULL != aCHISRCallback[eInstance])
{
SENT_HWA_ClearChannelStatus(pSent, u8Channel, u32ChannelStatus);
aCHISRCallback[eInstance]((Sent_ChannelType)u8Channel, u32ChannelStatus);
}
}
}
}
}
Sent_ReturnType SENT_Init(const Sent_InstanceType eInstance, const Sent_ConfigType *pCfg)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(false == aSentInit[eInstance])
{
if((NULL != pCfg) && (eInstance < SENT_INSTANCE_MAX) && \
(pCfg->u8DmaWaterMark <= SENT_GLBL_CTL_WATERMARK_MAX) && \
(pCfg->u8PreScaler < SENT_GLBL_CTL_PRESCALER_MAX))
{
pSent = aSent_Base[eInstance];
SENT_HWA_SetGlobalPreScaler(pSent, pCfg->u8PreScaler);
SENT_HWA_SetDMAWaterMark(pSent, pCfg->u8DmaWaterMark);
if(true == pCfg->bDebugModeEn)
{
SENT_HWA_EnableDebugMode(pSent);
}
else
{
SENT_HWA_DisableDebugMode(pSent);
}
if(true == pCfg->bAutoClearReadyFlag)
{
SENT_HWA_EnableDataOverflowFlagFastClear(pSent);
}
else
{
SENT_HWA_DisableDataOverflowFlagFastClear(pSent);
}
aGBISRCallback[eInstance] = pCfg->pGBCallback;
aCHISRCallback[eInstance] = pCfg->pCHCallback;
SENT_HWA_EnableGlobal(pSent);
aSentInit[eInstance] = true;
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_ALREADY_INIT;
}
return eRet;
}
Sent_ReturnType SENT_SetChannelConfig(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, const Sent_ChannelConfigType *pCfg)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((NULL != pCfg) && (eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
if(true == pCfg->bChannelEn)
{
if((pCfg->u8DataNibbleNumber > 0U) && (pCfg->u8DataNibbleNumber < 6U))
{
SENT_HWA_DisableChannelReceive(pSent, (uint8_t)eChannel);
SENT_HWA_SetChannelIdleCount(pSent, (uint8_t)eChannel, (uint8_t)pCfg->eIdleCount);
SENT_HWA_SetChannelDigitalFilterCount(pSent, (uint8_t)eChannel, pCfg->u8DigitalFilterCount);
SENT_HWA_SetChannelNibbleNumber(pSent, (uint8_t)eChannel, pCfg->u8DataNibbleNumber);
SENT_HWA_SetChannelPreScaler(pSent, (uint8_t)eChannel, (uint16_t)pCfg->u16TickScaler);
SENT_HWA_SetChannelNibbleDataMode(pSent, (uint8_t)eChannel, (SENT_NibbleDataModeType)(pCfg->eDataNibbleMode));
if(SENT_CALIBRATION_PULSE_DIAG_OPTION1 != pCfg->eCalDiagOption)
{
SENT_HWA_DisableChannelSPCOption1(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_EnableChannelSPCOption1(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bPausePulseEn)
{
SENT_HWA_EnableChannelPausePulse(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelPausePulse(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bTickCompensateEn)
{
SENT_HWA_EnableChannelCompensate(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelCompensate(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bFastMessageFifoEn)
{
SENT_HWA_EnableChannelFIFO(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelFIFO(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bFastMsgCRCAugEn)
{
SENT_HWA_EnableChannelFastMessageAugmentation(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelFastMessageAugmentation(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bFastMsgCRCCheckEn)
{
SENT_HWA_EnableChannelFastMessageCRCCheck(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelFastMessageCRCCheck(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bFastMsgCRCWithSCEn)
{
SENT_HWA_EnableChannelFastMessageCRCWithSC(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelFastMessageCRCWithSC(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bFastMsgDataChangeEn)
{
SENT_HWA_EnableChannelFastMessageDataChange(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelFastMessageDataChange(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bSlowMsgCRCAugEn)
{
SENT_HWA_EnableChannelSlowMessageAugmentation(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelSlowMessageAugmentation(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bUseAlternativeCrc)
{
SENT_HWA_EnableChannelAltCRC(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelAltCRC(pSent, (uint8_t)eChannel);
}
if(SENT_CALIBRATION_VALID_WITHIN_20 == pCfg->eCalValid)
{
SENT_HWA_DisableChannelCalValid20To25(pSent, (uint8_t)eChannel);
SENT_HWA_EnableChannelCalValidDiagnostic(pSent, (uint8_t)eChannel);
}
else if(SENT_CALIBRATION_VALID_FROM_20_TO_25 == pCfg->eCalValid)
{
SENT_HWA_EnableChannelCalValid20To25(pSent, (uint8_t)eChannel);
SENT_HWA_EnableChannelCalValidDiagnostic(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelCalValid20To25(pSent, (uint8_t)eChannel);
SENT_HWA_DisableChannelCalValidDiagnostic(pSent, (uint8_t)eChannel);
}
SENT_HWA_EnableChannelReceive(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
SENT_HWA_DisableChannelReceive(pSent, (uint8_t)eChannel);
}
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_SetDMAConfig(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, Sent_DMAConfigType *pCfg)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((NULL != pCfg) && (eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
if(true == pCfg->bFastMsgDmaEn)
{
SENT_HWA_EnableChannelFastMessageDmaRequest(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelFastMessageDmaRequest(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bSlowMsgDmaEn)
{
SENT_HWA_EnableChannelSlowMessageDmaRequest(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelSlowMessageDmaRequest(pSent, (uint8_t)eChannel);
}
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_SetSPCConfig(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, const Sent_SpcConfigType *pCfg)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((NULL != pCfg) && (eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
SENT_HWA_DisableChannelSPCMode(pSent, (uint8_t)eChannel);
SENT_HWA_SetChannelSPCTickBase(pSent, (uint8_t)eChannel, (SENT_SPCTickType)(pCfg->eSpcTickBase));
SENT_HWA_SetChannelSPCTriggerMethod(pSent, (uint8_t)eChannel, (SENT_SPCTriggerType)(pCfg->eSpcTrigger));
SENT_HWA_SetChannelSPCPulseDelay(pSent, (uint8_t)eChannel, pCfg->u8PulseDelay);
SENT_HWA_SetChannelSPCPulseWidth(pSent, (uint8_t)eChannel, pCfg->u8PulseWidth);
if(true == pCfg->bCalDiagEn)
{
SENT_HWA_EnableChannelCalibrationDiag(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelCalibrationDiag(pSent, (uint8_t)eChannel);
}
if(true == pCfg->bSpcModeEn)
{
SENT_HWA_EnableChannelSPCMode(pSent, (uint8_t)eChannel);
}
else
{
SENT_HWA_DisableChannelSPCMode(pSent, (uint8_t)eChannel);
}
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_GetFastMessageData(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, Sent_FastMessageDataType *pMsg)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
uint8_t u8DataShift;
if(true == aSentInit[eInstance])
{
if((NULL != pMsg) && (eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
pMsg->u8CRC = SENT_HWA_GetChannelFastMessageCRCNibble(pSent, (uint8_t)eChannel);
pMsg->u8SC = SENT_HWA_GetChannelFastMessageStatusNibble(pSent, (uint8_t)eChannel);
pMsg->u32Timestamp = SENT_HWA_GetChannelFastMessageTimeStamp(pSent, (uint8_t)eChannel);
u8DataShift = (5U - SENT_HWA_GetChannelNibbleNumber(pSent, (uint8_t)eChannel)) << 2U;
pMsg->u32Data = SENT_HWA_GetChannelDataNibble(pSent, (uint8_t)eChannel) >> (SENT_CHN_FDATA_DATA6_SHIFT + u8DataShift);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_GetSlowMessageData(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, Sent_SlowMessageDataType *pMsg)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((NULL != pMsg) && (eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
pMsg->eMsgType = (Sent_SerialMessageType)SENT_HWA_GetChannelSLowMessageType(pSent, (uint8_t)eChannel);
pMsg->u32Timestamp = SENT_HWA_GetChannelSlowMessageTimeStamp(pSent, (uint8_t)eChannel);
if(SENT_SERIAL_MESSAGE_SHORT == pMsg->eMsgType)
{
pMsg->u8CRC = SENT_HWA_GetChannelBit2CRC(pSent, (uint8_t)eChannel) & 0xFU;
pMsg->u16Data = (uint16_t)SENT_HWA_GetChannelBit2DATA(pSent, (uint8_t)eChannel) & 0xFFU;
pMsg->u8ID = SENT_HWA_GetChannelBit2DATA(pSent, (uint8_t)eChannel) >> 8U;
}
else if(SENT_SERIAL_MESSAGE_ENHANCE_12DATA_8ID == pMsg->eMsgType)
{
pMsg->u8CRC = SENT_HWA_GetChannelBit2CRC(pSent, (uint8_t)eChannel);
pMsg->u16Data = SENT_HWA_GetChannelBit2DATA(pSent, (uint8_t)eChannel);
pMsg->u8ID = (SENT_HWA_GetChannelBit3EnhancedID7_4_OR_ID3_0(pSent, (uint8_t)eChannel) << 4U) | SENT_HWA_GetChannelBit3EnhancedID3_0_OR_DATA15_12(pSent, (uint8_t)eChannel);
}
else if(SENT_SERIAL_MESSAGE_ENHANCE_16DATA_4ID == pMsg->eMsgType)
{
pMsg->u8CRC = SENT_HWA_GetChannelBit2CRC(pSent, (uint8_t)eChannel);
pMsg->u16Data = ((uint16_t)SENT_HWA_GetChannelBit3EnhancedID3_0_OR_DATA15_12(pSent, (uint8_t)eChannel) << 12U) | (uint16_t)SENT_HWA_GetChannelBit2DATA(pSent, (uint8_t)eChannel);
pMsg->u8ID = SENT_HWA_GetChannelBit3EnhancedID7_4_OR_ID3_0(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_NOT_OK;
}
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_DecodeFastMessageWithDMABuffer(uint32_t *pDmaBuffer, uint32_t u32BufferLength, Sent_FastMessageDataType *pMsg)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
if((NULL != pMsg) && (NULL != pDmaBuffer) && (12U == u32BufferLength))
{
pMsg->u8CRC = (uint8_t)((pDmaBuffer[1] & SENT_CHN_FCRC_CRC_DATA_MASK) >> SENT_CHN_FCRC_CRC_DATA_SHIFT);
pMsg->u8SC = (uint8_t)((pDmaBuffer[1] & SENT_CHN_FCRC_SC_NB_MASK) >> SENT_CHN_FCRC_SC_NB_SHIFT);
pMsg->u32Timestamp = ((pDmaBuffer[2] & SENT_CHN_FTS_TIMESTAMP_VAL_MASK) >> SENT_CHN_FTS_TIMESTAMP_VAL_SHIFT);
pMsg->u32Data = (pDmaBuffer[0] >> SENT_CHN_FDATA_DATA6_SHIFT);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
return eRet;
}
Sent_ReturnType SENT_DecodeSlowMessageWithDMABuffer(uint32_t *pDmaBuffer, uint32_t u32BufferLength, Sent_SlowMessageDataType *pMsg)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
if((NULL != pMsg) && (NULL != pDmaBuffer) && (12U == u32BufferLength))
{
if(SENT_CHN_SBIT3__MSG_TYPE_MASK == (pDmaBuffer[0] & SENT_CHN_SBIT3__MSG_TYPE_MASK))
{
if(SENT_CHN_SBIT3__CFG_MASK == (pDmaBuffer[0] & SENT_CHN_SBIT3__CFG_MASK))
{
pMsg->eMsgType = (Sent_SerialMessageType)SENT_SLOW_MESSAGE_ENHANCE_16DATA_4ID;
}
else
{
pMsg->eMsgType = (Sent_SerialMessageType)SENT_SLOW_MESSAGE_ENHANCE_12DATA_8ID;
}
}
else
{
pMsg->eMsgType = (Sent_SerialMessageType)SENT_SLOW_MESSAGE_SHORT;
}
pMsg->u32Timestamp = ((pDmaBuffer[2] & SENT_CHN_STS_SMSG_TIMESTAMP_MASK) >> SENT_CHN_STS_SMSG_TIMESTAMP_SHIFT);
if(SENT_SERIAL_MESSAGE_SHORT == pMsg->eMsgType)
{
pMsg->u8CRC =(uint8_t)(((pDmaBuffer[1] & SENT_CHN_SBIT2__SMSG_CRC_MASK) >> SENT_CHN_SBIT2__SMSG_CRC_SHIFT) & 0xFU);
pMsg->u16Data = (uint16_t)(((pDmaBuffer[1] & SENT_CHN_SBIT2__SMSG_DATA_MASK) >> SENT_CHN_SBIT2__SMSG_DATA_SHIFT) & 0xFFU);
pMsg->u8ID = (uint8_t)(((pDmaBuffer[1] & SENT_CHN_SBIT2__SMSG_DATA_MASK) >> SENT_CHN_SBIT2__SMSG_DATA_SHIFT) >> 8U);
}
else if(SENT_SERIAL_MESSAGE_ENHANCE_12DATA_8ID == pMsg->eMsgType)
{
pMsg->u8CRC = (uint8_t)((pDmaBuffer[1] & SENT_CHN_SBIT2__SMSG_CRC_MASK) >> SENT_CHN_SBIT2__SMSG_CRC_SHIFT);
pMsg->u16Data = (uint16_t)((pDmaBuffer[1] & SENT_CHN_SBIT2__SMSG_DATA_MASK) >> SENT_CHN_SBIT2__SMSG_DATA_SHIFT);
pMsg->u8ID = (uint8_t)((((pDmaBuffer[0] & SENT_CHN_SBIT3__ID7_4_OR_ID3_0_MASK) >> SENT_CHN_SBIT3__ID7_4_OR_ID3_0_SHIFT) << 4U) |\
((pDmaBuffer[0] & SENT_CHN_SBIT3__ID3_0_OR_DATA15_12_MASK) >> SENT_CHN_SBIT3__ID3_0_OR_DATA15_12_SHIFT));
}
else if(SENT_SERIAL_MESSAGE_ENHANCE_16DATA_4ID == pMsg->eMsgType)
{
pMsg->u8CRC = (uint8_t)((pDmaBuffer[1] & SENT_CHN_SBIT2__SMSG_CRC_MASK) >> SENT_CHN_SBIT2__SMSG_CRC_SHIFT);
pMsg->u16Data = (uint16_t)((((pDmaBuffer[0] & SENT_CHN_SBIT3__ID3_0_OR_DATA15_12_MASK) >> SENT_CHN_SBIT3__ID3_0_OR_DATA15_12_SHIFT) << 12U) |\
((pDmaBuffer[1] & SENT_CHN_SBIT2__SMSG_DATA_MASK) >> SENT_CHN_SBIT2__SMSG_DATA_SHIFT));
pMsg->u8ID = (uint8_t)((pDmaBuffer[0] & SENT_CHN_SBIT3__ID7_4_OR_ID3_0_MASK) >> SENT_CHN_SBIT3__ID7_4_OR_ID3_0_SHIFT);
}
else
{
eRet = SENT_RETURN_E_NOT_OK;
}
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
return eRet;
}
Sent_ReturnType SENT_EnableGlobalFastMsgNotification(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
SENT_HWA_EnableChannelFastMessageInterrupt(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_DisableGlobalFastMsgNotification(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
SENT_HWA_DisableChannelFastMessageInterrupt(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_EnableGlobalSlowMsgNotification(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
SENT_HWA_EnableChannelSlowMessageInterrupt(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_DisableGlobalSlowMsgNotification(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
SENT_HWA_DisableChannelSlowMessageInterrupt(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_EnableGlobalFastFifoMsgNotification(const Sent_InstanceType eInstance)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if(eInstance < SENT_INSTANCE_MAX)
{
pSent = aSent_Base[eInstance];
SENT_HWA_EnableFastMessageFIFOOverflowInterrupt(pSent);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_DisableGlobalFastFifoMsgNotification(const Sent_InstanceType eInstance)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if(eInstance < SENT_INSTANCE_MAX)
{
pSent = aSent_Base[eInstance];
SENT_HWA_DisableFastMessageFIFOOverflowInterrupt(pSent);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_ConfigChannelStatusNotification(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, const Sent_ChannelInterruptType *sInterruptEn)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
SENT_HWA_EnableChannelBusIdleInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bBusIdleITEn);
SENT_HWA_EnableChannelSPCOverRunInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bSpcOverrunITEn);
SENT_HWA_EnableChannelCALDiagInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bCalDiagErrITEn);
SENT_HWA_EnableChannelCalFailInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bCalFailITEn);
SENT_HWA_EnableChannelCalResyncInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bCalResyncErrITEn);
SENT_HWA_EnableChannelEdgeERRInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bFallingEdgeNumErrITEn);
SENT_HWA_EnableChannelFCRCInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bFastMsgCrcErrITEn);
SENT_HWA_EnableChannelFOVFLInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bFastMsgOFITEn);
SENT_HWA_EnableChannelNibbleErrorInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bNibbleValueErrITEn);
SENT_HWA_EnableChannelPPDiagInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bPrePulseDiagErrITEn);
SENT_HWA_EnableChannelSCRCInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bSlowMsgCrcErrITEn);
SENT_HWA_EnableChannelSOVFLInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bSlowMsgOFITEn);
SENT_HWA_EnableChannelCalERRInterrupt(pSent, (uint8_t)eChannel, sInterruptEn->bCalErrITEn);
//SENT_HWA_EnableChannelAllErrorInterrupt(pSent, eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_RequestSPCPulse(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
SENT_HWA_StartChannelSPC(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_GetFastMsgReadyFlag(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, bool *pFlag)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
*pFlag = SENT_HWA_GetFastMessageReadyFlag(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_GetSlowMsgReadyFlag(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, bool *pFlag)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
*pFlag = SENT_HWA_GetSlowMessageReadyFlag(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_GetChannelStatus(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, uint32_t *pStatus)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
*pStatus = SENT_HWA_GetChannelStatus(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_ClearChannelStatus(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, uint32_t Status)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
SENT_HWA_ClearChannelStatus(pSent, (uint8_t)eChannel, Status);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
Sent_ReturnType SENT_GetChannelSPCBusyFlag(const Sent_InstanceType eInstance, const Sent_ChannelType eChannel, bool *pflag)
{
Sent_ReturnType eRet = SENT_RETURN_OK;
SENT_Type *pSent;
if(true == aSentInit[eInstance])
{
if((eInstance < SENT_INSTANCE_MAX) && (eChannel < SENT_CHANNEL_MAX))
{
pSent = aSent_Base[eInstance];
*pflag = SENT_HWA_GetChanneSPCBusyFlag(pSent, (uint8_t)eChannel);
}
else
{
eRet = SENT_RETURN_E_PARAM;
}
}
else
{
eRet = SENT_RETURN_E_UNINIT;
}
return eRet;
}
void SENT0_IRQHandler(void)
{
SENT_IRQ_Handler(SENT_INSTANCE_0);
}
void SENT1_IRQHandler(void)
{
SENT_IRQ_Handler(SENT_INSTANCE_1);
}
Reference in New Issue View Git Blame Copy Permalink