1097 lines
36 KiB
C
1097 lines
36 KiB
C
/*
|
|
* Copyright (c) 2006-2018, RT-Thread Development Team
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2018-08-05 Xeon Xu the first version
|
|
* 2019-01-22 YLZ port from stm324xx-HAL to bsp stm3210x-HAL
|
|
* 2019-02-19 YLZ add support EXTID RTR Frame. modify send, recv functions.
|
|
* fix bug.port to BSP [stm32]
|
|
*/
|
|
|
|
#include "drv_can.h"
|
|
|
|
#ifdef RT_USING_CAN
|
|
|
|
#if defined (SOC_SERIES_STM32F1)
|
|
static const struct stm_baud_rate_tab can_baud_rate_tab[] =
|
|
{
|
|
{CAN1MBaud , (CAN_SJW_2TQ | CAN_BS1_8TQ | CAN_BS2_3TQ | 3)},
|
|
{CAN800kBaud, (CAN_SJW_2TQ | CAN_BS1_5TQ | CAN_BS2_3TQ | 5)},
|
|
{CAN500kBaud, (CAN_SJW_2TQ | CAN_BS1_8TQ | CAN_BS2_3TQ | 6)},
|
|
{CAN250kBaud, (CAN_SJW_2TQ | CAN_BS1_8TQ | CAN_BS2_3TQ | 12)},
|
|
{CAN125kBaud, (CAN_SJW_2TQ | CAN_BS1_8TQ | CAN_BS2_3TQ | 24)},
|
|
{CAN100kBaud, (CAN_SJW_2TQ | CAN_BS1_8TQ | CAN_BS2_3TQ | 30)},
|
|
{CAN50kBaud , (CAN_SJW_2TQ | CAN_BS1_8TQ | CAN_BS2_3TQ | 60)},
|
|
{CAN20kBaud , (CAN_SJW_2TQ | CAN_BS1_8TQ | CAN_BS2_3TQ | 150)},
|
|
{CAN10kBaud , (CAN_SJW_2TQ | CAN_BS1_8TQ | CAN_BS2_3TQ | 300)}
|
|
};
|
|
#elif defined (SOC_SERIES_STM32F4)
|
|
static const struct stm_baud_rate_tab can_baud_rate_tab[] =
|
|
{
|
|
{CAN1MBaud , (CAN_SJW_2TQ | CAN_BS1_9TQ | CAN_BS2_4TQ | 3)},
|
|
{CAN800kBaud, (CAN_SJW_2TQ | CAN_BS1_8TQ | CAN_BS2_4TQ | 4)},
|
|
{CAN500kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ | CAN_BS2_4TQ | 6)},
|
|
{CAN250kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ | CAN_BS2_4TQ | 12)},
|
|
{CAN125kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ | CAN_BS2_4TQ | 24)},
|
|
{CAN100kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ | CAN_BS2_4TQ | 30)},
|
|
{CAN50kBaud , (CAN_SJW_2TQ | CAN_BS1_9TQ | CAN_BS2_4TQ | 60)},
|
|
{CAN20kBaud , (CAN_SJW_2TQ | CAN_BS1_9TQ | CAN_BS2_4TQ | 150)},
|
|
{CAN10kBaud , (CAN_SJW_2TQ | CAN_BS1_9TQ | CAN_BS2_4TQ | 300)}
|
|
};
|
|
#endif
|
|
|
|
#define BAUD_DATA(TYPE,NO) \
|
|
((can_baud_rate_tab[NO].confdata & TYPE##MASK))
|
|
|
|
static rt_uint32_t get_can_baud_index(rt_uint32_t baud)
|
|
{
|
|
rt_uint32_t len, index, default_index;
|
|
|
|
len = sizeof(can_baud_rate_tab) / sizeof(can_baud_rate_tab[0]);
|
|
default_index = len;
|
|
|
|
for(index = 0; index < len; index++)
|
|
{
|
|
if(can_baud_rate_tab[index].baud_rate == baud)
|
|
return index;
|
|
|
|
if(can_baud_rate_tab[index].baud_rate == 1000UL * 250)
|
|
default_index = index;
|
|
}
|
|
|
|
if(default_index != len)
|
|
return default_index;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef BSP_USING_CAN1
|
|
static struct stm32_drv_can drv_can1;
|
|
struct rt_can_device dev_can1;
|
|
/**
|
|
* @brief This function handles CAN1 TX interrupts.
|
|
*/
|
|
void CAN1_TX_IRQHandler(void)
|
|
{
|
|
rt_interrupt_enter();
|
|
CAN_HandleTypeDef *hcan;
|
|
hcan = &drv_can1.CanHandle;
|
|
|
|
if (__HAL_CAN_TRANSMIT_STATUS(hcan, CAN_TXMAILBOX_0))
|
|
{
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_TXOK0))
|
|
{
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_TX_DONE | 0 << 8);
|
|
}
|
|
else
|
|
{
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_TX_FAIL | 0 << 8);
|
|
}
|
|
/* Write 0 to Clear transmission status flag RQCPx */
|
|
SET_BIT(hcan->Instance->TSR, CAN_TSR_RQCP0);
|
|
}
|
|
|
|
else if (__HAL_CAN_TRANSMIT_STATUS(hcan, CAN_TXMAILBOX_1))
|
|
{
|
|
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_TXOK1))
|
|
{
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_TX_DONE | 1 << 8);
|
|
}
|
|
else
|
|
{
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_TX_FAIL | 1 << 8);
|
|
}
|
|
/* Write 0 to Clear transmission status flag RQCPx */
|
|
SET_BIT(hcan->Instance->TSR, CAN_TSR_RQCP1);
|
|
}
|
|
|
|
else if (__HAL_CAN_TRANSMIT_STATUS(hcan, CAN_TXMAILBOX_2))
|
|
{
|
|
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_TXOK2))
|
|
{
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_TX_DONE | 2 << 8);
|
|
}
|
|
else
|
|
{
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_TX_FAIL | 2 << 8);
|
|
}
|
|
/* Write 0 to Clear transmission status flag RQCPx */
|
|
SET_BIT(hcan->Instance->TSR, CAN_TSR_RQCP2);
|
|
}
|
|
|
|
rt_interrupt_leave();
|
|
}
|
|
|
|
/**
|
|
* @brief This function handles CAN1 RX0 interrupts.
|
|
*/
|
|
void CAN1_RX0_IRQHandler(void)
|
|
{
|
|
rt_interrupt_enter();
|
|
|
|
CanRxMsgTypeDef* pRxMsg = NULL;
|
|
CAN_HandleTypeDef *hcan;
|
|
hcan = &drv_can1.CanHandle;
|
|
/* check FMP0 and get data */
|
|
while (__HAL_CAN_MSG_PENDING(hcan, CAN_FIFO0) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FMP0) != RESET)
|
|
{
|
|
/* beigin get data */
|
|
|
|
/* Set RxMsg pointer */
|
|
pRxMsg = hcan->pRxMsg;
|
|
/* Get the Id */
|
|
pRxMsg->IDE = (uint8_t)0x04U & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RIR;
|
|
if (pRxMsg->IDE == CAN_ID_STD)
|
|
{
|
|
pRxMsg->StdId = 0x000007FFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RIR >> 21U);
|
|
}
|
|
else
|
|
{
|
|
pRxMsg->ExtId = 0x1FFFFFFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RIR >> 3U);
|
|
}
|
|
|
|
pRxMsg->RTR = (uint8_t)0x02U & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RIR;
|
|
/* Get the DLC */
|
|
pRxMsg->DLC = (uint8_t)0x0FU & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDTR;
|
|
/* Get the FIFONumber */
|
|
pRxMsg->FIFONumber = CAN_FIFO0;
|
|
/* Get the FMI */
|
|
pRxMsg->FMI = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDTR >> 8U);
|
|
/* Get the data field */
|
|
pRxMsg->Data[0] = (uint8_t)0xFFU & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDLR;
|
|
pRxMsg->Data[1] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDLR >> 8U);
|
|
pRxMsg->Data[2] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDLR >> 16U);
|
|
pRxMsg->Data[3] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDLR >> 24U);
|
|
pRxMsg->Data[4] = (uint8_t)0xFFU & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDHR;
|
|
pRxMsg->Data[5] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDHR >> 8U);
|
|
pRxMsg->Data[6] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDHR >> 16U);
|
|
pRxMsg->Data[7] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDHR >> 24U);
|
|
|
|
/* Release FIFO0 */
|
|
__HAL_CAN_FIFO_RELEASE(hcan, CAN_FIFO0);
|
|
|
|
/* end get data */
|
|
|
|
/* save to user fifo */
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_RX_IND | 0 << 8);
|
|
}
|
|
|
|
/* Check Overrun flag for FIFO0 */
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_FF0) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FF0) != RESET)
|
|
{
|
|
/* Clear FIFO0 FULL Flag */
|
|
__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FF0);
|
|
}
|
|
|
|
/* Check Overrun flag for FIFO0 */
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_FOV0) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FOV0) != RESET)
|
|
{
|
|
/* Clear FIFO0 Overrun Flag */
|
|
__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FOV0);
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_RXOF_IND | 0 << 8);
|
|
}
|
|
rt_interrupt_leave();
|
|
}
|
|
|
|
/**
|
|
* @brief This function handles CAN1 RX1 interrupts.
|
|
*/
|
|
void CAN1_RX1_IRQHandler(void)
|
|
{
|
|
rt_interrupt_enter();
|
|
|
|
CanRxMsgTypeDef* pRxMsg = NULL;
|
|
CAN_HandleTypeDef *hcan;
|
|
hcan = &drv_can1.CanHandle;
|
|
/* check FMP1 and get data */
|
|
while (__HAL_CAN_MSG_PENDING(hcan, CAN_FIFO1) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FMP1) != RESET)
|
|
{
|
|
/* beigin get data */
|
|
|
|
/* Set RxMsg pointer */
|
|
pRxMsg = hcan->pRx1Msg;
|
|
/* Get the Id */
|
|
pRxMsg->IDE = (uint8_t)0x04U & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RIR;
|
|
if (pRxMsg->IDE == CAN_ID_STD)
|
|
{
|
|
pRxMsg->StdId = 0x000007FFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RIR >> 21U);
|
|
}
|
|
else
|
|
{
|
|
pRxMsg->ExtId = 0x1FFFFFFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RIR >> 3U);
|
|
}
|
|
|
|
pRxMsg->RTR = (uint8_t)0x02U & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RIR;
|
|
/* Get the DLC */
|
|
pRxMsg->DLC = (uint8_t)0x0FU & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDTR;
|
|
/* Get the FIFONumber */
|
|
pRxMsg->FIFONumber = CAN_FIFO1;
|
|
/* Get the FMI */
|
|
pRxMsg->FMI = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDTR >> 8U);
|
|
/* Get the data field */
|
|
pRxMsg->Data[0] = (uint8_t)0xFFU & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDLR;
|
|
pRxMsg->Data[1] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDLR >> 8U);
|
|
pRxMsg->Data[2] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDLR >> 16U);
|
|
pRxMsg->Data[3] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDLR >> 24U);
|
|
pRxMsg->Data[4] = (uint8_t)0xFFU & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDHR;
|
|
pRxMsg->Data[5] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDHR >> 8U);
|
|
pRxMsg->Data[6] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDHR >> 16U);
|
|
pRxMsg->Data[7] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDHR >> 24U);
|
|
|
|
/* Release FIFO1 */
|
|
__HAL_CAN_FIFO_RELEASE(hcan, CAN_FIFO1);
|
|
|
|
/* end get data */
|
|
|
|
/* save to user fifo */
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_RX_IND | 1 << 8);
|
|
}
|
|
|
|
/* Check Overrun flag for FIFO1 */
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_FF1) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FF1) != RESET)
|
|
{
|
|
/* Clear FIFO1 FULL Flag */
|
|
__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FF1);
|
|
}
|
|
|
|
/* Check Overrun flag for FIFO1 */
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_FOV1) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FOV1) != RESET)
|
|
{
|
|
/* Clear FIFO1 Overrun Flag */
|
|
__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FOV1);
|
|
rt_hw_can_isr(&dev_can1, RT_CAN_EVENT_RXOF_IND | 1 << 8);
|
|
}
|
|
rt_interrupt_leave();
|
|
}
|
|
|
|
/**
|
|
* @brief This function handles CAN1 SCE interrupts.
|
|
*/
|
|
void CAN1_SCE_IRQHandler(void)
|
|
{
|
|
rt_uint32_t errtype;
|
|
CAN_HandleTypeDef *hcan;
|
|
|
|
hcan = &drv_can1.CanHandle;
|
|
errtype = hcan->Instance->ESR;
|
|
|
|
rt_interrupt_enter();
|
|
HAL_CAN_IRQHandler(hcan);
|
|
|
|
if (errtype & 0x70 && dev_can1.status.lasterrtype == (errtype & 0x70))
|
|
{
|
|
switch ((errtype & 0x70) >> 4)
|
|
{
|
|
case RT_CAN_BUS_BIT_PAD_ERR:
|
|
dev_can1.status.bitpaderrcnt++;
|
|
break;
|
|
case RT_CAN_BUS_FORMAT_ERR:
|
|
dev_can1.status.formaterrcnt++;
|
|
break;
|
|
case RT_CAN_BUS_ACK_ERR:
|
|
dev_can1.status.ackerrcnt++;
|
|
break;
|
|
case RT_CAN_BUS_IMPLICIT_BIT_ERR:
|
|
case RT_CAN_BUS_EXPLICIT_BIT_ERR:
|
|
dev_can1.status.biterrcnt++;
|
|
break;
|
|
case RT_CAN_BUS_CRC_ERR:
|
|
dev_can1.status.crcerrcnt++;
|
|
break;
|
|
}
|
|
dev_can1.status.lasterrtype = errtype & 0x70;
|
|
hcan->Instance->ESR &= ~0x70;
|
|
}
|
|
dev_can1.status.rcverrcnt = errtype >> 24;
|
|
dev_can1.status.snderrcnt = (errtype >> 16 & 0xFF);
|
|
dev_can1.status.errcode = errtype & 0x07;
|
|
hcan->Instance->MSR |= CAN_MSR_ERRI;
|
|
rt_interrupt_leave();
|
|
}
|
|
#endif /* BSP_USING_CAN1 */
|
|
|
|
#ifdef BSP_USING_CAN2
|
|
static struct stm32_drv_can drv_can2;
|
|
struct rt_can_device dev_can2;
|
|
/**
|
|
* @brief This function handles CAN2 TX interrupts.
|
|
*/
|
|
void CAN2_TX_IRQHandler(void)
|
|
{
|
|
rt_interrupt_enter();
|
|
CAN_HandleTypeDef *hcan;
|
|
hcan = &drv_can2.CanHandle;
|
|
|
|
if (__HAL_CAN_TRANSMIT_STATUS(hcan, CAN_TXMAILBOX_0))
|
|
{
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_TXOK0))
|
|
{
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_TX_DONE | 0 << 8);
|
|
}
|
|
else
|
|
{
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_TX_FAIL | 0 << 8);
|
|
}
|
|
/* Write 0 to Clear transmission status flag RQCPx */
|
|
SET_BIT(hcan->Instance->TSR, CAN_TSR_RQCP0);
|
|
}
|
|
|
|
else if (__HAL_CAN_TRANSMIT_STATUS(hcan, CAN_TXMAILBOX_1))
|
|
{
|
|
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_TXOK1))
|
|
{
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_TX_DONE | 1 << 8);
|
|
}
|
|
else
|
|
{
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_TX_FAIL | 1 << 8);
|
|
}
|
|
/* Write 0 to Clear transmission status flag RQCPx */
|
|
SET_BIT(hcan->Instance->TSR, CAN_TSR_RQCP1);
|
|
}
|
|
|
|
else if (__HAL_CAN_TRANSMIT_STATUS(hcan, CAN_TXMAILBOX_2))
|
|
{
|
|
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_TXOK2))
|
|
{
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_TX_DONE | 2 << 8);
|
|
}
|
|
else
|
|
{
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_TX_FAIL | 2 << 8);
|
|
}
|
|
/* Write 0 to Clear transmission status flag RQCPx */
|
|
SET_BIT(hcan->Instance->TSR, CAN_TSR_RQCP2);
|
|
}
|
|
|
|
rt_interrupt_leave();
|
|
}
|
|
|
|
/**
|
|
* @brief This function handles CAN2 RX0 interrupts.
|
|
*/
|
|
void CAN2_RX0_IRQHandler(void)
|
|
{
|
|
rt_interrupt_enter();
|
|
|
|
CanRxMsgTypeDef* pRxMsg = NULL;
|
|
CAN_HandleTypeDef *hcan;
|
|
hcan = &drv_can2.CanHandle;
|
|
/* check FMP0 and get data */
|
|
while (__HAL_CAN_MSG_PENDING(hcan, CAN_FIFO0) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FMP0) != RESET)
|
|
{
|
|
/* beigin get data */
|
|
|
|
/* Set RxMsg pointer */
|
|
pRxMsg = hcan->pRxMsg;
|
|
/* Get the Id */
|
|
pRxMsg->IDE = (uint8_t)0x04U & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RIR;
|
|
if (pRxMsg->IDE == CAN_ID_STD)
|
|
{
|
|
pRxMsg->StdId = 0x000007FFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RIR >> 21U);
|
|
}
|
|
else
|
|
{
|
|
pRxMsg->ExtId = 0x1FFFFFFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RIR >> 3U);
|
|
}
|
|
|
|
pRxMsg->RTR = (uint8_t)0x02U & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RIR;
|
|
/* Get the DLC */
|
|
pRxMsg->DLC = (uint8_t)0x0FU & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDTR;
|
|
/* Get the FIFONumber */
|
|
pRxMsg->FIFONumber = CAN_FIFO0;
|
|
/* Get the FMI */
|
|
pRxMsg->FMI = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDTR >> 8U);
|
|
/* Get the data field */
|
|
pRxMsg->Data[0] = (uint8_t)0xFFU & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDLR;
|
|
pRxMsg->Data[1] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDLR >> 8U);
|
|
pRxMsg->Data[2] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDLR >> 16U);
|
|
pRxMsg->Data[3] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDLR >> 24U);
|
|
pRxMsg->Data[4] = (uint8_t)0xFFU & hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDHR;
|
|
pRxMsg->Data[5] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDHR >> 8U);
|
|
pRxMsg->Data[6] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDHR >> 16U);
|
|
pRxMsg->Data[7] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO0].RDHR >> 24U);
|
|
|
|
/* Release FIFO0 */
|
|
__HAL_CAN_FIFO_RELEASE(hcan, CAN_FIFO0);
|
|
|
|
/* end get data */
|
|
|
|
/* save to user fifo */
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_RX_IND | 0 << 8);
|
|
}
|
|
|
|
/* Check Overrun flag for FIFO0 */
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_FF0) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FF0) != RESET)
|
|
{
|
|
/* Clear FIFO0 FULL Flag */
|
|
__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FF0);
|
|
}
|
|
|
|
/* Check Overrun flag for FIFO0 */
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_FOV0) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FOV0) != RESET)
|
|
{
|
|
/* Clear FIFO0 Overrun Flag */
|
|
__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FOV0);
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_RXOF_IND | 0 << 8);
|
|
}
|
|
rt_interrupt_leave();
|
|
}
|
|
|
|
/**
|
|
* @brief This function handles CAN2 RX1 interrupts.
|
|
*/
|
|
void CAN2_RX1_IRQHandler(void)
|
|
{
|
|
rt_interrupt_enter();
|
|
|
|
CanRxMsgTypeDef* pRxMsg = NULL;
|
|
CAN_HandleTypeDef *hcan;
|
|
hcan = &drv_can2.CanHandle;
|
|
/* check FMP1 and get data */
|
|
while (__HAL_CAN_MSG_PENDING(hcan, CAN_FIFO1) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FMP1) != RESET)
|
|
{
|
|
/* beigin get data */
|
|
|
|
/* Set RxMsg pointer */
|
|
pRxMsg = hcan->pRx1Msg;
|
|
/* Get the Id */
|
|
pRxMsg->IDE = (uint8_t)0x04U & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RIR;
|
|
if (pRxMsg->IDE == CAN_ID_STD)
|
|
{
|
|
pRxMsg->StdId = 0x000007FFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RIR >> 21U);
|
|
}
|
|
else
|
|
{
|
|
pRxMsg->ExtId = 0x1FFFFFFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RIR >> 3U);
|
|
}
|
|
|
|
pRxMsg->RTR = (uint8_t)0x02U & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RIR;
|
|
/* Get the DLC */
|
|
pRxMsg->DLC = (uint8_t)0x0FU & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDTR;
|
|
/* Get the FIFONumber */
|
|
pRxMsg->FIFONumber = CAN_FIFO1;
|
|
/* Get the FMI */
|
|
pRxMsg->FMI = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDTR >> 8U);
|
|
/* Get the data field */
|
|
pRxMsg->Data[0] = (uint8_t)0xFFU & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDLR;
|
|
pRxMsg->Data[1] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDLR >> 8U);
|
|
pRxMsg->Data[2] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDLR >> 16U);
|
|
pRxMsg->Data[3] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDLR >> 24U);
|
|
pRxMsg->Data[4] = (uint8_t)0xFFU & hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDHR;
|
|
pRxMsg->Data[5] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDHR >> 8U);
|
|
pRxMsg->Data[6] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDHR >> 16U);
|
|
pRxMsg->Data[7] = (uint8_t)0xFFU & (hcan->Instance->sFIFOMailBox[CAN_FIFO1].RDHR >> 24U);
|
|
|
|
/* Release FIFO1 */
|
|
__HAL_CAN_FIFO_RELEASE(hcan, CAN_FIFO1);
|
|
|
|
/* end get data */
|
|
|
|
/* save to user fifo */
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_RX_IND | 1 << 8);
|
|
}
|
|
|
|
/* Check Overrun flag for FIFO1 */
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_FF1) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FF1) != RESET)
|
|
{
|
|
/* Clear FIFO1 FULL Flag */
|
|
__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FF1);
|
|
}
|
|
|
|
/* Check Overrun flag for FIFO1 */
|
|
if (__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_FOV1) != RESET && __HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FOV1) != RESET)
|
|
{
|
|
/* Clear FIFO1 Overrun Flag */
|
|
__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FOV1);
|
|
rt_hw_can_isr(&dev_can2, RT_CAN_EVENT_RXOF_IND | 1 << 8);
|
|
}
|
|
rt_interrupt_leave();
|
|
}
|
|
|
|
/**
|
|
* @brief This function handles CAN2 SCE interrupts.
|
|
*/
|
|
void CAN2_SCE_IRQHandler(void)
|
|
{
|
|
rt_uint32_t errtype;
|
|
CAN_HandleTypeDef *hcan;
|
|
|
|
hcan = &drv_can2.CanHandle;
|
|
errtype = hcan->Instance->ESR;
|
|
|
|
rt_interrupt_enter();
|
|
HAL_CAN_IRQHandler(hcan);
|
|
|
|
if (errtype & 0x70 && dev_can2.status.lasterrtype == (errtype & 0x70))
|
|
{
|
|
switch ((errtype & 0x70) >> 4)
|
|
{
|
|
case RT_CAN_BUS_BIT_PAD_ERR:
|
|
dev_can2.status.bitpaderrcnt++;
|
|
break;
|
|
case RT_CAN_BUS_FORMAT_ERR:
|
|
dev_can2.status.formaterrcnt++;
|
|
break;
|
|
case RT_CAN_BUS_ACK_ERR:
|
|
dev_can2.status.ackerrcnt++;
|
|
break;
|
|
case RT_CAN_BUS_IMPLICIT_BIT_ERR:
|
|
case RT_CAN_BUS_EXPLICIT_BIT_ERR:
|
|
dev_can2.status.biterrcnt++;
|
|
break;
|
|
case RT_CAN_BUS_CRC_ERR:
|
|
dev_can2.status.crcerrcnt++;
|
|
break;
|
|
}
|
|
dev_can2.status.lasterrtype = errtype & 0x70;
|
|
hcan->Instance->ESR &= ~0x70;
|
|
}
|
|
dev_can2.status.rcverrcnt = errtype >> 24;
|
|
dev_can2.status.snderrcnt = (errtype >> 16 & 0xFF);
|
|
dev_can2.status.errcode = errtype & 0x07;
|
|
hcan->Instance->MSR |= CAN_MSR_ERRI;
|
|
rt_interrupt_leave();
|
|
}
|
|
#endif /* BSP_USING_CAN2 */
|
|
|
|
/**
|
|
* @brief Error CAN callback.
|
|
* @param hcan pointer to a CAN_HandleTypeDef structure that contains
|
|
* the configuration information for the specified CAN.
|
|
* @retval None
|
|
*/
|
|
void HAL_CAN_ErrorCallback(CAN_HandleTypeDef *hcan)
|
|
{
|
|
__HAL_CAN_ENABLE_IT(hcan, CAN_IT_EWG |
|
|
CAN_IT_EPV |
|
|
CAN_IT_BOF |
|
|
CAN_IT_LEC |
|
|
CAN_IT_ERR |
|
|
CAN_IT_FMP0|
|
|
CAN_IT_FOV0|
|
|
CAN_IT_FMP1|
|
|
CAN_IT_FOV1|
|
|
CAN_IT_TME);
|
|
}
|
|
|
|
static rt_err_t drv_configure(struct rt_can_device *dev_can,
|
|
struct can_configure *cfg)
|
|
{
|
|
struct stm32_drv_can *drv_can;
|
|
rt_uint32_t baud_index;
|
|
CAN_InitTypeDef *drv_init;
|
|
CAN_FilterConfTypeDef *filterConf;
|
|
|
|
RT_ASSERT(dev_can);
|
|
RT_ASSERT(cfg);
|
|
|
|
drv_can = (struct stm32_drv_can *)dev_can->parent.user_data;
|
|
drv_init = &drv_can->CanHandle.Init;
|
|
|
|
drv_init->TTCM = DISABLE;
|
|
drv_init->ABOM = DISABLE;
|
|
drv_init->AWUM = DISABLE;
|
|
drv_init->NART = DISABLE;
|
|
drv_init->RFLM = DISABLE;
|
|
drv_init->TXFP = DISABLE;
|
|
|
|
switch (cfg->mode)
|
|
{
|
|
case RT_CAN_MODE_NORMAL:
|
|
drv_init->Mode = CAN_MODE_NORMAL;
|
|
break;
|
|
case RT_CAN_MODE_LISEN:
|
|
drv_init->Mode = CAN_MODE_SILENT;
|
|
break;
|
|
case RT_CAN_MODE_LOOPBACK:
|
|
drv_init->Mode = CAN_MODE_LOOPBACK;
|
|
break;
|
|
case RT_CAN_MODE_LOOPBACKANLISEN:
|
|
drv_init->Mode = CAN_MODE_SILENT_LOOPBACK;
|
|
break;
|
|
}
|
|
|
|
baud_index = get_can_baud_index(cfg->baud_rate);
|
|
drv_init->SJW = BAUD_DATA(SJW, baud_index);
|
|
drv_init->BS1 = BAUD_DATA(BS1, baud_index);
|
|
drv_init->BS2 = BAUD_DATA(BS2, baud_index);
|
|
drv_init->Prescaler = BAUD_DATA(RRESCL, baud_index);
|
|
if (HAL_CAN_Init(&drv_can->CanHandle) != HAL_OK)
|
|
{
|
|
return RT_ERROR;
|
|
}
|
|
|
|
/* Filter conf */
|
|
filterConf = &drv_can->FilterConfig;
|
|
filterConf->FilterNumber = 0;
|
|
filterConf->FilterMode = CAN_FILTERMODE_IDMASK;
|
|
filterConf->FilterScale = CAN_FILTERSCALE_32BIT;
|
|
filterConf->FilterIdHigh = 0x0000;
|
|
filterConf->FilterIdLow = 0x0000;
|
|
filterConf->FilterMaskIdHigh = 0x0000;
|
|
filterConf->FilterMaskIdLow = 0x0000;
|
|
filterConf->FilterFIFOAssignment = CAN_FIFO0;
|
|
filterConf->FilterActivation = ENABLE;
|
|
filterConf->BankNumber = 14;
|
|
HAL_CAN_ConfigFilter(&drv_can->CanHandle, filterConf);
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_err_t drv_control(struct rt_can_device *can, int cmd, void *arg)
|
|
{
|
|
struct stm32_drv_can *drv_can;
|
|
rt_uint32_t argval;
|
|
|
|
drv_can = (struct stm32_drv_can *) can->parent.user_data;
|
|
assert_param(drv_can != RT_NULL);
|
|
|
|
switch (cmd)
|
|
{
|
|
case RT_DEVICE_CTRL_CLR_INT:
|
|
argval = (rt_uint32_t) arg;
|
|
if (argval == RT_DEVICE_FLAG_INT_RX)
|
|
{
|
|
if (CAN1 == drv_can->CanHandle.Instance) {
|
|
HAL_NVIC_DisableIRQ(CAN1_RX0_IRQn);
|
|
HAL_NVIC_DisableIRQ(CAN1_RX1_IRQn);
|
|
}
|
|
#ifdef CAN2
|
|
else
|
|
{
|
|
HAL_NVIC_DisableIRQ(CAN2_RX0_IRQn);
|
|
HAL_NVIC_DisableIRQ(CAN2_RX1_IRQn);
|
|
}
|
|
#endif
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_FMP0);
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_FF0 );
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_FOV0);
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_FMP1);
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_FF1 );
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_FOV1);
|
|
}
|
|
else if (argval == RT_DEVICE_FLAG_INT_TX)
|
|
{
|
|
if (CAN1 == drv_can->CanHandle.Instance)
|
|
{
|
|
HAL_NVIC_DisableIRQ(CAN1_TX_IRQn);
|
|
}
|
|
#ifdef CAN2
|
|
else
|
|
{
|
|
HAL_NVIC_DisableIRQ(CAN2_TX_IRQn);
|
|
}
|
|
#endif
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_TME);
|
|
}
|
|
else if (argval == RT_DEVICE_CAN_INT_ERR)
|
|
{
|
|
if (CAN1 == drv_can->CanHandle.Instance)
|
|
{
|
|
NVIC_DisableIRQ(CAN1_SCE_IRQn);
|
|
}
|
|
#ifdef CAN2
|
|
else
|
|
{
|
|
NVIC_DisableIRQ(CAN2_SCE_IRQn);
|
|
}
|
|
#endif
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_BOF);
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_LEC);
|
|
__HAL_CAN_DISABLE_IT(&drv_can->CanHandle, CAN_IT_ERR);
|
|
}
|
|
break;
|
|
case RT_DEVICE_CTRL_SET_INT:
|
|
argval = (rt_uint32_t) arg;
|
|
if (argval == RT_DEVICE_FLAG_INT_RX)
|
|
{
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_FMP0);
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_FF0);
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_FOV0);
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_FMP1);
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_FF1);
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_FOV1);
|
|
|
|
if (CAN1 == drv_can->CanHandle.Instance)
|
|
{
|
|
HAL_NVIC_SetPriority(CAN1_RX0_IRQn, 1, 0);
|
|
HAL_NVIC_EnableIRQ(CAN1_RX0_IRQn);
|
|
HAL_NVIC_SetPriority(CAN1_RX1_IRQn, 1, 0);
|
|
HAL_NVIC_EnableIRQ(CAN1_RX1_IRQn);
|
|
}
|
|
#ifdef CAN2
|
|
else
|
|
{
|
|
HAL_NVIC_SetPriority(CAN2_RX0_IRQn, 1, 0);
|
|
HAL_NVIC_EnableIRQ(CAN2_RX0_IRQn);
|
|
HAL_NVIC_SetPriority(CAN2_RX1_IRQn, 1, 0);
|
|
HAL_NVIC_EnableIRQ(CAN2_RX1_IRQn);
|
|
}
|
|
#endif
|
|
}
|
|
else if (argval == RT_DEVICE_FLAG_INT_TX)
|
|
{
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_TME);
|
|
|
|
if (CAN1 == drv_can->CanHandle.Instance)
|
|
{
|
|
HAL_NVIC_SetPriority(CAN1_TX_IRQn, 1, 0);
|
|
HAL_NVIC_EnableIRQ(CAN1_TX_IRQn);
|
|
}
|
|
#ifdef CAN2
|
|
else
|
|
{
|
|
HAL_NVIC_SetPriority(CAN2_TX_IRQn, 1, 0);
|
|
HAL_NVIC_EnableIRQ(CAN2_TX_IRQn);
|
|
}
|
|
#endif
|
|
}
|
|
else if (argval == RT_DEVICE_CAN_INT_ERR)
|
|
{
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_BOF);
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_LEC);
|
|
__HAL_CAN_ENABLE_IT(&drv_can->CanHandle, CAN_IT_ERR);
|
|
|
|
if (CAN1 == drv_can->CanHandle.Instance)
|
|
{
|
|
HAL_NVIC_SetPriority(CAN1_SCE_IRQn, 1, 0);
|
|
HAL_NVIC_EnableIRQ(CAN1_SCE_IRQn);
|
|
}
|
|
#ifdef CAN2
|
|
else
|
|
{
|
|
HAL_NVIC_SetPriority(CAN2_SCE_IRQn, 1, 0);
|
|
HAL_NVIC_EnableIRQ(CAN2_SCE_IRQn);
|
|
}
|
|
#endif
|
|
}
|
|
break;
|
|
case RT_CAN_CMD_SET_FILTER:
|
|
/* TODO: filter*/
|
|
break;
|
|
case RT_CAN_CMD_SET_MODE:
|
|
argval = (rt_uint32_t) arg;
|
|
if (argval != RT_CAN_MODE_NORMAL ||
|
|
argval != RT_CAN_MODE_LISEN ||
|
|
argval != RT_CAN_MODE_LOOPBACK ||
|
|
argval != RT_CAN_MODE_LOOPBACKANLISEN)
|
|
{
|
|
return RT_ERROR;
|
|
}
|
|
if (argval != can->config.mode)
|
|
{
|
|
can->config.mode = argval;
|
|
if (HAL_CAN_Init(&drv_can->CanHandle) != HAL_OK)
|
|
{
|
|
return RT_ERROR;
|
|
}
|
|
}
|
|
break;
|
|
case RT_CAN_CMD_SET_BAUD:
|
|
argval = (rt_uint32_t) arg;
|
|
if (argval != CAN1MBaud &&
|
|
argval != CAN800kBaud &&
|
|
argval != CAN500kBaud &&
|
|
argval != CAN250kBaud &&
|
|
argval != CAN125kBaud &&
|
|
argval != CAN100kBaud &&
|
|
argval != CAN50kBaud &&
|
|
argval != CAN20kBaud &&
|
|
argval != CAN10kBaud)
|
|
{
|
|
return RT_ERROR;
|
|
}
|
|
if (argval != can->config.baud_rate)
|
|
{
|
|
CAN_InitTypeDef *drv_init;
|
|
rt_uint32_t baud_index;
|
|
can->config.baud_rate = argval;
|
|
drv_init = &drv_can->CanHandle.Init;
|
|
drv_init->TTCM = DISABLE;
|
|
drv_init->ABOM = DISABLE;
|
|
drv_init->AWUM = DISABLE;
|
|
drv_init->NART = DISABLE;
|
|
drv_init->RFLM = DISABLE;
|
|
drv_init->TXFP = DISABLE;
|
|
baud_index = get_can_baud_index(can->config.baud_rate);
|
|
drv_init->SJW = BAUD_DATA(SJW, baud_index);
|
|
drv_init->BS1 = BAUD_DATA(BS1, baud_index);
|
|
drv_init->BS2 = BAUD_DATA(BS2, baud_index);
|
|
drv_init->Prescaler = BAUD_DATA(RRESCL, baud_index);
|
|
|
|
if (HAL_CAN_Init(&drv_can->CanHandle) != HAL_OK)
|
|
{
|
|
return RT_ERROR;
|
|
}
|
|
}
|
|
break;
|
|
case RT_CAN_CMD_SET_PRIV:
|
|
argval = (rt_uint32_t) arg;
|
|
if (argval != RT_CAN_MODE_PRIV ||
|
|
argval != RT_CAN_MODE_NOPRIV)
|
|
{
|
|
return RT_ERROR;
|
|
}
|
|
if (argval != can->config.privmode)
|
|
{
|
|
can->config.privmode = argval;
|
|
if (HAL_CAN_Init(&drv_can->CanHandle) != HAL_OK)
|
|
{
|
|
return RT_ERROR;
|
|
}
|
|
}
|
|
break;
|
|
case RT_CAN_CMD_GET_STATUS:
|
|
{
|
|
rt_uint32_t errtype;
|
|
errtype = drv_can->CanHandle.Instance->ESR;
|
|
can->status.rcverrcnt = errtype >> 24;
|
|
can->status.snderrcnt = (errtype >> 16 & 0xFF);
|
|
can->status.errcode = errtype & 0x07;
|
|
if (arg != &can->status)
|
|
{
|
|
rt_memcpy(arg, &can->status, sizeof(can->status));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
static int drv_sendmsg(struct rt_can_device *can, const void *buf, rt_uint32_t boxno)
|
|
{
|
|
CAN_HandleTypeDef *hcan = RT_NULL;
|
|
hcan = &((struct stm32_drv_can *) can->parent.user_data)->CanHandle;
|
|
struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;
|
|
|
|
/*check Select mailbox is empty */
|
|
switch (boxno)
|
|
{
|
|
case CAN_TXMAILBOX_0:
|
|
if (HAL_IS_BIT_SET(hcan->Instance->TSR, CAN_TSR_TME0) != SET)
|
|
{
|
|
/* Change CAN state */
|
|
hcan->State = HAL_CAN_STATE_ERROR;
|
|
/* Return function status */
|
|
return -RT_ERROR;
|
|
}
|
|
break;
|
|
case CAN_TXMAILBOX_1:
|
|
if (HAL_IS_BIT_SET(hcan->Instance->TSR, CAN_TSR_TME1) != SET)
|
|
{
|
|
/* Change CAN state */
|
|
hcan->State = HAL_CAN_STATE_ERROR;
|
|
/* Return function status */
|
|
return -RT_ERROR;
|
|
}
|
|
break;
|
|
case CAN_TXMAILBOX_2:
|
|
if (HAL_IS_BIT_SET(hcan->Instance->TSR, CAN_TSR_TME2) != SET)
|
|
{
|
|
/* Change CAN state */
|
|
hcan->State = HAL_CAN_STATE_ERROR;
|
|
/* Return function status */
|
|
return -RT_ERROR;
|
|
}
|
|
break;
|
|
default:
|
|
RT_ASSERT(0);
|
|
break;
|
|
}
|
|
|
|
/* check id type */
|
|
if (RT_CAN_STDID == pmsg->ide)
|
|
{
|
|
hcan->pTxMsg->IDE = CAN_ID_STD;
|
|
hcan->pTxMsg->StdId = pmsg->id;
|
|
hcan->pTxMsg->ExtId = 0xFFFFFFFFU;
|
|
}
|
|
else if (RT_CAN_EXTID == pmsg->ide)
|
|
{
|
|
hcan->pTxMsg->IDE = CAN_ID_EXT;
|
|
hcan->pTxMsg->StdId = 0xFFFFFFFFU;
|
|
hcan->pTxMsg->ExtId = pmsg->id;
|
|
}
|
|
|
|
/* check frame type */
|
|
if (RT_CAN_DTR == pmsg->rtr)
|
|
{
|
|
hcan->pTxMsg->RTR = CAN_RTR_DATA;
|
|
}
|
|
else if (RT_CAN_RTR == pmsg->rtr)
|
|
{
|
|
hcan->pTxMsg->RTR = CAN_RTR_REMOTE;
|
|
}
|
|
|
|
hcan->pTxMsg->DLC = pmsg->len;
|
|
/* copy user data to hcan */
|
|
hcan->pTxMsg->Data[0] = pmsg->data[0];
|
|
hcan->pTxMsg->Data[1] = pmsg->data[1];
|
|
hcan->pTxMsg->Data[2] = pmsg->data[2];
|
|
hcan->pTxMsg->Data[3] = pmsg->data[3];
|
|
hcan->pTxMsg->Data[4] = pmsg->data[4];
|
|
hcan->pTxMsg->Data[5] = pmsg->data[5];
|
|
hcan->pTxMsg->Data[6] = pmsg->data[6];
|
|
hcan->pTxMsg->Data[7] = pmsg->data[7];
|
|
|
|
/* clear TIR */
|
|
hcan->Instance->sTxMailBox[boxno].TIR &= CAN_TI0R_TXRQ;
|
|
/* Set up the Id */
|
|
if (hcan->pTxMsg->IDE == CAN_ID_STD)
|
|
{
|
|
assert_param(IS_CAN_STDID(hcan->pTxMsg->StdId));
|
|
hcan->Instance->sTxMailBox[boxno].TIR |= ((hcan->pTxMsg->StdId << CAN_TI0R_STID_Pos) | \
|
|
hcan->pTxMsg->RTR);
|
|
}
|
|
else
|
|
{
|
|
assert_param(IS_CAN_EXTID(hcan->pTxMsg->ExtId));
|
|
hcan->Instance->sTxMailBox[boxno].TIR |= ((hcan->pTxMsg->ExtId << CAN_TI0R_EXID_Pos) | \
|
|
hcan->pTxMsg->IDE |
|
|
hcan->pTxMsg->RTR);
|
|
}
|
|
/* Set up the DLC */
|
|
hcan->pTxMsg->DLC &= (uint8_t)0x0000000FU;
|
|
hcan->Instance->sTxMailBox[boxno].TDTR &= 0xFFFFFFF0U;
|
|
hcan->Instance->sTxMailBox[boxno].TDTR |= hcan->pTxMsg->DLC;
|
|
|
|
/* Set up the data field */
|
|
WRITE_REG(hcan->Instance->sTxMailBox[boxno].TDLR, ((uint32_t)hcan->pTxMsg->Data[3U] << CAN_TDL0R_DATA3_Pos) |
|
|
((uint32_t)hcan->pTxMsg->Data[2U] << CAN_TDL0R_DATA2_Pos) |
|
|
((uint32_t)hcan->pTxMsg->Data[1U] << CAN_TDL0R_DATA1_Pos) |
|
|
((uint32_t)hcan->pTxMsg->Data[0U] << CAN_TDL0R_DATA0_Pos));
|
|
WRITE_REG(hcan->Instance->sTxMailBox[boxno].TDHR, ((uint32_t)hcan->pTxMsg->Data[7U] << CAN_TDL0R_DATA3_Pos) |
|
|
((uint32_t)hcan->pTxMsg->Data[6U] << CAN_TDL0R_DATA2_Pos) |
|
|
((uint32_t)hcan->pTxMsg->Data[5U] << CAN_TDL0R_DATA1_Pos) |
|
|
((uint32_t)hcan->pTxMsg->Data[4U] << CAN_TDL0R_DATA0_Pos));
|
|
|
|
/* Request transmission */
|
|
hcan->Instance->sTxMailBox[boxno].TIR |= CAN_TI0R_TXRQ;
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
static int drv_recvmsg(struct rt_can_device *can, void *buf, rt_uint32_t boxno)
|
|
{
|
|
CAN_HandleTypeDef *hcan;
|
|
struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;
|
|
hcan = &((struct stm32_drv_can *) can->parent.user_data)->CanHandle;
|
|
CanRxMsgTypeDef *pRxMsg = RT_NULL;
|
|
|
|
/* get FIFO */
|
|
switch (boxno)
|
|
{
|
|
case CAN_FIFO0:
|
|
pRxMsg = hcan->pRxMsg;
|
|
break;
|
|
case CAN_FIFO1:
|
|
pRxMsg = hcan->pRx1Msg;
|
|
break;
|
|
default:
|
|
RT_ASSERT(0);
|
|
break;
|
|
}
|
|
|
|
/* copy data */
|
|
/* get id */
|
|
if (CAN_ID_STD == pRxMsg->IDE)
|
|
{
|
|
pmsg->ide = RT_CAN_STDID;
|
|
pmsg->id = pRxMsg->StdId;
|
|
}
|
|
else if (CAN_ID_EXT == pRxMsg->IDE)
|
|
{
|
|
pmsg->ide = RT_CAN_EXTID;
|
|
pmsg->id = pRxMsg->ExtId;
|
|
}
|
|
/* get type */
|
|
if (CAN_RTR_DATA == pRxMsg->RTR)
|
|
{
|
|
pmsg->rtr = RT_CAN_DTR;
|
|
}
|
|
else if (CAN_RTR_REMOTE == pRxMsg->RTR)
|
|
{
|
|
pmsg->rtr = RT_CAN_RTR;
|
|
}
|
|
/* get len */
|
|
pmsg->len = pRxMsg->DLC;
|
|
/* get hdr */
|
|
pmsg->hdr = pRxMsg->FMI;
|
|
/* get data */
|
|
pmsg->data[0] = pRxMsg->Data[0];
|
|
pmsg->data[1] = pRxMsg->Data[1];
|
|
pmsg->data[2] = pRxMsg->Data[2];
|
|
pmsg->data[3] = pRxMsg->Data[3];
|
|
pmsg->data[4] = pRxMsg->Data[4];
|
|
pmsg->data[5] = pRxMsg->Data[5];
|
|
pmsg->data[6] = pRxMsg->Data[6];
|
|
pmsg->data[7] = pRxMsg->Data[7];
|
|
return RT_EOK;
|
|
}
|
|
|
|
static const struct rt_can_ops drv_can_ops =
|
|
{
|
|
drv_configure,
|
|
drv_control,
|
|
drv_sendmsg,
|
|
drv_recvmsg,
|
|
};
|
|
|
|
int rt_hw_can_init(void)
|
|
{
|
|
struct stm32_drv_can *drv_can;
|
|
struct can_configure config = CANDEFAULTCONFIG;
|
|
config.privmode = 0;
|
|
config.ticks = 50;
|
|
config.sndboxnumber = 3;
|
|
config.msgboxsz = 32;
|
|
#ifdef RT_CAN_USING_HDR
|
|
config.maxhdr = 14;
|
|
#ifdef CAN2
|
|
config.maxhdr = 28;
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef BSP_USING_CAN1
|
|
drv_can = &drv_can1;
|
|
drv_can->CanHandle.Instance = CAN1;
|
|
drv_can->CanHandle.pTxMsg = &drv_can->TxMessage;
|
|
drv_can->CanHandle.pRxMsg = &drv_can->RxMessage;
|
|
drv_can->CanHandle.pRx1Msg = &drv_can->Rx1Message;
|
|
dev_can1.ops = &drv_can_ops;
|
|
dev_can1.config = config;
|
|
/* register CAN1 device */
|
|
rt_hw_can_register(&dev_can1, "can1",
|
|
&drv_can_ops,
|
|
drv_can);
|
|
#endif /* BSP_USING_CAN1 */
|
|
|
|
#ifdef BSP_USING_CAN2
|
|
drv_can = &drv_can2;
|
|
drv_can->CanHandle.Instance = CAN2;
|
|
drv_can->CanHandle.pTxMsg = &drv_can->TxMessage;
|
|
drv_can->CanHandle.pRxMsg = &drv_can->RxMessage;
|
|
drv_can->CanHandle.pRx1Msg = &drv_can->Rx1Message;
|
|
dev_can2.ops = &drv_can_ops;
|
|
dev_can2.config = config;
|
|
/* register CAN2 device */
|
|
rt_hw_can_register(&dev_can2, "can2",
|
|
&drv_can_ops,
|
|
drv_can);
|
|
#endif /* BSP_USING_CAN2 */
|
|
|
|
return 0;
|
|
}
|
|
|
|
INIT_BOARD_EXPORT(rt_hw_can_init);
|
|
|
|
#endif /* RT_USING_CAN */
|