【RT-Thread】nxp rt10xx 设备驱动框架之--can搭建和使用

已于 2022-07-09 09:46:46 修改
阅读量2.1k 收藏 4
点赞数
分类专栏： RTOS RT-Thread 文章标签： 物联网 arm mcu
于 2022-07-08 21:11:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38426553/article/details/125681470
版权

CAN是控制器局域网络(Controller Area Network)的简称，是一种多主方式的串行通讯总线，是国际上应用最广泛的现场总线之一。车载，医疗，船舶等等行业应用十分广泛，基于CAN在汽车行业也逐渐衍生了一套标准协议，本章不扩展讲解，具体通过网络搜索吧。

开发前准备

  • 硬件平台：nxp rt10xx单片机
  • IDE: Keil

1.Kconfig 修改和menuconfig配置

在Env环境menuconfig中 RT-Thread Components->Device Drivers 设备驱动默认为n，所以需要开启。

请添加图片描述

先在Kconfig中添加如下语句，然后在Env环境menuconfig中 Hardware Drivers Config->On-Chip Peripheral Drivers 使能CAN，本章使用CAN2

请添加图片描述

2.工程添加CAN驱动框架和BSP驱动接口

设备驱动框架：can.c BSP接口：drv_can.c fsl_flexcan.c

请添加图片描述

3.添加或修改drv_can.c

笔者查阅文件，基本不用改动啥，笔者只是调整了下时钟源，其他保持不变

  • 定义can device
struct rt_can_device
{
    struct rt_device parent;

    const struct rt_can_ops *ops;
    struct can_configure config;
    struct rt_can_status status;

    rt_uint32_t timerinitflag;
    struct rt_timer timer;

    struct rt_can_status_ind_type status_indicate;
#ifdef RT_CAN_USING_HDR
    struct rt_can_hdr *hdr;
#endif
#ifdef RT_CAN_USING_BUS_HOOK
    rt_can_bus_hook bus_hook;
#endif /*RT_CAN_USING_BUS_HOOK*/
    struct rt_mutex lock;
    void *can_rx;
    void *can_tx;
};

struct rt_can_ops
{
    rt_err_t (*configure)(struct rt_can_device *can, struct can_configure *cfg);
    rt_err_t (*control)(struct rt_can_device *can, int cmd, void *arg);
    int (*sendmsg)(struct rt_can_device *can, const void *buf, rt_uint32_t boxno);
    int (*recvmsg)(struct rt_can_device *can, void *buf, rt_uint32_t boxno);
};

static struct rt_can_ops imxrt_can_ops =
{
    .configure    = can_cfg,
    .control      = can_control,
    .sendmsg      = can_send,
    .recvmsg      = can_recv,
};
  • 设备创建注册
int rt_hw_can_init(void)
{
    int i;
    rt_err_t ret = RT_EOK;
    struct can_configure config = CANDEFAULTCONFIG;

    config.privmode = 0;
    config.ticks = 50;
    config.sndboxnumber = 16;             /* send Mailbox count */
    config.msgboxsz = RX_MB_COUNT;        /* RX msg buffer count */
#ifdef RT_CAN_USING_HDR
    config.maxhdr = RX_MB_COUNT;          /* filter count,one filter per MB */
#endif

    for (i = 0; i < sizeof(flexcans) / sizeof(flexcans[0]); i++)
    {
        flexcans[i].can_dev.config = config;
        ret = rt_hw_can_register(&flexcans[i].can_dev, flexcans[i].name, &imxrt_can_ops, &flexcans[i]);
    }

    return ret;
}
INIT_BOARD_EXPORT(rt_hw_can_init);
  • 基于imxrt can device 驱动相关函数
/* Select 60M clock divided by USB1 PLL (480 MHz) as master flexcan clock source */
#define FLEXCAN_CLOCK_SOURCE_SELECT  (0U)
/* Clock divider for master flexcan clock source */
#define FLEXCAN_CLOCK_SOURCE_DIVIDER (2U)
/* Get frequency of flexcan clock */
#define EXAMPLE_CAN_CLK_FREQ ((CLOCK_GetFreq(kCLOCK_Usb1PllClk) / 8) / (FLEXCAN_CLOCK_SOURCE_DIVIDER + 1U))

static void flexcan_callback(CAN_Type *base, flexcan_handle_t *handle, status_t status, uint32_t result, void *userData)
{
    struct imxrt_can *can;
    flexcan_mb_transfer_t rxXfer;

    can = (struct imxrt_can *)userData;

    switch (status)
    {
    case kStatus_FLEXCAN_RxIdle:
        rt_hw_can_isr(&can->can_dev, RT_CAN_EVENT_RX_IND | result << 8);
        rxXfer.frame = &frame[result - 1];
        rxXfer.mbIdx = result;
        FLEXCAN_TransferReceiveNonBlocking(can->base, &can->handle, &rxXfer);
        break;

    case kStatus_FLEXCAN_TxIdle:
        rt_hw_can_isr(&can->can_dev, RT_CAN_EVENT_TX_DONE | (63 - result) << 8);
        break;

    case kStatus_FLEXCAN_WakeUp:

    case kStatus_FLEXCAN_ErrorStatus:
        if ((result >= 47) && (result <= 63))
        {
            rt_hw_can_isr(&can->can_dev, RT_CAN_EVENT_TX_FAIL | (63 - result) << 8);
        }
        break;

    case kStatus_FLEXCAN_TxSwitchToRx:
        break;

    default:
        break;
    }
}

static rt_err_t can_cfg(struct rt_can_device *can_dev, struct can_configure *cfg)
{
    struct imxrt_can *can;
    flexcan_config_t config;
    rt_uint32_t res = RT_EOK;
    flexcan_rx_mb_config_t mbConfig;
    flexcan_mb_transfer_t rxXfer;
    rt_uint8_t i, mailbox;

    RT_ASSERT(can_dev != RT_NULL);
    RT_ASSERT(cfg != RT_NULL);

    can = (struct imxrt_can *)can_dev->parent.user_data;
    RT_ASSERT(can != RT_NULL);

	/*Clock setting for FLEXCAN*/
	CLOCK_SetMux(kCLOCK_CanMux, FLEXCAN_CLOCK_SOURCE_SELECT);
	CLOCK_SetDiv(kCLOCK_CanDiv, FLEXCAN_CLOCK_SOURCE_DIVIDER);	

    FLEXCAN_GetDefaultConfig(&config);
    config.baudRate = cfg->baud_rate;
    config.maxMbNum = 64;               /* all series have 64 MB */
    config.enableIndividMask = true;    /* one filter per MB */
    switch (cfg->mode)
    {
    case RT_CAN_MODE_NORMAL:
        /* default mode */
        break;
    case RT_CAN_MODE_LISEN:
        break;
    case RT_CAN_MODE_LOOPBACK:
        config.enableLoopBack = true;
        break;
    case RT_CAN_MODE_LOOPBACKANLISEN:
        break;
    }
    FLEXCAN_Init(can->base, &config, EXAMPLE_CAN_CLK_FREQ);

    /* Create FlexCAN handle structure and set call back function. */
    FLEXCAN_TransferCreateHandle(can->base, &can->handle, flexcan_callback, can);

    /* init RX_MB_COUNT RX MB to default status */
    mbConfig.format = kFLEXCAN_FrameFormatStandard;  /* standard ID */
    mbConfig.type = kFLEXCAN_FrameTypeData;          /* data frame */
    mbConfig.id = FLEXCAN_ID_STD(0);                 /* default ID is 0 */
    for (i = 0; i < RX_MB_COUNT; i++)
    {
        /* the used MB index from 1 to RX_MB_COUNT */
        mailbox = i + 1;
        /* all ID bit in the filter is "don't care" */
        FLEXCAN_SetRxIndividualMask(can->base, mailbox, FLEXCAN_RX_MB_STD_MASK(0, 0, 0));
        FLEXCAN_SetRxMbConfig(can->base, mailbox, &mbConfig, true);
        /* one frame buffer per MB */
        rxXfer.frame = &frame[i];
        rxXfer.mbIdx = mailbox;
        FLEXCAN_TransferReceiveNonBlocking(can->base, &can->handle, &rxXfer);
    }

    NVIC_SetPriority(CAN1_IRQn, CAN_ISR_PRE);
    NVIC_SetPriority(CAN2_IRQn, CAN_ISR_PRE);

    return res;
}

static rt_err_t can_control(struct rt_can_device *can_dev, int cmd, void *arg)
{
    struct imxrt_can *can;
    rt_uint32_t argval, mask;
    rt_uint32_t res = RT_EOK;
    flexcan_rx_mb_config_t mbConfig;
    struct rt_can_filter_config  *cfg;
    struct rt_can_filter_item *item;
    rt_uint8_t i, count, index;

    RT_ASSERT(can_dev != RT_NULL);

    can = (struct imxrt_can *)can_dev->parent.user_data;
    RT_ASSERT(can != RT_NULL);

    switch (cmd)
    {
    case RT_DEVICE_CTRL_SET_INT:
        argval = (rt_uint32_t) arg;
        if (argval == RT_DEVICE_FLAG_INT_RX)
        {
            mask = kFLEXCAN_RxWarningInterruptEnable;
        }
        else if (argval == RT_DEVICE_FLAG_INT_TX)
        {
            mask = kFLEXCAN_TxWarningInterruptEnable;
        }
        else if (argval == RT_DEVICE_CAN_INT_ERR)
        {
            mask = kFLEXCAN_ErrorInterruptEnable;
        }
        FLEXCAN_EnableInterrupts(can->base, mask);
        NVIC_SetPriority(can->irqn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
        EnableIRQ(can->irqn);
        break;
    case RT_DEVICE_CTRL_CLR_INT:
        /* each CAN device have one IRQ number. */
        DisableIRQ(can->irqn);
        break;
    case RT_CAN_CMD_SET_FILTER:
        cfg = (struct rt_can_filter_config *)arg;
        item = cfg->items;
        count = cfg->count;

        if (filter_mask == 0xffffffff)
        {
            LOG_E("%s filter is full!\n", can->name);
            res = RT_ERROR;
            break;
        }
        else if (filter_mask == 0)
        {
            /* deinit all init RX MB */
            for (i = 0; i < RX_MB_COUNT; i++)
            {
                FLEXCAN_SetRxMbConfig(can->base, i + 1, RT_NULL, false);
            }
        }

        while (count)
        {
            if (item->ide)
            {
                mbConfig.format = kFLEXCAN_FrameFormatExtend;
                mbConfig.id = FLEXCAN_ID_EXT(item->id);
                mask = FLEXCAN_RX_MB_EXT_MASK(item->mask, 0, 0);
            }
            else
            {
                mbConfig.format = kFLEXCAN_FrameFormatStandard;
                mbConfig.id = FLEXCAN_ID_STD(item->id);
                mask = FLEXCAN_RX_MB_STD_MASK(item->mask, 0, 0);
            }

            if (item->rtr)
            {
                mbConfig.type = kFLEXCAN_FrameTypeRemote;
            }
            else
            {
                mbConfig.type = kFLEXCAN_FrameTypeData;
            }

            /* user does not specify hdr index,set hdr from RX MB 1 */
            if (item->hdr == -1)
            {

                for (i = 0; i < 32; i++)
                {
                    if (!(filter_mask & (1 << i)))
                    {
                        index = i;
                        break;
                    }
                }
            }
            else    /* use user specified hdr */
            {
                if (filter_mask & (1 << item->hdr))
                {
                    res = RT_ERROR;
                    LOG_E("%s hdr%d filter already set!\n", can->name, item->hdr);
                    break;
                }
                else
                {
                    index = item->hdr;
                }
            }

            /* RX MB index from 1 to 32,hdr index 0~31 map RX MB index 1~32. */
            FLEXCAN_SetRxIndividualMask(can->base, index + 1, mask);
            FLEXCAN_SetRxMbConfig(can->base, index + 1, &mbConfig, true);
            filter_mask |= 1 << index;

            item++;
            count--;
        }

        break;

    case RT_CAN_CMD_SET_BAUD:
        res = RT_ERROR;
        break;
    case RT_CAN_CMD_SET_MODE:
        res = RT_ERROR;
        break;

    case RT_CAN_CMD_SET_PRIV:
        res = RT_ERROR;
        break;
    case RT_CAN_CMD_GET_STATUS:
        FLEXCAN_GetBusErrCount(can->base, (rt_uint8_t *)(&can->can_dev.status.snderrcnt), (rt_uint8_t *)(&can->can_dev.status.rcverrcnt));
        rt_memcpy(arg, &can->can_dev.status, sizeof(can->can_dev.status));
        break;
    default:
        res = RT_ERROR;
        break;
    }

    return res;
}

static int can_send(struct rt_can_device *can_dev, const void *buf, rt_uint32_t boxno)
{
    struct imxrt_can *can;
    struct rt_can_msg *msg;
    status_t ret;
    flexcan_frame_t frame;
    flexcan_mb_transfer_t txXfer;
    rt_uint8_t sendMB;

    RT_ASSERT(can_dev != RT_NULL);
    RT_ASSERT(buf != RT_NULL);

    can = (struct imxrt_can *)can_dev->parent.user_data;
    msg = (struct rt_can_msg *) buf;
    RT_ASSERT(can != RT_NULL);
    RT_ASSERT(msg != RT_NULL);

    /* use the last 16 MB to send msg */
    sendMB = 63 - boxno;
    FLEXCAN_SetTxMbConfig(can->base, sendMB, true);

    if (RT_CAN_STDID == msg->ide)
    {
        frame.id = FLEXCAN_ID_STD(msg->id);
        frame.format = kFLEXCAN_FrameFormatStandard;
    }
    else if (RT_CAN_EXTID == msg->ide)
    {
        frame.id = FLEXCAN_ID_EXT(msg->id);
        frame.format = kFLEXCAN_FrameFormatExtend;
    }

    if (RT_CAN_DTR == msg->rtr)
    {
        frame.type = kFLEXCAN_FrameTypeData;
    }
    else if (RT_CAN_RTR == msg->rtr)
    {
        frame.type = kFLEXCAN_FrameTypeRemote;
    }

    frame.length = msg->len;
    frame.dataByte0 = msg->data[0];
    frame.dataByte1 = msg->data[1];
    frame.dataByte2 = msg->data[2];
    frame.dataByte3 = msg->data[3];
    frame.dataByte4 = msg->data[4];
    frame.dataByte5 = msg->data[5];
    frame.dataByte6 = msg->data[6];
    frame.dataByte7 = msg->data[7];

    txXfer.mbIdx = sendMB;
    txXfer.frame = &frame;

    ret = FLEXCAN_TransferSendNonBlocking(can->base, &can->handle, &txXfer);
    switch (ret)
    {
    case kStatus_Success:
        ret = RT_EOK;
        break;
    case kStatus_Fail:
        ret = RT_ERROR;
        break;
    case kStatus_FLEXCAN_TxBusy:
        ret = RT_EBUSY;
        break;
    }

    return ret;
}

static int can_recv(struct rt_can_device *can_dev, void *buf, rt_uint32_t boxno)
{
    struct imxrt_can *can;
    struct rt_can_msg *pmsg;
    rt_uint8_t index;

    RT_ASSERT(can_dev != RT_NULL);

    can = (struct imxrt_can *)can_dev->parent.user_data;
    pmsg = (struct rt_can_msg *) buf;
    RT_ASSERT(can != RT_NULL);

    index = boxno - 1;

    if (frame[index].format == kFLEXCAN_FrameFormatStandard)
    {
        pmsg->ide = RT_CAN_STDID;
        pmsg->id = frame[index].id >> CAN_ID_STD_SHIFT;
    }
    else
    {
        pmsg->ide = RT_CAN_EXTID;
        pmsg->id = frame[index].id >> CAN_ID_EXT_SHIFT;
    }

    if (frame[index].type == kFLEXCAN_FrameTypeData)
    {
        pmsg->rtr = RT_CAN_DTR;
    }
    else if (frame[index].type == kFLEXCAN_FrameTypeRemote)
    {
        pmsg->rtr = RT_CAN_RTR;
    }
    pmsg->hdr = index;      /* one hdr filter per MB */
    pmsg->len = frame[index].length;
    pmsg->data[0] = frame[index].dataByte0;
    pmsg->data[1] = frame[index].dataByte1;
    pmsg->data[2] = frame[index].dataByte2;
    pmsg->data[3] = frame[index].dataByte3;
    pmsg->data[4] = frame[index].dataByte4;
    pmsg->data[5] = frame[index].dataByte5;
    pmsg->data[6] = frame[index].dataByte6;
    pmsg->data[7] = frame[index].dataByte7;

    return 0;
}

4.搭建应用层demo

底层IO初始化

IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B0_02_FLEXCAN2_TX, 1U); 
IOMUXC_SetPinMux(IOMUXC_GPIO_AD_B0_03_FLEXCAN2_RX, 1U); 
IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B0_02_FLEXCAN2_TX, 0x10B0u); 
IOMUXC_SetPinConfig(IOMUXC_GPIO_AD_B0_03_FLEXCAN2_RX, 0x10B0u);

can 波特率设置为：500K (can.h文件中)

#define CANDEFAULTCONFIG \
{\
        CAN500kBaud,\
        RT_CANMSG_BOX_SZ,\
        RT_CANSND_BOX_NUM,\
        RT_CAN_MODE_NORMAL,\
};

应用基本拷贝官方提供demo测试就行了：demo主要测试CAN收发数据和帧过滤的应用

/**************************************************START OF FILE*****************************************************/






/*------------------------------------------------------------------------------------------------------------------
Includes
*/
#include <rtthread.h>
#include <rtdevice.h>


/*------------------------------------------------------------------------------------------------------------------
Macros
*/
#define CAN_DEV_NAME       "can2"      /* CAN 设备名称 */

/*------------------------------------------------------------------------------------------------------------------
Variables
*/
static struct rt_semaphore rx_sem;     /* 用于接收消息的信号量 */
static rt_device_t can_dev;            /* CAN 设备句柄 */

/*------------------------------------------------------------------------------------------------------------------
Functions
*/
/* 接收数据回调函数 */
static rt_err_t can_rx_call(rt_device_t dev, rt_size_t size)
{
    /* CAN 接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
    rt_sem_release(&rx_sem);

    return RT_EOK;
}

static void can_rx_thread(void *parameter)
{
    int i;
    rt_err_t res;
    struct rt_can_msg rxmsg = {0};

    /* 设置接收回调函数 */
    rt_device_set_rx_indicate(can_dev, can_rx_call);

#ifdef RT_CAN_USING_HDR
    struct rt_can_filter_item items[5] =
    {
        RT_CAN_FILTER_ITEM_INIT(0x100, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x100~0x1ff，hdr 为 - 1，设置默认过滤表 */
        RT_CAN_FILTER_ITEM_INIT(0x300, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x300~0x3ff，hdr 为 - 1 */
        RT_CAN_FILTER_ITEM_INIT(0x211, 0, 0, 0, 0x7ff, RT_NULL, RT_NULL), /* std,match ID:0x211，hdr 为 - 1 */
        RT_CAN_FILTER_STD_INIT(0x486, RT_NULL, RT_NULL),                  /* std,match ID:0x486，hdr 为 - 1 */
        {0x555, 0, 0, 0, 0x7ff, 7,}                                       /* std,match ID:0x555，hdr 为 7，指定设置 7 号过滤表 */
    };
    struct rt_can_filter_config cfg = {5, 1, items}; /* 一共有 5 个过滤表 */
	
	/* 设置硬件过滤表 */
    res = rt_device_control(can_dev, RT_CAN_CMD_SET_FILTER, &cfg);
    RT_ASSERT(res == RT_EOK);
#endif

    while (1)
    {
        /* hdr 值为 - 1，表示直接从 uselist 链表读取数据 */
        rxmsg.hdr = -1;
        /* 阻塞等待接收信号量 */
        rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
        /* 从 CAN 读取一帧数据 */
        rt_device_read(can_dev, 0, &rxmsg, sizeof(rxmsg));
        /* 打印数据 ID 及内容 */
        rt_kprintf("ID:%x", rxmsg.id);
		rt_kprintf(" DATA:");
        for (i = 0; i < 8; i++)
        {
            rt_kprintf("%2x", rxmsg.data[i]);
        }

        rt_kprintf("\n");
		
		rt_thread_mdelay(2);
    }
}

int can_sample(void)
{
    struct rt_can_msg msg = {0};
    rt_err_t res;
    rt_size_t  size;
    rt_thread_t thread;
    char can_name[RT_NAME_MAX];

    /* 查找 CAN 设备 */
    can_dev = rt_device_find(CAN_DEV_NAME);
    if (!can_dev)
    {
        rt_kprintf("find %s failed!\n", CAN_DEV_NAME);
        return RT_ERROR;
    }

    /* 初始化 CAN 接收信号量 */
    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);

    /* 以中断接收及发送方式打开 CAN 设备 */
    res = rt_device_open(can_dev, RT_DEVICE_FLAG_INT_TX | RT_DEVICE_FLAG_INT_RX);
    RT_ASSERT(res == RT_EOK);
    /* 创建数据接收线程 */
    thread = rt_thread_create("t_can_rx", can_rx_thread, RT_NULL, 1024, 25, 10);
    if (thread != RT_NULL)
    {
        rt_thread_startup(thread);
    }
    else
    {
        rt_kprintf("create can_rx thread failed!\n");
    }

    msg.id = 0x78;              /* ID 为 0x78 */
    msg.ide = RT_CAN_STDID;     /* 标准格式 */
    msg.rtr = RT_CAN_DTR;       /* 数据帧 */
    msg.len = 8;                /* 数据长度为 8 */
    /* 待发送的 8 字节数据 */
    msg.data[0] = 0x00;
    msg.data[1] = 0x11;
    msg.data[2] = 0x22;
    msg.data[3] = 0x33;
    msg.data[4] = 0x44;
    msg.data[5] = 0x55;
    msg.data[6] = 0x66;
    msg.data[7] = 0x77;
    /* 发送一帧 CAN 数据 */
    size = rt_device_write(can_dev, 0, &msg, sizeof(msg));
    if (size == 0)
    {
        rt_kprintf("can dev write data failed!\n");
    }

    return res;
}

/****************************************************END OF FILE*****************************************************/

将CAN信号接入PCAN设备，然后打开PCAN-View上位机，复位MCU，使用PCAN-View上位机，向MCU发送参数，将会有如下结果：

请添加图片描述

请添加图片描述

L_17
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SylixOS can驱动框架分析
12-24
SylixOS can驱动框架分分析。
STM32F429阿波罗RTTHREAD的CAN驱动
07-08
STM32F429阿波罗 RTTHREAD USBHID和CAN驱动
基于RT-Thread的CAN电机驱动板设计 （三）CAN驱动配置与实现
张竞豪的博客
06-05 2103
引言 上一篇文章实现了基于rtthread的uart 的DMA接收驱动的配置与使用。下面重点需要完成rtthread对stm32的CAN驱动的配置，由于rtthread默认工程中没有对特定芯片如stm32的CAN驱动的芯片级驱动代码，但是在rtthread的github仓库中有相关的代码，需要我们自己完成配置。因此本文的重点工作是完成stm32的CAN驱动的配置，通过上述流程达到一以贯之的效果，以后再遇到其他协议也可以如此处理。 前期准备 制作好的电机驱动板一块 USB转485模块一个，用来插在PC上实现
灵动微MM32芯片FlexCAN配置
最新发布
qq_58575597的博客
05-29 358
记录一下自己学习关于灵动微芯MM32F0系列芯片有关CAN的过程，做个笔记！
RT-Thread-CAN通信
嵌入式开发
05-30 1579
RT-Thrad-CAN通信
RT-Thread系列08——CAN设备（CAN收发）
32Haozi
07-22 2137
RT-Thread 使用CAN接口进行收发案例
【NuMaker-M2354试用】基于rt-thread CAN驱动框架通信评测
开发学习过程中一点经验积累
01-17 717
1.前言 1.1 本章内容 本章通过ENV环境配置M2354片上外设CAN的功能，Keil Arm编译，基于rt-thread CAN驱动框架实现开发板和CAN调试器进行CAN通信验证。 1.2模块介绍 BSP已经对接好了CAN的驱动，只需在系统配置上打开相应的开关即可 在ENV环境下，打开系统配置界面，Hardware Drivers Config->On-Chip Peripheral Drivers ->Enable Controller Area Network(CAN)->Ena
20191119 (36) RT-Thread 下 CAN 驱动模块的使用和测试 不含过滤表说明（NXP JTA1050）
你学习了吗？咋办，先想法子忽悠成“砖家”呗
11-19 5656
目的 只针对收/发/配置进行说明 1 了解 CAN 的工作原理 2 了解相关 CAN 的控制语句及配置 3 用例 CAN1 连续发送和接收 在最后 注意: 官方配置可能有问题，需要自行配置 正文 跟 485 一样 CAN 也是两线制的，利用差分信号传输，而为了避免信号的反射和干扰，一般会在 H 和 L 端接上 120 欧姆的电阻，这 120 欧姆的电阻是根据电缆线的特性阻抗决定（一般是 12...
NXP i.MX RT1052 RT-Thread实战：RT-Thread的启动流程
12-01
在本实践教程中，我们将深入探讨NXP i.MX RT1052微控制器与开源RTOS（实时操作系统）RT-Thread的集成应用。NXP i.MX RT1052是一款高性能、低延迟的Cortex-M7内核MCU，特别适合于需要实时性能和快速响应的应用场景。...
NXP i.MX RT1052 RT-Thread实战：事件
12-01
RT-Thread则是一个开源、轻量级的实时操作系统，提供了一套完整的系统服务，包括任务调度、内存管理、设备驱动和网络协议栈等。 首先，让我们了解NXP i.MX RT1052的关键特性。它基于Cortex-M7内核，工作频率高达600...
NXP i.MX RT1052 RT-Thread实战：软件定时器
12-01
在本文中，我们将深入探讨如何在NXP i.MX RT1052微控制器上使用RT-Thread实时操作系统实现软件定时器。NXP i.MX RT1052是一款高性能的跨界处理器，专为需要实时性能和低延迟的应用设计，如工业自动化、物联网设备和...
NXP i.MX RT1052 RT-Thread实战：互斥量
12-01
2. **RT-Thread操作系统**：RT-Thread是一个成熟且广泛使用的实时操作系统，它提供了线程管理、内存管理、设备驱动、网络协议栈等核心功能，支持多种编程语言，并具有良好的可移植性。在NXP i.MX RT1052上使用RT-...
linux 下pci 转can驱动
01-16
PCI转CAN的驱动，linux框架下的linux转can设备驱动，具有很好的借鉴作用
vb-Can.rar_CAN_VB中can_can vb_vb can_vb-can
07-15
用VB做的有关CAN卡的通讯程序，十分好用，对于CAN通讯很实用。
NXP i.MX RT1052 RT-Thread实战：线程管理
12-01
RT-Thread是一个轻量级、开源的操作系统，提供了丰富的功能集，包括线程管理、内存管理、设备驱动、网络协议栈等，非常适合嵌入式开发。 ### 线程管理基础 线程是操作系统调度的基本单位，每个线程代表了程序执行的...
RT-Thread设备和驱动-I/O CAN设备①
华为奋斗者精神
11-16 1115
CAN 是控制器局域网络 (Controller Area Network, CAN) 的简称，是由以研发和生产汽车电子产品著称的德国 BOSCH 公司开发的，并最终成为国际标准（ISO 11898），是国际上应用最广泛的现场总线之一。CAN 控制器根据两根线上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。CAN 的连接示意图如下图所示：CAN 总线有如下特点：CAN 总线是可同时连接多个单元的总线。
RT-thread 中CAN总线的应用
qq_41675998的博客
09-02 2463
rt-thread CAN应用
rt-thread can
超哥的专栏
10-08 4395
rt-thread stm32f10x-HAL can的驱动和应用。源码暂时还不支持，自己通过F4修改了一版 源码地址：https://gitee.com/gitee.thomas/rt_can rtconfig.h配置 #define RT_USING_CAN #define RT_CAN_USING_HDR 源码自测已经通过，欢迎下载 ...
stm32 can Configuration
stude的专栏
09-20 2035
//配置步骤：时钟，GPIO，NVIC，Cell，Fliter，IT使能 void CAN_Configuration(void) {     CAN_InitTypeDef        CAN_InitStructure;     CAN_FilterInitType
RT-thread移植指南-RISC-V.docx
09-24
RT-thread移植指南-移植到RISC-V

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值