/**************************************************************************//** | |
* @file can.c | |
* @version V1.00 | |
* @brief CAN driver source file | |
* | |
* @copyright (C) 2016 Nuvoton Technology Corp. All rights reserved. | |
*****************************************************************************/ | |
#include "M2351.h" | |
#if defined(__ICCARM__) | |
# pragma diag_suppress=Pm073, Pm143 /* Misra C rule 14.7 */ | |
#endif | |
/** @addtogroup Standard_Driver Standard Driver | |
@{ | |
*/ | |
/** @addtogroup CAN_Driver CAN Driver | |
@{ | |
*/ | |
/** @addtogroup CAN_EXPORTED_FUNCTIONS CAN Exported Functions | |
@{ | |
*/ | |
/** @cond HIDDEN_SYMBOLS */ | |
#if defined(CAN1) | |
static uint8_t gu8LockCanIf[2][2] = {0U}; /* The chip has two CANs. */ | |
#elif defined(CAN0) || defined(CAN) | |
static uint8_t gu8LockCanIf[1][2] = {0U}; /* The chip only has one CAN. */ | |
#endif | |
#define RETRY_COUNTS (0x10000000UL) | |
#define TSEG1_MIN 2 | |
#define TSEG1_MAX 16 | |
#define TSEG2_MIN 1 | |
#define TSEG2_MAX 8 | |
#define BRP_MIN 1 | |
#define BRP_MAX 1024 /* 6-bit BRP field + 4-bit BRPE field*/ | |
#define SJW_MAX 4UL | |
#define BRP_INC 1 | |
/* #define DEBUG_PRINTF printf */ | |
#define DEBUG_PRINTF(...) | |
static uint32_t LockIF(CAN_T *tCAN); | |
static uint32_t LockIF_TL(CAN_T *tCAN); | |
static void ReleaseIF(CAN_T *tCAN, uint32_t u32IfNo); | |
static int can_update_spt(int sampl_pt, int tseg, int *tseg1, int *tseg2); | |
/** | |
* @brief Check if any interface is available then lock it for usage. | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @retval 0 IF0 is free | |
* @retval 1 IF1 is free | |
* @retval 2 No IF is free | |
* @details Search the first free message interface, starting from 0. If a interface is | |
* available, set a flag to lock the interface. | |
*/ | |
static uint32_t LockIF(CAN_T *tCAN) | |
{ | |
uint32_t u32CanNo; | |
uint32_t u32FreeIfNo; | |
uint32_t u32IntMask; | |
#if defined(CAN1) | |
u32CanNo = (tCAN == CAN1) ? 1 : 0; | |
#else // defined(CAN0) || defined(CAN) | |
u32CanNo = 0U; | |
#endif | |
u32FreeIfNo = 2U; | |
/* Disable CAN interrupt */ | |
u32IntMask = tCAN->CON & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk); | |
tCAN->CON = tCAN->CON & ~(CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk); | |
/* Check interface 1 is available or not */ | |
if((tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0U) | |
{ | |
if(gu8LockCanIf[u32CanNo][0] == (uint8_t)FALSE) | |
{ | |
gu8LockCanIf[u32CanNo][0] = (uint8_t)TRUE; | |
u32FreeIfNo = 0U; | |
} | |
} | |
/* Or check interface 2 is available or not */ | |
if(u32FreeIfNo == 2U) | |
{ | |
if((tCAN->IF[1].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0U) | |
{ | |
if(gu8LockCanIf[u32CanNo][1] == (uint8_t)FALSE) | |
{ | |
gu8LockCanIf[u32CanNo][1] = (uint8_t)TRUE; | |
u32FreeIfNo = 1U; | |
} | |
} | |
} | |
/* Enable CAN interrupt */ | |
tCAN->CON |= u32IntMask; | |
return u32FreeIfNo; | |
} | |
/** | |
* @brief Check if any interface is available in a time limitation then lock it for usage. | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @retval 0 IF0 is free | |
* @retval 1 IF1 is free | |
* @retval 2 No IF is free | |
* @details Search the first free message interface, starting from 0. If no interface is | |
* it will try again until time out. If a interface is available, set a flag to | |
* lock the interface. | |
*/ | |
static uint32_t LockIF_TL(CAN_T *tCAN) | |
{ | |
uint32_t u32Count; | |
uint32_t u32FreeIfNo; | |
for(u32Count = 0U; u32Count < (uint32_t)RETRY_COUNTS; u32Count++) | |
{ | |
if((u32FreeIfNo = LockIF(tCAN)) != 2U) | |
{ | |
break; | |
} | |
} | |
return u32FreeIfNo; | |
} | |
/** | |
* @brief Release locked interface. | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32Info The interface number, 0 or 1. | |
* @return none | |
* @details Release the locked interface. | |
*/ | |
static void ReleaseIF(CAN_T *tCAN, uint32_t u32IfNo) | |
{ | |
uint32_t u32IntMask; | |
uint32_t u32CanNo; | |
if(u32IfNo < 2U) | |
{ | |
#if defined(CAN1) | |
u32CanNo = (tCAN == CAN1) ? 1U : 0U; | |
#else // defined(CAN0) || defined(CAN) | |
u32CanNo = 0U; | |
#endif | |
/* Disable CAN interrupt */ | |
u32IntMask = tCAN->CON & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk); | |
tCAN->CON = tCAN->CON & ~(CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk); | |
gu8LockCanIf[u32CanNo][u32IfNo] = (uint8_t)FALSE; | |
/* Enable CAN interrupt */ | |
tCAN->CON |= u32IntMask; | |
} | |
} | |
/** | |
* @brief Enter initialization mode | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] Following values can be used. | |
* \ref CAN_CON_DAR_Msk Disable automatic retransmission. | |
* \ref CAN_CON_EIE_Msk Enable error interrupt. | |
* \ref CAN_CON_SIE_Msk Enable status interrupt. | |
* \ref CAN_CON_IE_Msk CAN interrupt. | |
* @return None | |
* @details This function is used to set CAN to enter initialization mode and enable access bit timing | |
* register. After bit timing configuration ready, user must call CAN_LeaveInitMode() | |
* to leave initialization mode and lock bit timing register to let new configuration | |
* take effect. | |
*/ | |
void CAN_EnterInitMode(CAN_T *tCAN, uint8_t u8Mask) | |
{ | |
tCAN->CON = u8Mask | (CAN_CON_INIT_Msk | CAN_CON_CCE_Msk); | |
} | |
/** | |
* @brief Leave initialization mode | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @return None | |
* @details This function is used to set CAN to leave initialization mode to let | |
* bit timing configuration take effect after configuration ready. | |
*/ | |
void CAN_LeaveInitMode(CAN_T *tCAN) | |
{ | |
tCAN->CON &= (~(CAN_CON_INIT_Msk | CAN_CON_CCE_Msk)); | |
while(tCAN->CON & CAN_CON_INIT_Msk) {} /* Check INIT bit is released */ | |
} | |
/** | |
* @brief Wait message into message buffer in basic mode. | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @return None | |
* @details This function is used to wait message into message buffer in basic mode. Please notice the | |
* function is polling NEWDAT bit of MCON register by while loop and it is used in basic mode. | |
*/ | |
void CAN_WaitMsg(CAN_T *tCAN) | |
{ | |
tCAN->STATUS = 0x0U; /* clr status */ | |
while(1) | |
{ | |
if(tCAN->IF[1].MCON & CAN_IF_MCON_NEWDAT_Msk) /* check new data */ | |
{ | |
/* DEBUG_PRINTF("New Data IN\n"); */ | |
break; | |
} | |
if(tCAN->STATUS & CAN_STATUS_RXOK_Msk) | |
{ | |
/* DEBUG_PRINTF("Rx OK\n"); */ | |
} | |
if(tCAN->STATUS & CAN_STATUS_LEC_Msk) | |
{ | |
/* DEBUG_PRINTF("Error\n"); */ | |
} | |
} | |
} | |
/** | |
* @brief Get current bit rate | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @return Current Bit-Rate (kilo bit per second) | |
* @details Return current CAN bit rate according to the user bit-timing parameter settings | |
*/ | |
uint32_t CAN_GetCANBitRate(CAN_T *tCAN) | |
{ | |
uint8_t u8Tseg1, u8Tseg2; | |
uint32_t u32Bpr; | |
u8Tseg1 = (uint8_t)((tCAN->BTIME & CAN_BTIME_TSEG1_Msk) >> CAN_BTIME_TSEG1_Pos); | |
u8Tseg2 = (uint8_t)((tCAN->BTIME & CAN_BTIME_TSEG2_Msk) >> CAN_BTIME_TSEG2_Pos); | |
u32Bpr = (tCAN->BTIME & CAN_BTIME_BRP_Msk); | |
u32Bpr |= (tCAN->BRPE << 6); | |
return (SystemCoreClock / (u32Bpr + 1U) / ((uint32_t)u8Tseg1 + (uint32_t)u8Tseg2 + 3U)); | |
} | |
/** | |
* @brief Switch the CAN into test mode. | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u8TestMask Specifies the configuration in test modes | |
* \ref CAN_TEST_BASIC_Msk Enable basic mode of test mode | |
* \ref CAN_TEST_SILENT_Msk Enable silent mode of test mode | |
* \ref CAN_TEST_LBACK_Msk Enable Loop Back Mode of test mode | |
* \ref CAN_TEST_TX0_Msk / \ref CAN_TEST_TX1_Msk Control CAN_TX pin bit field | |
* @return None | |
* @details Switch the CAN into test mode. There are four test mode (BASIC/SILENT/LOOPBACK/ | |
* LOOPBACK combined SILENT/CONTROL_TX_PIN)could be selected. After setting test mode,user | |
* must call CAN_LeaveInitMode() to let the setting take effect. | |
*/ | |
void CAN_EnterTestMode(CAN_T *tCAN, uint8_t u8TestMask) | |
{ | |
tCAN->CON |= CAN_CON_TEST_Msk; | |
tCAN->TEST = u8TestMask; | |
} | |
/** | |
* @brief Leave the test mode | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @return None | |
* @details This function is used to Leave the test mode (switch into normal mode). | |
*/ | |
void CAN_LeaveTestMode(CAN_T *tCAN) | |
{ | |
tCAN->CON |= CAN_CON_TEST_Msk; | |
tCAN->TEST &= ~(CAN_TEST_LBACK_Msk | CAN_TEST_SILENT_Msk | CAN_TEST_BASIC_Msk); | |
tCAN->CON &= (~CAN_CON_TEST_Msk); | |
} | |
/** | |
* @brief Get the waiting status of a received message. | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u8MsgObj Specifies the Message object number, from 0 to 31. | |
* @retval non-zero The corresponding message object has a new data bit is set. | |
* @retval 0 No message object has new data. | |
* @details This function is used to get the waiting status of a received message. | |
*/ | |
uint32_t CAN_IsNewDataReceived(CAN_T *tCAN, uint8_t u8MsgObj) | |
{ | |
uint32_t ret; | |
if((uint32_t)u8MsgObj < 16U) | |
{ | |
ret = tCAN->NDAT1 & (1UL << u8MsgObj); | |
} | |
else | |
{ | |
ret = tCAN->NDAT2 & (1UL << (u8MsgObj - 16U)); | |
} | |
return ret; | |
} | |
/** | |
* @brief Send CAN message in BASIC mode of test mode | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] pCanMsg Pointer to the message structure containing data to transmit. | |
* @return TRUE: Transmission OK | |
* FALSE: Check busy flag of interface 0 is timeout | |
* @details The function is used to send CAN message in BASIC mode of test mode. Before call the API, | |
* the user should be call CAN_EnterTestMode(CAN_TEST_BASIC) and let CAN controller enter | |
* basic mode of test mode. Please notice IF1 Registers used as Tx Buffer in basic mode. | |
*/ | |
int32_t CAN_BasicSendMsg(CAN_T *tCAN, STR_CANMSG_T* pCanMsg) | |
{ | |
uint32_t i = 0UL; | |
while(tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) {} | |
tCAN->STATUS &= (~CAN_STATUS_TXOK_Msk); | |
if(pCanMsg->IdType == CAN_STD_ID) | |
{ | |
/* standard ID*/ | |
tCAN->IF[0].ARB1 = 0UL; | |
tCAN->IF[0].ARB2 = (((pCanMsg->Id) & 0x7FFUL) << 2) ; | |
} | |
else | |
{ | |
/* extended ID*/ | |
tCAN->IF[0].ARB1 = (pCanMsg->Id) & 0xFFFFUL; | |
tCAN->IF[0].ARB2 = (((pCanMsg->Id) & 0x1FFF0000UL) >> 16) | CAN_IF_ARB2_XTD_Msk; | |
} | |
if(pCanMsg->FrameType) | |
{ | |
tCAN->IF[0].ARB2 |= CAN_IF_ARB2_DIR_Msk; | |
} | |
else | |
{ | |
tCAN->IF[0].ARB2 &= (~CAN_IF_ARB2_DIR_Msk); | |
} | |
tCAN->IF[0].MCON = (tCAN->IF[0].MCON & (~CAN_IF_MCON_DLC_Msk)) | pCanMsg->DLC; | |
tCAN->IF[0].DAT_A1 = ((uint32_t)pCanMsg->Data[1] << 8) | pCanMsg->Data[0]; | |
tCAN->IF[0].DAT_A2 = ((uint32_t)pCanMsg->Data[3] << 8) | pCanMsg->Data[2]; | |
tCAN->IF[0].DAT_B1 = ((uint32_t)pCanMsg->Data[5] << 8) | pCanMsg->Data[4]; | |
tCAN->IF[0].DAT_B2 = ((uint32_t)pCanMsg->Data[7] << 8) | pCanMsg->Data[6]; | |
/* request transmission*/ | |
tCAN->IF[0].CREQ &= (~CAN_IF_CREQ_BUSY_Msk); | |
if(tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) | |
{ | |
/* DEBUG_PRINTF("Cannot clear busy for sending ...\n"); */ | |
return (int32_t)FALSE; | |
} | |
tCAN->IF[0].CREQ |= CAN_IF_CREQ_BUSY_Msk; /* sending */ | |
for(i = 0UL; i < 0xFFFFFUL; i++) | |
{ | |
if((tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0UL) | |
{ | |
break; | |
} | |
} | |
if(i >= 0xFFFFFUL) | |
{ | |
/* DEBUG_PRINTF("Cannot send out...\n"); */ | |
return (int32_t)FALSE; | |
} | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief Get a message information in BASIC mode. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] pCanMsg Pointer to the message structure where received data is copied. | |
* | |
* @return FALSE No any message received. | |
* TRUE Receive a message success. | |
* | |
*/ | |
int32_t CAN_BasicReceiveMsg(CAN_T *tCAN, STR_CANMSG_T* pCanMsg) | |
{ | |
if((tCAN->IF[1].MCON & CAN_IF_MCON_NEWDAT_Msk) == 0UL) /* In basic mode, receive data always save in IF2 */ | |
{ | |
return (int32_t)FALSE; | |
} | |
tCAN->STATUS &= (~CAN_STATUS_RXOK_Msk); | |
tCAN->IF[1].CMASK = CAN_IF_CMASK_ARB_Msk | |
| CAN_IF_CMASK_CONTROL_Msk | |
| CAN_IF_CMASK_DATAA_Msk | |
| CAN_IF_CMASK_DATAB_Msk; | |
if((tCAN->IF[1].ARB2 & CAN_IF_ARB2_XTD_Msk) == 0UL) | |
{ | |
/* standard ID*/ | |
pCanMsg->IdType = CAN_STD_ID; | |
pCanMsg->Id = (tCAN->IF[1].ARB2 >> 2) & 0x07FFUL; | |
} | |
else | |
{ | |
/* extended ID*/ | |
pCanMsg->IdType = CAN_EXT_ID; | |
pCanMsg->Id = (tCAN->IF[1].ARB2 & 0x1FFFUL) << 16; | |
pCanMsg->Id |= (uint32_t)tCAN->IF[1].ARB1; | |
} | |
/* | |
pCanMsg->FrameType = (uint32_t)(!(uint32_t)((tCAN->IF[1].ARB2 & (uint32_t)CAN_IF_ARB2_DIR_Msk) >> (uint32_t)CAN_IF_ARB2_DIR_Pos)); | |
*/ | |
pCanMsg->FrameType = (tCAN->IF[1].ARB2 & CAN_IF_ARB2_DIR_Msk) ? 0UL : 1UL; | |
pCanMsg->DLC = (uint8_t)(tCAN->IF[1].MCON & CAN_IF_MCON_DLC_Msk); | |
pCanMsg->Data[0] = (uint8_t)(tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA0_Msk); | |
pCanMsg->Data[1] = (uint8_t)((tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA1_Msk) >> CAN_IF_DAT_A1_DATA1_Pos); | |
pCanMsg->Data[2] = (uint8_t)(tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA2_Msk); | |
pCanMsg->Data[3] = (uint8_t)((tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA3_Msk) >> CAN_IF_DAT_A2_DATA3_Pos); | |
pCanMsg->Data[4] = (uint8_t)(tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA4_Msk); | |
pCanMsg->Data[5] = (uint8_t)((tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA5_Msk) >> CAN_IF_DAT_B1_DATA5_Pos); | |
pCanMsg->Data[6] = (uint8_t)(tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA6_Msk); | |
pCanMsg->Data[7] = (uint8_t)((tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA7_Msk) >> CAN_IF_DAT_B2_DATA7_Pos); | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief Set Rx message object, include ID mask. | |
* @param[in] u8MsgObj Specifies the Message object number, from 0 to 31. | |
* @param[in] u8idType Specifies the identifier type of the frames that will be transmitted | |
* This parameter can be one of the following values: | |
* \ref CAN_STD_ID (standard ID, 11-bit) | |
* \ref CAN_EXT_ID (extended ID, 29-bit) | |
* @param[in] u32id Specifies the identifier used for acceptance filtering. | |
* @param[in] u8singleOrFifoLast Specifies the end-of-buffer indicator. | |
* This parameter can be one of the following values: | |
* TRUE: for a single receive object or a FIFO receive object that is the last one of the FIFO. | |
* FALSE: for a FIFO receive object that is not the last one. | |
* @retval TRUE SUCCESS | |
* @retval FALSE No useful interface | |
* @details The function is used to configure a receive message object. | |
*/ | |
int32_t CAN_SetRxMsgObjAndMsk(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8idType, uint32_t u32id, uint32_t u32idmask, uint8_t u8singleOrFifoLast) | |
{ | |
uint8_t u8MsgIfNum; | |
/* Get and lock a free interface */ | |
if((u8MsgIfNum = (uint8_t)LockIF_TL(tCAN)) == 2U) | |
{ | |
return (int32_t)FALSE; | |
} | |
/* Command Setting */ | |
tCAN->IF[u8MsgIfNum].CMASK = CAN_IF_CMASK_WRRD_Msk | CAN_IF_CMASK_MASK_Msk | CAN_IF_CMASK_ARB_Msk | | |
CAN_IF_CMASK_CONTROL_Msk | CAN_IF_CMASK_DATAA_Msk | CAN_IF_CMASK_DATAB_Msk; | |
if(u8idType == CAN_STD_ID) /* According STD/EXT ID format,Configure Mask and Arbitration register */ | |
{ | |
tCAN->IF[u8MsgIfNum].ARB1 = 0U; | |
tCAN->IF[u8MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | (u32id & 0x7FFUL) << 2; | |
} | |
else | |
{ | |
tCAN->IF[u8MsgIfNum].ARB1 = u32id & 0xFFFFUL; | |
tCAN->IF[u8MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | CAN_IF_ARB2_XTD_Msk | (u32id & 0x1FFF0000UL) >> 16; | |
} | |
tCAN->IF[u8MsgIfNum].MASK1 = (u32idmask & 0xFFFFUL); | |
tCAN->IF[u8MsgIfNum].MASK2 = (u32idmask >> 16) & 0xFFFFUL; | |
tCAN->IF[u8MsgIfNum].MCON = CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk; | |
if(u8singleOrFifoLast) | |
{ | |
tCAN->IF[u8MsgIfNum].MCON |= CAN_IF_MCON_EOB_Msk; | |
} | |
else | |
{ | |
tCAN->IF[u8MsgIfNum].MCON &= (~CAN_IF_MCON_EOB_Msk); | |
} | |
tCAN->IF[u8MsgIfNum].DAT_A1 = 0U; | |
tCAN->IF[u8MsgIfNum].DAT_A2 = 0U; | |
tCAN->IF[u8MsgIfNum].DAT_B1 = 0U; | |
tCAN->IF[u8MsgIfNum].DAT_B2 = 0U; | |
tCAN->IF[u8MsgIfNum].CREQ = 1UL + u8MsgObj; | |
ReleaseIF(tCAN, (uint32_t)u8MsgIfNum); | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief Set Rx message object | |
* @param[in] u8MsgObj Specifies the Message object number, from 0 to 31. | |
* @param[in] u8idType Specifies the identifier type of the frames that will be transmitted | |
* This parameter can be one of the following values: | |
* \ref CAN_STD_ID (standard ID, 11-bit) | |
* \ref CAN_EXT_ID (extended ID, 29-bit) | |
* @param[in] u32id Specifies the identifier used for acceptance filtering. | |
* @param[in] u8singleOrFifoLast Specifies the end-of-buffer indicator. | |
* This parameter can be one of the following values: | |
* TRUE: for a single receive object or a FIFO receive object that is the last one of the FIFO. | |
* FALSE: for a FIFO receive object that is not the last one. | |
* @retval TRUE SUCCESS | |
* @retval FALSE No useful interface | |
* @details The function is used to configure a receive message object. | |
*/ | |
int32_t CAN_SetRxMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8idType, uint32_t u32id, uint8_t u8singleOrFifoLast) | |
{ | |
uint8_t u8MsgIfNum; | |
/* Get and lock a free interface */ | |
if((u8MsgIfNum = (uint8_t)LockIF_TL(tCAN)) == 2U) | |
{ | |
return (int32_t)FALSE; | |
} | |
/* Command Setting */ | |
tCAN->IF[u8MsgIfNum].CMASK = CAN_IF_CMASK_WRRD_Msk | CAN_IF_CMASK_MASK_Msk | CAN_IF_CMASK_ARB_Msk | | |
CAN_IF_CMASK_CONTROL_Msk | CAN_IF_CMASK_DATAA_Msk | CAN_IF_CMASK_DATAB_Msk; | |
if(u8idType == CAN_STD_ID) /* According STD/EXT ID format,Configure Mask and Arbitration register */ | |
{ | |
tCAN->IF[u8MsgIfNum].ARB1 = 0U; | |
tCAN->IF[u8MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | (u32id & 0x7FFUL) << 2; | |
} | |
else | |
{ | |
tCAN->IF[u8MsgIfNum].ARB1 = u32id & 0xFFFFUL; | |
tCAN->IF[u8MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | CAN_IF_ARB2_XTD_Msk | (u32id & 0x1FFF0000UL) >> 16; | |
} | |
tCAN->IF[u8MsgIfNum].MCON = CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk; | |
if(u8singleOrFifoLast) | |
{ | |
tCAN->IF[u8MsgIfNum].MCON |= CAN_IF_MCON_EOB_Msk; | |
} | |
else | |
{ | |
tCAN->IF[u8MsgIfNum].MCON &= (~CAN_IF_MCON_EOB_Msk); | |
} | |
tCAN->IF[u8MsgIfNum].DAT_A1 = 0U; | |
tCAN->IF[u8MsgIfNum].DAT_A2 = 0U; | |
tCAN->IF[u8MsgIfNum].DAT_B1 = 0U; | |
tCAN->IF[u8MsgIfNum].DAT_B2 = 0U; | |
tCAN->IF[u8MsgIfNum].CREQ = 1UL + u8MsgObj; | |
ReleaseIF(tCAN, (uint32_t)u8MsgIfNum); | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief Gets the message | |
* @param[in] u8MsgObj Specifies the Message object number, from 0 to 31. | |
* @param[in] u8Release Specifies the message release indicator. | |
* This parameter can be one of the following values: | |
* TRUE: the message object is released when getting the data. | |
* FALSE:the message object is not released. | |
* @param[in] pCanMsg Pointer to the message structure where received data is copied. | |
* @retval TRUE Success | |
* @retval FALSE No any message received | |
* @details Gets the message, if received. | |
*/ | |
int32_t CAN_ReadMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8Release, STR_CANMSG_T* pCanMsg) | |
{ | |
uint8_t u8MsgIfNum; | |
uint32_t u32Tmp; | |
if(!CAN_IsNewDataReceived(tCAN, u8MsgObj)) | |
{ | |
return (int32_t)FALSE; | |
} | |
/* Get and lock a free interface */ | |
if((u8MsgIfNum = (uint8_t)LockIF_TL(tCAN)) == 2U) | |
{ | |
return (int32_t)FALSE; | |
} | |
tCAN->STATUS &= (~CAN_STATUS_RXOK_Msk); | |
/* read the message contents*/ | |
tCAN->IF[u8MsgIfNum].CMASK = CAN_IF_CMASK_MASK_Msk | |
| CAN_IF_CMASK_ARB_Msk | |
| CAN_IF_CMASK_CONTROL_Msk | |
| CAN_IF_CMASK_CLRINTPND_Msk | |
| (u8Release ? CAN_IF_CMASK_TXRQSTNEWDAT_Msk : 0UL) | |
| CAN_IF_CMASK_DATAA_Msk | |
| CAN_IF_CMASK_DATAB_Msk; | |
tCAN->IF[u8MsgIfNum].CREQ = 1UL + u8MsgObj; | |
while(tCAN->IF[u8MsgIfNum].CREQ & CAN_IF_CREQ_BUSY_Msk) | |
{ | |
/*Wait*/ | |
} | |
if((tCAN->IF[u8MsgIfNum].ARB2 & CAN_IF_ARB2_XTD_Msk) == 0U) | |
{ | |
/* standard ID*/ | |
pCanMsg->IdType = CAN_STD_ID; | |
pCanMsg->Id = (tCAN->IF[u8MsgIfNum].ARB2 & CAN_IF_ARB2_ID_Msk) >> 2; | |
} | |
else | |
{ | |
/* extended ID*/ | |
pCanMsg->IdType = CAN_EXT_ID; | |
u32Tmp = (((tCAN->IF[u8MsgIfNum].ARB2) & 0x1FFFUL) << 16); | |
u32Tmp |= tCAN->IF[u8MsgIfNum].ARB1; | |
pCanMsg->Id = u32Tmp; | |
} | |
pCanMsg->DLC = (uint8_t)(tCAN->IF[u8MsgIfNum].MCON & CAN_IF_MCON_DLC_Msk); | |
pCanMsg->Data[0] = (uint8_t)(tCAN->IF[u8MsgIfNum].DAT_A1 & CAN_IF_DAT_A1_DATA0_Msk); | |
pCanMsg->Data[1] = (uint8_t)((tCAN->IF[u8MsgIfNum].DAT_A1 & CAN_IF_DAT_A1_DATA1_Msk) >> CAN_IF_DAT_A1_DATA1_Pos); | |
pCanMsg->Data[2] = (uint8_t)(tCAN->IF[u8MsgIfNum].DAT_A2 & CAN_IF_DAT_A2_DATA2_Msk); | |
pCanMsg->Data[3] = (uint8_t)((tCAN->IF[u8MsgIfNum].DAT_A2 & CAN_IF_DAT_A2_DATA3_Msk) >> CAN_IF_DAT_A2_DATA3_Pos); | |
pCanMsg->Data[4] = (uint8_t)(tCAN->IF[u8MsgIfNum].DAT_B1 & CAN_IF_DAT_B1_DATA4_Msk); | |
pCanMsg->Data[5] = (uint8_t)((tCAN->IF[u8MsgIfNum].DAT_B1 & CAN_IF_DAT_B1_DATA5_Msk) >> CAN_IF_DAT_B1_DATA5_Pos); | |
pCanMsg->Data[6] = (uint8_t)(tCAN->IF[u8MsgIfNum].DAT_B2 & CAN_IF_DAT_B2_DATA6_Msk); | |
pCanMsg->Data[7] = (uint8_t)((tCAN->IF[u8MsgIfNum].DAT_B2 & CAN_IF_DAT_B2_DATA7_Msk) >> CAN_IF_DAT_B2_DATA7_Pos); | |
ReleaseIF(tCAN, (uint32_t)u8MsgIfNum); | |
return (int32_t)TRUE; | |
} | |
static int can_update_spt(int sampl_pt, int tseg, int *tseg1, int *tseg2) | |
{ | |
*tseg2 = tseg + 1 - (sampl_pt * (tseg + 1)) / 1000; | |
if(*tseg2 < TSEG2_MIN) | |
{ | |
*tseg2 = TSEG2_MIN; | |
} | |
if(*tseg2 > TSEG2_MAX) | |
{ | |
*tseg2 = TSEG2_MAX; | |
} | |
*tseg1 = tseg - *tseg2; | |
if(*tseg1 > TSEG1_MAX) | |
{ | |
*tseg1 = TSEG1_MAX; | |
*tseg2 = tseg - *tseg1; | |
} | |
return 1000 * (tseg + 1 - *tseg2) / (tseg + 1); | |
} | |
/** @endcond HIDDEN_SYMBOLS */ | |
/** | |
* @brief Set bus baud-rate. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32BaudRate The target CAN baud-rate. The range of u32BaudRate is 1~1000KHz. | |
* | |
* @return u32CurrentBitRate Real baud-rate value. | |
* | |
* @details The function is used to set bus timing parameter according current clock and target baud-rate. | |
*/ | |
uint32_t CAN_SetBaudRate(CAN_T *tCAN, uint32_t u32BaudRate) | |
{ | |
long rate; | |
long best_error = 1000000000, error = 0; | |
int best_tseg = 0, best_brp = 0, brp = 0; | |
int tsegall, tseg = 0, tseg1 = 0, tseg2 = 0; | |
int spt_error = 1000, spt = 0, sampl_pt; | |
int64_t clock_freq = 0; | |
uint32_t sjw = 1UL; | |
CAN_EnterInitMode(tCAN, 0U); | |
clock_freq = (int64_t)CLK_GetPCLK0Freq(); | |
if(u32BaudRate >= 1000000UL) | |
{ | |
u32BaudRate = 1000000UL; | |
} | |
/* Use CIA recommended sample points */ | |
if(u32BaudRate > 800000UL) | |
{ | |
sampl_pt = 750; | |
} | |
else if(u32BaudRate > 500000UL) | |
{ | |
sampl_pt = 800; | |
} | |
else | |
{ | |
sampl_pt = 875; | |
} | |
/* tseg even = round down, odd = round up */ | |
for(tseg = (TSEG1_MAX + TSEG2_MAX) * 2 + 1; tseg >= (TSEG1_MIN + TSEG2_MIN) * 2; tseg--) | |
{ | |
tsegall = 1 + tseg / 2; | |
/* Compute all possible tseg choices (tseg=tseg1+tseg2) */ | |
/* brp = (int32_t)(clock_freq / (tsegall * u32BaudRate)) + (tseg % 2); */ | |
brp = (int32_t)(clock_freq / ((int64_t)tsegall * (int32_t)u32BaudRate)) + (tseg % 2); | |
/* chose brp step which is possible in system */ | |
brp = (brp / BRP_INC) * BRP_INC; | |
if((brp >= BRP_MIN) && (brp <= BRP_MAX)) | |
{ | |
rate = (int32_t)(clock_freq / ((int64_t)brp * tsegall)); | |
error = (int32_t)u32BaudRate - rate; | |
/* tseg brp biterror */ | |
if(error < 0) | |
{ | |
error = -error; | |
} | |
if(error <= best_error) | |
{ | |
best_error = error; | |
if(error == 0) | |
{ | |
spt = can_update_spt(sampl_pt, tseg / 2, &tseg1, &tseg2); | |
error = sampl_pt - spt; | |
if(error < 0) | |
{ | |
error = -error; | |
} | |
if(error <= spt_error) | |
{ | |
spt_error = error; | |
best_tseg = tseg / 2; | |
best_brp = brp; | |
if(error == 0) | |
{ | |
break; | |
} | |
} | |
} | |
else | |
{ | |
best_tseg = tseg / 2; | |
best_brp = brp; | |
} | |
} | |
} | |
} | |
spt = can_update_spt(sampl_pt, best_tseg, &tseg1, &tseg2); | |
/* check for sjw user settings */ | |
/* bt->sjw is at least 1 -> sanitize upper bound to sjw_max */ | |
if(sjw > SJW_MAX) | |
{ | |
sjw = SJW_MAX; | |
} | |
/* bt->sjw must not be higher than tseg2 */ | |
if(tseg2 < (int32_t)sjw) | |
{ | |
sjw = (uint32_t)tseg2; | |
} | |
/* real bit-rate */ | |
u32BaudRate = (uint32_t)(int32_t)(clock_freq / (int32_t)(best_brp * (tseg1 + tseg2 + 1))); | |
tCAN->BTIME = (((uint32_t)tseg2 - 1UL) << CAN_BTIME_TSEG2_Pos) | (((uint32_t)tseg1 - 1UL) << CAN_BTIME_TSEG1_Pos) | | |
(((uint32_t)best_brp - 1UL) & CAN_BTIME_BRP_Msk) | (sjw << CAN_BTIME_SJW_Pos); | |
tCAN->BRPE = (((uint32_t)best_brp - 1UL) >> 6) & 0x0FUL; | |
/* DEBUG_PRINTF("\n bitrate = %d \n", CAN_GetCANBitRate(tCAN)); */ | |
CAN_LeaveInitMode(tCAN); | |
return u32BaudRate; | |
} | |
/** | |
* @brief The function is used to disable all CAN interrupt. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* | |
* @return None | |
* | |
* @details No Status Change Interrupt and Error Status Interrupt will be generated. | |
*/ | |
void CAN_Close(CAN_T *tCAN) | |
{ | |
CAN_DisableInt(tCAN, (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk)); | |
} | |
/** | |
* @brief Set CAN operation mode and target baud-rate. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32BaudRate The target CAN baud-rate. The range of u32BaudRate is 1~1000KHz. | |
* @param[in] u32Mode The CAN operation mode. Valid values are: | |
* - \ref CAN_NORMAL_MODE Normal operation. | |
* - \ref CAN_BASIC_MODE Basic mode. | |
* @return u32CurrentBitRate Real baud-rate value. | |
* | |
* @details Set bus timing parameter according current clock and target baud-rate. | |
* In Basic mode, IF1 Registers used as Tx Buffer, IF2 Registers used as Rx Buffer. | |
*/ | |
uint32_t CAN_Open(CAN_T *tCAN, uint32_t u32BaudRate, uint32_t u32Mode) | |
{ | |
uint32_t u32CurrentBitRate; | |
u32CurrentBitRate = CAN_SetBaudRate(tCAN, u32BaudRate); | |
if(u32Mode == CAN_BASIC_MODE) | |
{ | |
CAN_EnterTestMode(tCAN, (uint8_t)CAN_TEST_BASIC_Msk); | |
} | |
return u32CurrentBitRate; | |
} | |
/** | |
* @brief The function is used to configure a transmit object. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32MsgNum Specifies the Message object number, from 0 to 31. | |
* @param[in] pCanMsg Pointer to the message structure where received data is copied. | |
* | |
* @retval FALSE No useful interface. | |
* @retval TRUE Config message object success. | |
* | |
* @details The two sets of interface registers (IF1 and IF2) control the software access to the Message RAM. | |
* They buffer the data to be transferred to and from the RAM, avoiding conflicts between software accesses and message reception/transmission. | |
*/ | |
int32_t CAN_SetTxMsg(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T* pCanMsg) | |
{ | |
uint8_t u8MsgIfNum; | |
if((u8MsgIfNum = (uint8_t)LockIF_TL(tCAN)) == 2U) | |
{ | |
return (int32_t)FALSE; | |
} | |
/* update the contents needed for transmission*/ | |
tCAN->IF[u8MsgIfNum].CMASK = CAN_IF_CMASK_WRRD_Msk | CAN_IF_CMASK_MASK_Msk | CAN_IF_CMASK_ARB_Msk | | |
CAN_IF_CMASK_CONTROL_Msk | CAN_IF_CMASK_DATAA_Msk | CAN_IF_CMASK_DATAB_Msk; | |
if(pCanMsg->IdType == CAN_STD_ID) | |
{ | |
/* standard ID*/ | |
tCAN->IF[u8MsgIfNum].ARB1 = 0UL; | |
tCAN->IF[u8MsgIfNum].ARB2 = (((pCanMsg->Id) & 0x7FFUL) << 2) | CAN_IF_ARB2_DIR_Msk | CAN_IF_ARB2_MSGVAL_Msk; | |
} | |
else | |
{ | |
/* extended ID*/ | |
tCAN->IF[u8MsgIfNum].ARB1 = (pCanMsg->Id) & 0xFFFFUL; | |
tCAN->IF[u8MsgIfNum].ARB2 = (((pCanMsg->Id) & 0x1FFF0000UL) >> 16) | CAN_IF_ARB2_DIR_Msk | CAN_IF_ARB2_XTD_Msk | CAN_IF_ARB2_MSGVAL_Msk; | |
} | |
if(pCanMsg->FrameType) | |
{ | |
tCAN->IF[u8MsgIfNum].ARB2 |= CAN_IF_ARB2_DIR_Msk; | |
} | |
else | |
{ | |
tCAN->IF[u8MsgIfNum].ARB2 &= (~CAN_IF_ARB2_DIR_Msk); | |
} | |
tCAN->IF[u8MsgIfNum].DAT_A1 = ((uint32_t)pCanMsg->Data[1] << 8) | (uint32_t)pCanMsg->Data[0]; | |
tCAN->IF[u8MsgIfNum].DAT_A2 = ((uint32_t)pCanMsg->Data[3] << 8) | (uint32_t)pCanMsg->Data[2]; | |
tCAN->IF[u8MsgIfNum].DAT_B1 = ((uint32_t)pCanMsg->Data[5] << 8) | pCanMsg->Data[4]; | |
tCAN->IF[u8MsgIfNum].DAT_B2 = ((uint32_t)pCanMsg->Data[7] << 8) | pCanMsg->Data[6]; | |
tCAN->IF[u8MsgIfNum].MCON = CAN_IF_MCON_NEWDAT_Msk | pCanMsg->DLC | CAN_IF_MCON_TXIE_Msk | CAN_IF_MCON_EOB_Msk; | |
tCAN->IF[u8MsgIfNum].CREQ = 1UL + u32MsgNum; | |
ReleaseIF(tCAN, (uint32_t)u8MsgIfNum); | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief Set transmit request bit. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32MsgNum Specifies the Message object number, from 0 to 31. | |
* | |
* @return TRUE: Start transmit message. | |
* | |
* @details If a transmission is requested by programming bit TxRqst/NewDat (IFn_CMASK[2]), the TxRqst (IFn_MCON[8]) will be ignored. | |
*/ | |
int32_t CAN_TriggerTxMsg(CAN_T *tCAN, uint32_t u32MsgNum) | |
{ | |
uint8_t u8MsgIfNum; | |
if((u8MsgIfNum = (uint8_t)LockIF_TL(tCAN)) == 2U) | |
{ | |
return (int32_t)FALSE; | |
} | |
tCAN->STATUS &= (~CAN_STATUS_TXOK_Msk); | |
/* read the message contents*/ | |
tCAN->IF[u8MsgIfNum].CMASK = CAN_IF_CMASK_CLRINTPND_Msk | |
| CAN_IF_CMASK_TXRQSTNEWDAT_Msk; | |
tCAN->IF[u8MsgIfNum].CREQ = 1UL + u32MsgNum; | |
while(tCAN->IF[u8MsgIfNum].CREQ & CAN_IF_CREQ_BUSY_Msk) | |
{ | |
/*Wait*/ | |
} | |
tCAN->IF[u8MsgIfNum].CMASK = CAN_IF_CMASK_WRRD_Msk | CAN_IF_CMASK_TXRQSTNEWDAT_Msk; | |
tCAN->IF[u8MsgIfNum].CREQ = 1UL + u32MsgNum; | |
ReleaseIF(tCAN, (uint32_t)u8MsgIfNum); | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief Enable CAN interrupt. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32Mask Interrupt Mask. Valid values are: | |
* - \ref CAN_CON_IE_Msk Module interrupt enable. | |
* - \ref CAN_CON_SIE_Msk Status change interrupt enable. | |
* - \ref CAN_CON_EIE_Msk Error interrupt enable. | |
* | |
* @return None | |
* | |
* @details The application software has two possibilities to follow the source of a message interrupt. | |
* First, it can follow the IntId in the Interrupt Register and second it can poll the Interrupt Pending Register. | |
*/ | |
void CAN_EnableInt(CAN_T *tCAN, uint32_t u32Mask) | |
{ | |
tCAN->CON = (tCAN->CON & ~(CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk)) | | |
(u32Mask & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk)); | |
} | |
/** | |
* @brief Disable CAN interrupt. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32Mask Interrupt Mask. (CAN_CON_IE_Msk / CAN_CON_SIE_Msk / CAN_CON_EIE_Msk). | |
* | |
* @return None | |
* | |
* @details The interrupt remains active until the Interrupt Register is back to value zero (the cause of the interrupt is reset) or until IE is reset. | |
*/ | |
void CAN_DisableInt(CAN_T *tCAN, uint32_t u32Mask) | |
{ | |
tCAN->CON = tCAN->CON & ~((u32Mask & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk))); | |
} | |
/** | |
* @brief The function is used to configure a receive message object. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32MsgNum Specifies the Message object number, from 0 to 31. | |
* @param[in] u32IDType Specifies the identifier type of the frames that will be transmitted. Valid values are: | |
* - \ref CAN_STD_ID The 11-bit identifier. | |
* - \ref CAN_EXT_ID The 29-bit identifier. | |
* @param[in] u32ID Specifies the identifier used for acceptance filtering. | |
* | |
* @retval FALSE No useful interface. | |
* @retval TRUE Configure a receive message object success. | |
* | |
* @details If the RxIE bit (CAN_IFn_MCON[10]) is set, the IntPnd bit (CAN_IFn_MCON[13]) | |
* will be set when a received Data Frame is accepted and stored in the Message Object. | |
*/ | |
int32_t CAN_SetRxMsg(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32IDType, uint32_t u32ID) | |
{ | |
uint32_t u32TimeOutCount = 0UL; | |
while(CAN_SetRxMsgObj(tCAN, (uint8_t)u32MsgNum, (uint8_t)u32IDType, u32ID, (uint8_t)TRUE) == (int32_t)FALSE) | |
{ | |
if(++u32TimeOutCount >= RETRY_COUNTS) | |
{ | |
return (int32_t)FALSE; | |
} | |
} | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief The function is used to configure a receive message object. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32MsgNum Specifies the Message object number, from 0 to 31. | |
* @param[in] u32IDType Specifies the identifier type of the frames that will be transmitted. Valid values are: | |
* - \ref CAN_STD_ID The 11-bit identifier. | |
* - \ref CAN_EXT_ID The 29-bit identifier. | |
* @param[in] u32ID Specifies the identifier used for acceptance filtering. | |
* @param[in] u32IDMask Specifies the identifier mask used for acceptance filtering. | |
* | |
* @retval FALSE No useful interface. | |
* @retval TRUE Configure a receive message object success. | |
* | |
* @details If the RxIE bit (CAN_IFn_MCON[10]) is set, the IntPnd bit (CAN_IFn_MCON[13]) | |
* will be set when a received Data Frame is accepted and stored in the Message Object. | |
*/ | |
int32_t CAN_SetRxMsgAndMsk(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32IDType, uint32_t u32ID, uint32_t u32IDMask) | |
{ | |
uint32_t u32TimeOutCount = 0UL; | |
while(CAN_SetRxMsgObjAndMsk(tCAN, (uint8_t)u32MsgNum, (uint8_t)u32IDType, u32ID, u32IDMask, (uint8_t)TRUE) == (int32_t)FALSE) | |
{ | |
if(++u32TimeOutCount >= RETRY_COUNTS) | |
{ | |
return (int32_t)FALSE; | |
} | |
} | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief The function is used to configure several receive message objects. | |
* | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32MsgNum The starting MSG RAM number(0 ~ 31). | |
* @param[in] u32MsgCount the number of MSG RAM of the FIFO. | |
* @param[in] u32IDType Specifies the identifier type of the frames that will be transmitted. Valid values are: | |
* - \ref CAN_STD_ID The 11-bit identifier. | |
* - \ref CAN_EXT_ID The 29-bit identifier. | |
* @param[in] u32ID Specifies the identifier used for acceptance filtering. | |
* | |
* @retval FALSE No useful interface. | |
* @retval TRUE Configure receive message objects success. | |
* | |
* @details The Interface Registers avoid conflict between the CPU accesses to the Message RAM and CAN message reception | |
* and transmission by buffering the data to be transferred. | |
*/ | |
int32_t CAN_SetMultiRxMsg(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32MsgCount, uint32_t u32IDType, uint32_t u32ID) | |
{ | |
uint32_t i = 0UL; | |
uint32_t u32TimeOutCount; | |
uint32_t u32EOB_Flag = 0UL; | |
for(i = 1UL; i < u32MsgCount; i++) | |
{ | |
u32TimeOutCount = 0UL; | |
u32MsgNum += (i - 1UL); | |
if(i == u32MsgCount) | |
{ | |
u32EOB_Flag = 1UL; | |
} | |
while(CAN_SetRxMsgObj(tCAN, (uint8_t)u32MsgNum, (uint8_t)u32IDType, u32ID, (uint8_t)u32EOB_Flag) == (int32_t)FALSE) | |
{ | |
if(++u32TimeOutCount >= RETRY_COUNTS) | |
{ | |
return (int32_t)FALSE; | |
} | |
} | |
} | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief Send CAN message. | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32MsgNum Specifies the Message object number, from 0 to 31. | |
* @param[in] pCanMsg Pointer to the message structure where received data is copied. | |
* | |
* @retval FALSE 1. When operation in basic mode: Transmit message time out. \n | |
* 2. When operation in normal mode: No useful interface. \n | |
* @retval TRUE Transmit Message success. | |
* | |
* @details The receive/transmit priority for the Message Objects is attached to the message number. | |
* Message Object 1 has the highest priority, while Message Object 32 has the lowest priority. | |
*/ | |
int32_t CAN_Transmit(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T* pCanMsg) | |
{ | |
uint32_t cond0, cond1; | |
cond0 = tCAN->CON & CAN_CON_TEST_Msk; | |
cond1 = tCAN->TEST & CAN_TEST_BASIC_Msk; | |
if(cond0 && cond1) | |
{ | |
return (CAN_BasicSendMsg(tCAN, pCanMsg)); | |
} | |
else | |
{ | |
if(CAN_SetTxMsg(tCAN, u32MsgNum, pCanMsg) == (int32_t)FALSE) | |
{ | |
return (int32_t)FALSE; | |
} | |
CAN_TriggerTxMsg(tCAN, u32MsgNum); | |
} | |
return (int32_t)TRUE; | |
} | |
/** | |
* @brief Gets the message, if received. | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32MsgNum Specifies the Message object number, from 0 to 31. | |
* @param[in] pCanMsg Pointer to the message structure where received data is copied. | |
* | |
* @retval FALSE No any message received. | |
* @retval TRUE Receive Message success. | |
* | |
* @details The Interface Registers avoid conflict between the CPU accesses to the Message RAM and CAN message reception | |
* and transmission by buffering the data to be transferred. | |
*/ | |
int32_t CAN_Receive(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T* pCanMsg) | |
{ | |
uint32_t cond0, cond1; | |
cond0 = tCAN->CON & CAN_CON_TEST_Msk; | |
cond1 = tCAN->TEST & CAN_TEST_BASIC_Msk; | |
if(cond0 && cond1) | |
{ | |
return (CAN_BasicReceiveMsg(tCAN, pCanMsg)); | |
} | |
else | |
{ | |
return CAN_ReadMsgObj(tCAN, (uint8_t)u32MsgNum, (uint8_t)TRUE, pCanMsg); | |
} | |
} | |
/** | |
* @brief Clear interrupt pending bit. | |
* @param[in] tCAN The pointer to CAN module base address. | |
* @param[in] u32MsgNum Specifies the Message object number, from 0 to 31. | |
* | |
* @return None | |
* | |
* @details An interrupt remains pending until the application software has cleared it. | |
*/ | |
void CAN_CLR_INT_PENDING_BIT(CAN_T *tCAN, uint8_t u32MsgNum) | |
{ | |
uint32_t u32MsgIfNum; | |
if((u32MsgIfNum = LockIF_TL(tCAN)) == 2UL) | |
{ | |
u32MsgIfNum = 0UL; | |
} | |
tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_CLRINTPND_Msk | CAN_IF_CMASK_TXRQSTNEWDAT_Msk; | |
tCAN->IF[u32MsgIfNum].CREQ = 1UL + u32MsgNum; | |
ReleaseIF(tCAN, u32MsgIfNum); | |
} | |
/*@}*/ /* end of group CAN_EXPORTED_FUNCTIONS */ | |
/*@}*/ /* end of group CAN_Driver */ | |
/*@}*/ /* end of group Standard_Driver */ | |
/*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/ | |