565 lines
16 KiB
C
565 lines
16 KiB
C
|
/**************************************************************************//**
|
||
|
*
|
||
|
* @copyright (C) 2019 Nuvoton Technology Corp. All rights reserved.
|
||
|
*
|
||
|
* SPDX-License-Identifier: Apache-2.0
|
||
|
*
|
||
|
* Change Logs:
|
||
|
* Date Author Notes
|
||
|
* 2020-2-07 ChingI First version
|
||
|
*
|
||
|
******************************************************************************/
|
||
|
|
||
|
#include <rtconfig.h>
|
||
|
|
||
|
#if defined(BSP_USING_CAN)
|
||
|
|
||
|
#include <rtdevice.h>
|
||
|
#include <rthw.h>
|
||
|
#include <NuMicro.h>
|
||
|
|
||
|
/* Private Define ---------------------------------------------------------------*/
|
||
|
#define RX_MSG_ID_INDEX 16
|
||
|
#define IS_CAN_STDID(STDID) ((STDID) <= 0x7FFU)
|
||
|
#define IS_CAN_EXTID(EXTID) ((EXTID) <= 0x1FFFFFFFU)
|
||
|
#define IS_CAN_DLC(DLC) ((DLC) <= 8U)
|
||
|
|
||
|
/* Default config for serial_configure structure */
|
||
|
#define NU_CAN_CONFIG_DEFAULT \
|
||
|
{ \
|
||
|
CAN1MBaud, /* 1M bits/s */ \
|
||
|
RT_CANMSG_BOX_SZ, /* message box max size */ \
|
||
|
RT_CANSND_BOX_NUM, /* message box number */ \
|
||
|
RT_CAN_MODE_NORMAL, /* Normal mode */ \
|
||
|
0, /* privmode */ \
|
||
|
0, /* reserved */ \
|
||
|
100, /* Timeout Tick */ \
|
||
|
}
|
||
|
|
||
|
enum
|
||
|
{
|
||
|
CAN_START = -1,
|
||
|
#if defined(BSP_USING_CAN0)
|
||
|
CAN0_IDX,
|
||
|
#endif
|
||
|
#if defined(BSP_USING_CAN1)
|
||
|
CAN1_IDX,
|
||
|
#endif
|
||
|
#if defined(BSP_USING_CAN2)
|
||
|
CAN2_IDX,
|
||
|
#endif
|
||
|
CAN_CNT
|
||
|
};
|
||
|
|
||
|
/* Private Typedef --------------------------------------------------------------*/
|
||
|
struct nu_can
|
||
|
{
|
||
|
struct rt_can_device dev;
|
||
|
char *name;
|
||
|
CAN_T *can_base;
|
||
|
uint32_t can_rst;
|
||
|
IRQn_Type can_irq_n;
|
||
|
};
|
||
|
typedef struct nu_can *nu_can_t;
|
||
|
|
||
|
/* Private functions ------------------------------------------------------------*/
|
||
|
static rt_err_t nu_can_configure(struct rt_can_device *can, struct can_configure *cfg);
|
||
|
static rt_err_t nu_can_control(struct rt_can_device *can, int cmd, void *arg);
|
||
|
static int nu_can_sendmsg(struct rt_can_device *can, const void *buf, rt_uint32_t boxno);
|
||
|
static int nu_can_recvmsg(struct rt_can_device *can, void *buf, rt_uint32_t boxno);
|
||
|
static void nu_can_isr(nu_can_t can);
|
||
|
|
||
|
static struct nu_can nu_can_arr[] =
|
||
|
{
|
||
|
#if defined(BSP_USING_CAN0)
|
||
|
{
|
||
|
.name = "can0",
|
||
|
.can_base = CAN0,
|
||
|
.can_rst = CAN0_RST,
|
||
|
.can_irq_n = CAN0_IRQn,
|
||
|
},
|
||
|
#endif
|
||
|
#if defined(BSP_USING_CAN1)
|
||
|
{
|
||
|
.name = "can1",
|
||
|
.can_base = CAN1,
|
||
|
.can_rst = CAN1_RST,
|
||
|
.can_irq_n = CAN1_IRQn,
|
||
|
},
|
||
|
#endif
|
||
|
|
||
|
#if defined(BSP_USING_CAN2)
|
||
|
{
|
||
|
.name = "can2",
|
||
|
.can_base = CAN2,
|
||
|
.can_rst = CAN2_RST,
|
||
|
.can_irq_n = CAN2_IRQn,
|
||
|
},
|
||
|
#endif
|
||
|
{0}
|
||
|
}; /* usart nu_usart */
|
||
|
|
||
|
/* Public functions ------------------------------------------------------------*/
|
||
|
|
||
|
/* Private variables ------------------------------------------------------------*/
|
||
|
static const struct rt_can_ops nu_can_ops =
|
||
|
{
|
||
|
.configure = nu_can_configure,
|
||
|
.control = nu_can_control,
|
||
|
.sendmsg = nu_can_sendmsg,
|
||
|
.recvmsg = nu_can_recvmsg,
|
||
|
};
|
||
|
|
||
|
static const struct can_configure nu_can_default_config = NU_CAN_CONFIG_DEFAULT;
|
||
|
|
||
|
/* Interrupt Handle Funtion ----------------------------------------------------*/
|
||
|
#if defined(BSP_USING_CAN0)
|
||
|
/* CAN0 interrupt entry */
|
||
|
void CAN0_IRQHandler(void)
|
||
|
{
|
||
|
/* enter interrupt */
|
||
|
rt_interrupt_enter();
|
||
|
|
||
|
nu_can_isr(&nu_can_arr[CAN0_IDX]);
|
||
|
|
||
|
/* leave interrupt */
|
||
|
rt_interrupt_leave();
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#if defined(BSP_USING_CAN1)
|
||
|
/* CAN1 interrupt entry */
|
||
|
void CAN1_IRQHandler(void)
|
||
|
{
|
||
|
/* enter interrupt */
|
||
|
rt_interrupt_enter();
|
||
|
|
||
|
nu_can_isr(&nu_can_arr[CAN1_IDX]);
|
||
|
|
||
|
/* leave interrupt */
|
||
|
rt_interrupt_leave();
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#if defined(BSP_USING_CAN2)
|
||
|
/* CAN2 interrupt entry */
|
||
|
void CAN2_IRQHandler(void)
|
||
|
{
|
||
|
/* enter interrupt */
|
||
|
rt_interrupt_enter();
|
||
|
|
||
|
nu_can_isr(&nu_can_arr[CAN2_IDX]);
|
||
|
|
||
|
/* leave interrupt */
|
||
|
rt_interrupt_leave();
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
|
||
|
/* Private Variables ------------------------------------------------------------*/
|
||
|
|
||
|
|
||
|
static void nu_can_isr(nu_can_t can)
|
||
|
{
|
||
|
uint32_t u32IIDRstatus;
|
||
|
/* Get base address of CAN register */
|
||
|
CAN_T *can_base = ((nu_can_t)can)->can_base;
|
||
|
|
||
|
/* Get interrupt event */
|
||
|
u32IIDRstatus = can_base->IIDR;
|
||
|
|
||
|
if (u32IIDRstatus == 0x00008000) /* Check Status Interrupt Flag (Error status Int and Status change Int) */
|
||
|
{
|
||
|
/**************************/
|
||
|
/* Status Change interrupt*/
|
||
|
/**************************/
|
||
|
if (can_base->STATUS & CAN_STATUS_RXOK_Msk)
|
||
|
{
|
||
|
|
||
|
#ifndef RT_CAN_USING_HDR
|
||
|
/* Using as Lisen,Loopback,Loopback+Lisen mode*/
|
||
|
rt_hw_can_isr(&can->dev, RT_CAN_EVENT_RX_IND);
|
||
|
#endif
|
||
|
can_base->STATUS &= ~CAN_STATUS_RXOK_Msk; /* Clear Rx Ok status*/
|
||
|
rt_kprintf("RX OK INT\n") ;
|
||
|
}
|
||
|
|
||
|
if (can_base->STATUS & CAN_STATUS_TXOK_Msk)
|
||
|
{
|
||
|
|
||
|
#ifndef RT_CAN_USING_HDR
|
||
|
/* Using as Lisen,Loopback,Loopback+Lisen mode*/
|
||
|
rt_hw_can_isr(&can->dev, RT_CAN_EVENT_TX_DONE);
|
||
|
#endif
|
||
|
can_base->STATUS &= ~CAN_STATUS_TXOK_Msk; /* Clear Tx Ok status*/
|
||
|
rt_kprintf("TX OK INT\n") ;
|
||
|
}
|
||
|
|
||
|
/**************************/
|
||
|
/* Error Status interrupt */
|
||
|
/**************************/
|
||
|
if (can_base->STATUS & CAN_STATUS_EWARN_Msk)
|
||
|
{
|
||
|
rt_kprintf("EWARN INT\n") ;
|
||
|
}
|
||
|
|
||
|
if (can_base->STATUS & CAN_STATUS_BOFF_Msk)
|
||
|
{
|
||
|
rt_kprintf("BOFF INT\n") ;
|
||
|
|
||
|
/* Do Init to release busoff pin */
|
||
|
can_base->CON = (CAN_CON_INIT_Msk | CAN_CON_CCE_Msk);
|
||
|
can_base->CON &= (~(CAN_CON_INIT_Msk | CAN_CON_CCE_Msk));
|
||
|
while (can_base->CON & CAN_CON_INIT_Msk);
|
||
|
}
|
||
|
}
|
||
|
#ifdef RT_CAN_USING_HDR
|
||
|
/*Number of Message Object which caused the interrupt*/
|
||
|
else if (u32IIDRstatus != 0 && u32IIDRstatus <= 32)
|
||
|
{
|
||
|
rt_kprintf("=> Interrupt Pointer = %d\n", can_base->IIDR - 1);
|
||
|
/*Message RAM 0~15 for CAN Tx using*/
|
||
|
if (u32IIDRstatus < 16)
|
||
|
rt_hw_can_isr(&can->dev, RT_CAN_EVENT_TX_DONE);
|
||
|
else /*Message RAM 16~31 for CAN Rx using*/
|
||
|
{
|
||
|
rt_hw_can_isr(&can->dev, (RT_CAN_EVENT_RX_IND | (((can_base->IIDR) - 1) << 8)));
|
||
|
}
|
||
|
CAN_CLR_INT_PENDING_BIT(can_base, ((can_base->IIDR) - 1)); /* Clear Interrupt Pending */
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
}
|
||
|
|
||
|
|
||
|
static rt_err_t nu_can_configure(struct rt_can_device *can, struct can_configure *cfg)
|
||
|
{
|
||
|
|
||
|
RT_ASSERT(can != RT_NULL);
|
||
|
RT_ASSERT(cfg != RT_NULL);
|
||
|
|
||
|
/* Get base address of uart register */
|
||
|
CAN_T *can_base = ((nu_can_t)can)->can_base;
|
||
|
|
||
|
RT_ASSERT(can_base != RT_NULL);
|
||
|
|
||
|
/* Reset this module */
|
||
|
SYS_ResetModule(((nu_can_t)can)->can_rst);
|
||
|
|
||
|
switch (cfg->mode)
|
||
|
{
|
||
|
/* CAN default Normal mode */
|
||
|
case RT_CAN_MODE_NORMAL:
|
||
|
can->config.mode = CAN_NORMAL_MODE;
|
||
|
break;
|
||
|
case RT_CAN_MODE_LISEN:
|
||
|
can->config.mode = RT_CAN_MODE_LISEN;
|
||
|
break;
|
||
|
case RT_CAN_MODE_LOOPBACK:
|
||
|
can->config.mode = RT_CAN_MODE_LOOPBACK;
|
||
|
break;
|
||
|
case RT_CAN_MODE_LOOPBACKANLISEN:
|
||
|
can->config.mode = RT_CAN_MODE_LOOPBACKANLISEN;
|
||
|
break;
|
||
|
default:
|
||
|
rt_kprintf("Unsupported Operating mode");
|
||
|
goto exit_nu_can_configure;
|
||
|
}
|
||
|
|
||
|
/*Set the CAN Bit Rate and Operating mode*/
|
||
|
if (CAN_Open(can_base, can->config.baud_rate, can->config.mode) < 1)
|
||
|
return -(RT_ERROR);
|
||
|
|
||
|
|
||
|
switch (cfg->mode)
|
||
|
{
|
||
|
/* CAN default Normal mode */
|
||
|
case RT_CAN_MODE_NORMAL:
|
||
|
#ifdef RT_CAN_USING_HDR
|
||
|
CAN_LeaveTestMode(can_base);
|
||
|
#else
|
||
|
CAN_EnterTestMode(can_base, CAN_TEST_BASIC_Msk);
|
||
|
#endif
|
||
|
break;
|
||
|
case RT_CAN_MODE_LISEN:
|
||
|
CAN_EnterTestMode(can_base, CAN_TEST_BASIC_Msk | CAN_TEST_SILENT_Msk);
|
||
|
break;
|
||
|
case RT_CAN_MODE_LOOPBACK:
|
||
|
CAN_EnterTestMode(can_base, CAN_TEST_BASIC_Msk | CAN_TEST_LBACK_Msk);
|
||
|
break;
|
||
|
case RT_CAN_MODE_LOOPBACKANLISEN:
|
||
|
CAN_EnterTestMode(can_base, CAN_TEST_BASIC_Msk | CAN_TEST_SILENT_Msk | CAN_TEST_LBACK_Msk);
|
||
|
break;
|
||
|
default:
|
||
|
rt_kprintf("Unsupported Operating mode");
|
||
|
goto exit_nu_can_configure;
|
||
|
}
|
||
|
|
||
|
|
||
|
return RT_EOK;
|
||
|
|
||
|
exit_nu_can_configure:
|
||
|
|
||
|
CAN_Close(can_base);
|
||
|
|
||
|
return -(RT_ERROR);
|
||
|
}
|
||
|
|
||
|
static rt_err_t nu_can_control(struct rt_can_device *can, int cmd, void *arg)
|
||
|
{
|
||
|
rt_uint32_t argval;
|
||
|
|
||
|
#ifdef RT_CAN_USING_HDR
|
||
|
struct rt_can_filter_config *filter_cfg;
|
||
|
#endif
|
||
|
/* Get base address of uart register */
|
||
|
CAN_T *can_base = ((nu_can_t)can)->can_base;
|
||
|
|
||
|
RT_ASSERT(can_base != RT_NULL);
|
||
|
/* Check baudrate */
|
||
|
RT_ASSERT(can->config.baud_rate != 0);
|
||
|
|
||
|
switch (cmd)
|
||
|
{
|
||
|
case RT_DEVICE_CTRL_CLR_INT:
|
||
|
argval = (rt_uint32_t) arg;
|
||
|
if ((argval == RT_DEVICE_FLAG_INT_RX) || (argval == RT_DEVICE_FLAG_INT_TX))
|
||
|
{
|
||
|
/* Disable NVIC interrupt. */
|
||
|
NVIC_DisableIRQ(((nu_can_t)can)->can_irq_n);
|
||
|
/* Disable Status Change Interrupt */
|
||
|
CAN_DisableInt(can_base, CAN_CON_IE_Msk | CAN_CON_SIE_Msk);
|
||
|
|
||
|
}
|
||
|
else if (argval == RT_DEVICE_CAN_INT_ERR)
|
||
|
{
|
||
|
/* Disable NVIC interrupt. */
|
||
|
NVIC_DisableIRQ(((nu_can_t)can)->can_irq_n);
|
||
|
/* Disable Error Interrupt */
|
||
|
CAN_DisableInt(can_base, CAN_CON_EIE_Msk);
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case RT_DEVICE_CTRL_SET_INT:
|
||
|
argval = (rt_uint32_t) arg;
|
||
|
if (argval == RT_DEVICE_FLAG_INT_RX || (argval == RT_DEVICE_FLAG_INT_TX))
|
||
|
{
|
||
|
/* Enable Status Change Interrupt */
|
||
|
CAN_EnableInt(can_base, CAN_CON_IE_Msk | CAN_CON_SIE_Msk);
|
||
|
NVIC_SetPriority(((nu_can_t)can)->can_irq_n, (1 << __NVIC_PRIO_BITS) - 2);
|
||
|
/* Enable NVIC interrupt. */
|
||
|
NVIC_EnableIRQ(((nu_can_t)can)->can_irq_n);
|
||
|
|
||
|
}
|
||
|
else if (argval == RT_DEVICE_CAN_INT_ERR)
|
||
|
{
|
||
|
/* Enable Error Status and Status Change Interrupt */
|
||
|
CAN_EnableInt(can_base, CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk);
|
||
|
NVIC_SetPriority(((nu_can_t)can)->can_irq_n, (1 << __NVIC_PRIO_BITS) - 2);
|
||
|
/* Enable NVIC interrupt. */
|
||
|
NVIC_EnableIRQ(((nu_can_t)can)->can_irq_n);
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case RT_CAN_CMD_SET_FILTER:
|
||
|
#ifdef RT_CAN_USING_HDR
|
||
|
filter_cfg = (struct rt_can_filter_config *)arg;
|
||
|
|
||
|
for (int i = 0; i < filter_cfg->count; i++)
|
||
|
{
|
||
|
|
||
|
/*set the filter message object*/
|
||
|
if (filter_cfg->items[i].mode == 1)
|
||
|
{
|
||
|
if (CAN_SetRxMsgObjAndMsk(can_base, MSG(i + RX_MSG_ID_INDEX), filter_cfg->items[i].ide, filter_cfg->items[i].id, filter_cfg->items[i].mask, FALSE) == FALSE)
|
||
|
{
|
||
|
return -(RT_ERROR);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
|
||
|
{
|
||
|
/*set the filter message object*/
|
||
|
if (CAN_SetRxMsgAndMsk(can_base, MSG(i + RX_MSG_ID_INDEX), filter_cfg->items[i].ide, filter_cfg->items[i].id, filter_cfg->items[i].mask) == FALSE)
|
||
|
{
|
||
|
return -(RT_ERROR);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
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;
|
||
|
return nu_can_configure(can, &can->config);
|
||
|
}
|
||
|
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->config.baud_rate = argval;
|
||
|
return nu_can_configure(can, &can->config);
|
||
|
}
|
||
|
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;
|
||
|
return nu_can_configure(can, &can->config);
|
||
|
}
|
||
|
break;
|
||
|
case RT_CAN_CMD_GET_STATUS:
|
||
|
{
|
||
|
rt_uint32_t errtype;
|
||
|
errtype = can_base->ERR;
|
||
|
/*Receive Error Counter*/
|
||
|
can->status.rcverrcnt = (errtype >> 8);
|
||
|
/*Transmit Error Counter*/
|
||
|
can->status.snderrcnt = ((errtype >> 24) & 0xFF);
|
||
|
can->status.lasterrtype = CAN_GET_INT_STATUS(can_base) & 0x8000;
|
||
|
/*status error code*/
|
||
|
can->status.errcode = CAN_GET_INT_STATUS(can_base) & 0x07;
|
||
|
rt_memcpy(arg, &can->status, sizeof(can->status));
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
return RT_EOK;
|
||
|
}
|
||
|
|
||
|
static int nu_can_sendmsg(struct rt_can_device *can, const void *buf, rt_uint32_t boxno)
|
||
|
{
|
||
|
STR_CANMSG_T tMsg;
|
||
|
struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;
|
||
|
/* Get base address of uart register */
|
||
|
CAN_T *can_base = ((nu_can_t)can)->can_base;
|
||
|
|
||
|
RT_ASSERT(can_base != RT_NULL);
|
||
|
RT_ASSERT(buf != RT_NULL);
|
||
|
/* Check the parameters */
|
||
|
RT_ASSERT(IS_CAN_DLC(pmsg->len));
|
||
|
/* Standard ID (11 bits)*/
|
||
|
if (pmsg->ide == RT_CAN_STDID)
|
||
|
{
|
||
|
tMsg.IdType = CAN_STD_ID;
|
||
|
RT_ASSERT(IS_CAN_STDID(pmsg->id))
|
||
|
tMsg.Id = pmsg->id ;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/* Extended ID (29 bits)*/
|
||
|
tMsg.IdType = CAN_EXT_ID;
|
||
|
RT_ASSERT(IS_CAN_EXTID(pmsg->id));
|
||
|
tMsg.Id = pmsg->id ;
|
||
|
}
|
||
|
|
||
|
if (pmsg->rtr == RT_CAN_DTR)
|
||
|
{
|
||
|
/* Data frame */
|
||
|
tMsg.FrameType = CAN_DATA_FRAME;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/* Remote frame */
|
||
|
tMsg.FrameType = CAN_REMOTE_FRAME;
|
||
|
}
|
||
|
tMsg.DLC = pmsg->len;
|
||
|
rt_memcpy(tMsg.Data, pmsg->data, pmsg->len);
|
||
|
|
||
|
if (CAN_Transmit(can_base, MSG(boxno), &tMsg) == FALSE) // Configure Msg RAM and send the Msg in the RAM
|
||
|
{
|
||
|
return -(RT_ERROR);
|
||
|
}
|
||
|
|
||
|
return RT_EOK;
|
||
|
}
|
||
|
static int nu_can_recvmsg(struct rt_can_device *can, void *buf, rt_uint32_t boxno)
|
||
|
{
|
||
|
STR_CANMSG_T tMsg;
|
||
|
struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;
|
||
|
/* Get base address of uart register */
|
||
|
CAN_T *can_base = ((nu_can_t)can)->can_base;
|
||
|
|
||
|
RT_ASSERT(can_base != RT_NULL);
|
||
|
RT_ASSERT(buf != RT_NULL);
|
||
|
|
||
|
/* get data */
|
||
|
CAN_Receive(can_base, boxno, &tMsg);
|
||
|
|
||
|
#ifdef RT_CAN_USING_HDR
|
||
|
/* Hardware filter messages are valid */
|
||
|
can->hdr->connected = 1;
|
||
|
#endif
|
||
|
|
||
|
/* Standard ID (11 bits)*/
|
||
|
if (tMsg.IdType == CAN_STD_ID)
|
||
|
{
|
||
|
pmsg->ide = RT_CAN_STDID;
|
||
|
pmsg->id = tMsg.Id;
|
||
|
}
|
||
|
else /* Extended ID (29 bits)*/
|
||
|
{
|
||
|
pmsg->ide = RT_CAN_EXTID;
|
||
|
pmsg->id = tMsg.Id;
|
||
|
}
|
||
|
if (tMsg.FrameType == CAN_DATA_FRAME)
|
||
|
{
|
||
|
/* Data frame */
|
||
|
pmsg->rtr = RT_CAN_DTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/* Remote frame */
|
||
|
pmsg->rtr = RT_CAN_RTR;
|
||
|
}
|
||
|
pmsg->len = tMsg.DLC ;
|
||
|
rt_memcpy(pmsg->data, tMsg.Data, pmsg->len);
|
||
|
|
||
|
|
||
|
return RT_EOK;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Hardware CAN Initialization
|
||
|
*/
|
||
|
static int rt_hw_can_init(void)
|
||
|
{
|
||
|
int i;
|
||
|
rt_err_t ret = RT_EOK;
|
||
|
|
||
|
for (i = (CAN_START + 1); i < CAN_CNT; i++)
|
||
|
{
|
||
|
|
||
|
nu_can_arr[i].dev.ops = &nu_can_ops;
|
||
|
nu_can_arr[i].dev.config = nu_can_default_config;
|
||
|
|
||
|
#ifdef RT_CAN_USING_HDR
|
||
|
nu_can_arr[i].dev.config.maxhdr = RT_CANMSG_BOX_SZ;
|
||
|
#endif
|
||
|
ret = rt_hw_can_register(&nu_can_arr[i].dev, nu_can_arr[i].name, &nu_can_ops, NULL);
|
||
|
RT_ASSERT(ret == RT_EOK);
|
||
|
}
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
INIT_DEVICE_EXPORT(rt_hw_can_init);
|
||
|
#endif //#if defined(BSP_USING_CAN)
|