📄 lpc17xx_can.c
字号:
{
CANx->TFI3 |= (1<<31); //set bit FF
}
else
{
CANx->TFI3 &= ~(1<<31);
}
/* Write CAN ID*/
CANx->TID3 = CAN_Msg->id;
/*Write first 4 data bytes*/
data = (CAN_Msg->dataA[0])|(((CAN_Msg->dataA[1]))<<8)|((CAN_Msg->dataA[2])<<16)|((CAN_Msg->dataA[3])<<24);
CANx->TDA3 = data;
/*Write second 4 data bytes*/
data = (CAN_Msg->dataB[0])|(((CAN_Msg->dataB[1]))<<8)|((CAN_Msg->dataB[2])<<16)|((CAN_Msg->dataB[3])<<24);
CANx->TDB3 = data;
/*Write transmission request*/
CANx->CMR = 0x81;
return SUCCESS;
}
else
{
return ERROR;
}
}
/********************************************************************//**
* @brief Receive message data
* @param[in] CANx pointer to LPC_CAN_TypeDef, should be:
* - LPC_CAN1: CAN1 peripheral
* - LPC_CAN2: CAN2 peripheral
* @param[in] CAN_Msg point to the CAN_MSG_Type Struct, it will contain received
* message information such as: ID, DLC, RTR, ID Format
* @return Status:
* - SUCCESS: receive message successfully
* - ERROR: receive message unsuccessfully
*********************************************************************/
Status CAN_ReceiveMsg (LPC_CAN_TypeDef *CANx, CAN_MSG_Type *CAN_Msg)
{
uint32_t data;
CHECK_PARAM(PARAM_CANx(CANx));
//check status of Receive Buffer
if((CANx->SR &0x00000001))
{
/* Receive message is available */
/* Read frame informations */
CAN_Msg->format = (uint8_t)(((CANx->RFS) & 0x80000000)>>31);
CAN_Msg->type = (uint8_t)(((CANx->RFS) & 0x40000000)>>30);
CAN_Msg->len = (uint8_t)(((CANx->RFS) & 0x000F0000)>>16);
/* Read CAN message identifier */
CAN_Msg->id = CANx->RID;
/* Read the data if received message was DATA FRAME */
if (CAN_Msg->type == DATA_FRAME)
{
/* Read first 4 data bytes */
data = CANx->RDA;
*((uint8_t *) &CAN_Msg->dataA[0])= data & 0x000000FF;
*((uint8_t *) &CAN_Msg->dataA[1])= (data & 0x0000FF00)>>8;;
*((uint8_t *) &CAN_Msg->dataA[2])= (data & 0x00FF0000)>>16;
*((uint8_t *) &CAN_Msg->dataA[3])= (data & 0xFF000000)>>24;
/* Read second 4 data bytes */
data = CANx->RDB;
*((uint8_t *) &CAN_Msg->dataB[0])= data & 0x000000FF;
*((uint8_t *) &CAN_Msg->dataB[1])= (data & 0x0000FF00)>>8;
*((uint8_t *) &CAN_Msg->dataB[2])= (data & 0x00FF0000)>>16;
*((uint8_t *) &CAN_Msg->dataB[3])= (data & 0xFF000000)>>24;
/*release receive buffer*/
CANx->CMR = 0x04;
}
else
{
/* Received Frame is a Remote Frame, not have data, we just receive
* message information only */
CANx->CMR = 0x04; /*release receive buffer*/
return SUCCESS;
}
}
else
{
// no receive message available
return ERROR;
}
return SUCCESS;
}
/********************************************************************//**
* @brief Receive FullCAN Object
* @param[in] CANAFx: CAN Acceptance Filter register, should be: LPC_CANAF
* @param[in] CAN_Msg point to the CAN_MSG_Type Struct, it will contain received
* message information such as: ID, DLC, RTR, ID Format
* @return CAN_ERROR, could be:
* - CAN_FULL_OBJ_NOT_RCV: FullCAN Object is not be received
* - CAN_OK: Received FullCAN Object successful
*
*********************************************************************/
CAN_ERROR FCAN_ReadObj (LPC_CANAF_TypeDef* CANAFx, CAN_MSG_Type *CAN_Msg)
{
uint32_t *pSrc, data;
uint32_t interrut_word, msg_idx, test_bit, head_idx, tail_idx;
CHECK_PARAM(PARAM_CANAFx(CANAFx));
interrut_word = 0;
if (LPC_CANAF->FCANIC0 != 0)
{
interrut_word = LPC_CANAF->FCANIC0;
head_idx = 0;
tail_idx = 31;
}
else if (LPC_CANAF->FCANIC1 != 0)
{
interrut_word = LPC_CANAF->FCANIC1;
head_idx = 32;
tail_idx = 63;
}
if (interrut_word != 0)
{
/* Detect for interrupt pending */
msg_idx = 0;
for (msg_idx = head_idx; msg_idx <= tail_idx; msg_idx++)
{
test_bit = interrut_word & 0x1;
interrut_word = interrut_word >> 1;
if (test_bit)
{
pSrc = (uint32_t *) (LPC_CANAF->ENDofTable + LPC_CANAF_RAM_BASE + msg_idx * 12);
/* Has been finished updating the content */
if ((*pSrc & 0x03000000L) == 0x03000000L)
{
/*clear semaphore*/
*pSrc &= 0xFCFFFFFF;
/*Set to DatA*/
pSrc++;
/* Copy to dest buf */
data = *pSrc;
*((uint8_t *) &CAN_Msg->dataA[0])= data & 0x000000FF;
*((uint8_t *) &CAN_Msg->dataA[1])= (data & 0x0000FF00)>>8;
*((uint8_t *) &CAN_Msg->dataA[2])= (data & 0x00FF0000)>>16;
*((uint8_t *) &CAN_Msg->dataA[3])= (data & 0xFF000000)>>24;
/*Set to DatB*/
pSrc++;
/* Copy to dest buf */
data = *pSrc;
*((uint8_t *) &CAN_Msg->dataB[0])= data & 0x000000FF;
*((uint8_t *) &CAN_Msg->dataB[1])= (data & 0x0000FF00)>>8;
*((uint8_t *) &CAN_Msg->dataB[2])= (data & 0x00FF0000)>>16;
*((uint8_t *) &CAN_Msg->dataB[3])= (data & 0xFF000000)>>24;
/*Back to Dat1*/
pSrc -= 2;
CAN_Msg->id = *pSrc & 0x7FF;
CAN_Msg->len = (uint8_t) (*pSrc >> 16) & 0x0F;
CAN_Msg->format = 0; //FullCAN Object ID always is 11-bit value
CAN_Msg->type = (uint8_t)(*pSrc >> 30) &0x01;
/*Re-read semaphore*/
if ((*pSrc & 0x03000000L) == 0)
{
return CAN_OK;
}
}
}
}
}
return CAN_FULL_OBJ_NOT_RCV;
}
/********************************************************************//**
* @brief Get CAN Control Status
* @param[in] CANx pointer to LPC_CAN_TypeDef, should be:
* - LPC_CAN1: CAN1 peripheral
* - LPC_CAN2: CAN2 peripheral
* @param[in] arg: type of CAN status to get from CAN status register
* Should be:
* - CANCTRL_GLOBAL_STS: CAN Global Status
* - CANCTRL_INT_CAP: CAN Interrupt and Capture
* - CANCTRL_ERR_WRN: CAN Error Warning Limit
* - CANCTRL_STS: CAN Control Status
* @return Current Control Status that you want to get value
*********************************************************************/
uint32_t CAN_GetCTRLStatus (LPC_CAN_TypeDef* CANx, CAN_CTRL_STS_Type arg)
{
CHECK_PARAM(PARAM_CANx(CANx));
CHECK_PARAM(PARAM_CTRL_STS_TYPE(arg));
switch (arg)
{
case CANCTRL_GLOBAL_STS:
return CANx->GSR;
case CANCTRL_INT_CAP:
return CANx->ICR;
case CANCTRL_ERR_WRN:
return CANx->EWL;
default: // CANCTRL_STS
return CANx->SR;
}
}
/********************************************************************//**
* @brief Get CAN Central Status
* @param[in] CANCRx point to LPC_CANCR_TypeDef, should be: LPC_CANCR
* @param[in] arg: type of CAN status to get from CAN Central status register
* Should be:
* - CANCR_TX_STS: Central CAN Tx Status
* - CANCR_RX_STS: Central CAN Rx Status
* - CANCR_MS: Central CAN Miscellaneous Status
* @return Current Central Status that you want to get value
*********************************************************************/
uint32_t CAN_GetCRStatus (LPC_CANCR_TypeDef* CANCRx, CAN_CR_STS_Type arg)
{
CHECK_PARAM(PARAM_CANCRx(CANCRx));
CHECK_PARAM(PARAM_CR_STS_TYPE(arg));
switch (arg)
{
case CANCR_TX_STS:
return CANCRx->CANTxSR;
case CANCR_RX_STS:
return CANCRx->CANRxSR;
default: // CANCR_MS
return CANCRx->CANMSR;
}
}
/********************************************************************//**
* @brief Enable/Disable CAN Interrupt
* @param[in] CANx pointer to LPC_CAN_TypeDef, should be:
* - LPC_CAN1: CAN1 peripheral
* - LPC_CAN2: CAN2 peripheral
* @param[in] arg: type of CAN interrupt that you want to enable/disable
* Should be:
* - CANINT_RIE: CAN Receiver Interrupt Enable
* - CANINT_TIE1: CAN Transmit Interrupt Enable
* - CANINT_EIE: CAN Error Warning Interrupt Enable
* - CANINT_DOIE: CAN Data Overrun Interrupt Enable
* - CANINT_WUIE: CAN Wake-Up Interrupt Enable
* - CANINT_EPIE: CAN Error Passive Interrupt Enable
* - CANINT_ALIE: CAN Arbitration Lost Interrupt Enable
* - CANINT_BEIE: CAN Bus Error Interrupt Enable
* - CANINT_IDIE: CAN ID Ready Interrupt Enable
* - CANINT_TIE2: CAN Transmit Interrupt Enable for Buffer2
* - CANINT_TIE3: CAN Transmit Interrupt Enable for Buffer3
* - CANINT_FCE: FullCAN Interrupt Enable
* @param[in] NewState: New state of this function, should be:
* - ENABLE
* - DISABLE
* @return none
*********************************************************************/
void CAN_IRQCmd (LPC_CAN_TypeDef* CANx, CAN_INT_EN_Type arg, FunctionalState NewState)
{
CHECK_PARAM(PARAM_CANx(CANx));
CHECK_PARAM(PARAM_INT_EN_TYPE(arg));
CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState));
if(NewState == ENABLE)
{
if(arg==CANINT_FCE)
{
LPC_CANAF->AFMR = 0x01;
LPC_CANAF->FCANIE = 0x01;
LPC_CANAF->AFMR = 0x04;
}
else
CANx->IER |= (1 << arg);
}
else
{
if(arg==CANINT_FCE){
LPC_CANAF->AFMR = 0x01;
LPC_CANAF->FCANIE = 0x01;
LPC_CANAF->AFMR = 0x00;
}
else
CANx->IER &= ~(1 << arg);
}
}
/********************************************************************//**
* @brief Setting Acceptance Filter mode
* @param[in] CANAFx point to LPC_CANAF_TypeDef object, should be: LPC_CANAF
* @param[in] AFMode: type of AF mode that you want to set, should be:
* - CAN_Normal: Normal mode
* - CAN_AccOff: Acceptance Filter Off Mode
* - CAN_AccBP: Acceptance Fileter Bypass Mode
* - CAN_eFCAN: FullCAN Mode Enhancement
* @return none
*********************************************************************/
void CAN_SetAFMode (LPC_CANAF_TypeDef* CANAFx, CAN_AFMODE_Type AFMode)
{
CHECK_PARAM(PARAM_CANAFx(CANAFx));
CHECK_PARAM(PARAM_AFMODE_TYPE(AFMode));
switch(AFMode)
{
case CAN_Normal:
CANAFx->AFMR = 0x00;
break;
case CAN_AccOff:
CANAFx->AFMR = 0x01;
break;
case CAN_AccBP:
CANAFx->AFMR = 0x02;
break;
case CAN_eFCAN:
CANAFx->AFMR = 0x04;
break;
}
}
/********************************************************************//**
* @brief Enable/Disable CAN Mode
* @param[in] CANx pointer to LPC_CAN_TypeDef, should be:
* - LPC_CAN1: CAN1 peripheral
* - LPC_CAN2: CAN2 peripheral
* @param[in] mode: type of CAN mode that you want to enable/disable, should be:
* - CAN_OPERATING_MODE: Normal Operating Mode
* - CAN_RESET_MODE: Reset Mode
* - CAN_LISTENONLY_MODE: Listen Only Mode
* - CAN_SELFTEST_MODE: Self Test Mode
* - CAN_TXPRIORITY_MODE: Transmit Priority Mode
* - CAN_SLEEP_MODE: Sleep Mode
* - CAN_RXPOLARITY_MODE: Receive Polarity Mode
* - CAN_TEST_MODE: Test Mode
* @param[in] NewState: New State of this function, should be:
* - ENABLE
* - DISABLE
* @return none
*********************************************************************/
void CAN_ModeConfig(LPC_CAN_TypeDef* CANx, CAN_MODE_Type mode, FunctionalState NewState)
{
CHECK_PARAM(PARAM_CANx(CANx));
CHECK_PARAM(PARAM_MODE_TYPE(mode));
CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState));
switch(mode)
{
case CAN_OPERATING_MODE:
CANx->MOD = 0x00;
break;
case CAN_RESET_MODE:
if(NewState == ENABLE)
CANx->MOD |=CAN_MOD_RM;
else
CANx->MOD &= ~CAN_MOD_RM;
break;
case CAN_LISTENONLY_MODE:
CANx->MOD |=CAN_MOD_RM;//Enter Reset mode
if(NewState == ENABLE)
CANx->MOD |=CAN_MOD_LOM;
else
CANx->MOD &=~CAN_MOD_LOM;
CANx->MOD &=~CAN_MOD_RM;//Release Reset mode
break;
case CAN_SELFTEST_MODE:
CANx->MOD |=CAN_MOD_RM;//Enter Reset mode
if(NewState == ENABLE)
CANx->MOD |=CAN_MOD_STM;
else
CANx->MOD &=~CAN_MOD_STM;
CANx->MOD &=~CAN_MOD_RM;//Release Reset mode
break;
case CAN_TXPRIORITY_MODE:
if(NewState == ENABLE)
CANx->MOD |=CAN_MOD_TPM;
else
CANx->MOD &=~CAN_MOD_TPM;
break;
case CAN_SLEEP_MODE:
if(NewState == ENABLE)
CANx->MOD |=CAN_MOD_SM;
else
CANx->MOD &=~CAN_MOD_SM;
break;
case CAN_RXPOLARITY_MODE:
if(NewState == ENABLE)
CANx->MOD |=CAN_MOD_RPM;
else
CANx->MOD &=~CAN_MOD_RPM;
break;
case CAN_TEST_MODE:
if(NewState == ENABLE)
CANx->MOD |=CAN_MOD_TM;
else
CANx->MOD &=~CAN_MOD_TM;
break;
}
}
/*********************************************************************//**
* @brief Set CAN command request
* @param[in] CANx point to CAN peripheral selected, should be:
* - LPC_CAN1: CAN1 peripheral
* - LPC_CAN2: CAN2 peripheral
* @param[in] CMRType command request type, should be:
* - CAN_CMR_TR: Transmission request
* - CAN_CMR_AT: Abort Transmission request
* - CAN_CMR_RRB: Release Receive Buffer request
* - CAN_CMR_CDO: Clear Data Overrun request
* - CAN_CMR_SRR: Self Reception request
* - CAN_CMR_STB1: Select Tx Buffer 1 request
* - CAN_CMR_STB2: Select Tx Buffer 2 request
* - CAN_CMR_STB3: Select Tx Buffer 3 request
* @return CANICR (CAN interrupt and Capture register) value
**********************************************************************/
void CAN_SetCommand(LPC_CAN_TypeDef* CANx, uint32_t CMRType)
{
CHECK_PARAM(PARAM_CANx(CANx));
CANx->CMR |= CMRType;
}
/*********************************************************************//**
* @brief Get CAN interrupt status
* @param[in] CANx point to CAN peripheral selected, should be:
* - LPC_CAN1: CAN1 peripheral
* - LPC_CAN2: CAN2 peripheral
* @return CANICR (CAN interrupt and Capture register) value
**********************************************************************/
uint32_t CAN_IntGetStatus(LPC_CAN_TypeDef* CANx)
{
CHECK_PARAM(PARAM_CANx(CANx));
return CANx->ICR;
}
/*********************************************************************//**
* @brief Check if FullCAN interrupt enable or not
* @param[in] CANAFx point to LPC_CANAF_TypeDef object, should be: LPC_CANAF
* @return IntStatus, could be:
* - SET: if FullCAN interrupt is enable
* - RESET: if FullCAN interrupt is disable
**********************************************************************/
IntStatus CAN_FullCANIntGetStatus (LPC_CANAF_TypeDef* CANAFx)
{
CHECK_PARAM( PARAM_CANAFx(CANAFx));
if (CANAFx->FCANIE)
return SET;
return RESET;
}
/*********************************************************************//**
* @brief Get value of FullCAN interrupt and capture register
* @param[in] CANAFx point to LPC_CANAF_TypeDef object, should be: LPC_CANAF
* @param[in] type: FullCAN IC type, should be:
* - FULLCAN_IC0: FullCAN Interrupt Capture 0
* - FULLCAN_IC1: FullCAN Interrupt Capture 1
* @return FCANIC0 or FCANIC1 (FullCAN interrupt and Capture register) value
**********************************************************************/
uint32_t CAN_FullCANPendGetStatus(LPC_CANAF_TypeDef* CANAFx, FullCAN_IC_Type type)
{
CHECK_PARAM(PARAM_CANAFx(CANAFx));
CHECK_PARAM( PARAM_FULLCAN_IC(type));
if (type == FULLCAN_IC0)
return CANAFx->FCANIC0;
return CANAFx->FCANIC1;
}
/* End of Public Variables ---------------------------------------------------------- */
/**
* @}
*/
#endif /* _CAN */
/**
* @}
*/
/* --------------------------------- End Of File ------------------------------ */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -