RT-Thread-CAN调试过程曲折不断，记录调试过程的问题和解决方法。RT-Thread问答社区

CAN调试过程曲折不断，记录调试过程的问题和解决方法。

发布于 2024-10-08 14:04:36 浏览：209 订阅该版

[tocm]

## 编译问题
使用了5.1.0创建工程。CAN编译总是不成功。后来发现5.1.0的drv_can.h/.c与can.c/h不是最新的。

```c
[rt-thread/bsp/stm32/libraries/HAL_Drivers/drivers/drv_can.h at v5.1.0 · RT-Thread/rt-thread · GitHub](https://github.com/RT-Thread/rt-thread/blob/v5.1.0/bsp/stm32/libraries/HAL_Drivers/drivers/drv_can.h)
```
到这下载最新的相应文件替换
## 接收问题
使用了示例代码如下，发现能触发事件但是收不到数据，后来研究发现开了硬件过滤，关了就好了。

```c
#include "rtthread.h"
#include "rtdevice.h"

/* can接收事件标志 */
#define CAN_RX_EVENT (1 << 0)
static rt_device_t can_device = RT_NULL;
static struct rt_event can_event;

static rt_err_t can_rx_ind(rt_device_t device, rt_size_t len)
{
    rt_event_send(&can_event, CAN_RX_EVENT);
    return RT_EOK;
}
/* CAN初始化 */
static rt_err_t can_open()
{
    can_device = rt_device_find("can1");
    if (RT_NULL == can_device)
    {
        rt_kprintf("can1 device not found!\n");
        return -RT_ERROR;
    }
//    rt_device_control(can_device, RT_CAN_CMD_SET_BAUD, (void *)CAN500kBaud);
    /* 初始化事件对象 */
    rt_event_init(&can_event, "can_rx_event", RT_IPC_FLAG_FIFO);
    /* 设置回调函数发送事件 */
    rt_device_set_rx_indicate(can_device, can_rx_ind);
    return rt_device_open(can_device, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX);
    /* 设置 CAN 通信的波特率为 500kbit/s*/

}

void print_can_msg(struct rt_can_msg *data)
{
    rt_kprintf("\n");
    if (RT_CAN_STDID == data->ide)
    {
        rt_kprintf("STDID=%03X ", data->id);
    }
    else if (RT_CAN_EXTID == data->ide)
    {
        rt_kprintf("EXTID=%08X ", data->id);
    }
    rt_kprintf("HDR=%02X ", data->hdr);
    if (RT_CAN_DTR == data->rtr)
    {
        rt_kprintf("TYPE=DATA LEN=%02X ", data->len);
        for (int i = 0; i < data->len; ++i)
        {
            rt_kprintf("%02X ", data->data[i]);
        }
    }
    else if (RT_CAN_RTR == data->rtr)
    {
        rt_kprintf("TYPE=RMOT LEN=%02X ", data->len);
    }
}

rt_err_t can_write(struct rt_can_msg *data, rt_size_t len)
{
    return rt_device_write(can_device, 0, data, len);
}

rt_err_t can_read(struct rt_can_msg *data, rt_size_t len)
{
    rt_err_t ret = 0;
    rt_uint32_t e;
    while (1)
    {
        ret = rt_event_recv(&can_event, CAN_RX_EVENT, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &e);
        if (RT_EOK != ret){

}
        else
        {
            rt_device_read(can_device, 0, data, len);

print_can_msg(data);
//                rt_thread_mdelay(1);

}
    }
}

#define CAN_ID 0x12

rt_size_t can_sendmsg(const rt_uint8_t *data, const rt_uint32_t len)
{
    struct rt_can_msg msg = {0};
    msg.id = CAN_ID;
    msg.ide = RT_CAN_STDID;
    msg.rtr = 0;
    msg.len = len;
    rt_memcpy(msg.data, data, len);

return rt_device_write(can_device, 0, &msg, sizeof(msg));
}
int can_write_test(int argc, char **argv)
{
    can_sendmsg(argv[1], 8);
}

/********线程入口***************/
void can1_entry(void *param)
{
    struct rt_can_msg msg =
    {
        .id = 1,
        .ide = RT_CAN_STDID,
        .rtr = RT_CAN_DTR,
        .len = 8,
        .data = {0, 1, 2, 3, 4, 5, 6, 7}
    };
    can_write(&msg, sizeof(struct rt_can_msg));

msg.rtr = RT_CAN_RTR;
    can_write(&msg, sizeof(struct rt_can_msg));

msg.ide = RT_CAN_EXTID;
    msg.rtr = RT_CAN_DTR;
    can_write(&msg, sizeof(struct rt_can_msg));

msg.rtr = RT_CAN_RTR;
    can_write(&msg, sizeof(struct rt_can_msg));
//
    while(1)
    {
//        msg.id = 0xff;
//        msg.rtr = RT_CAN_STDID;
//        can_write(&msg, sizeof(struct rt_can_msg));
        can_read(&msg, sizeof(struct rt_can_msg));
        rt_thread_mdelay(100);
    }

}

/*线程创建函数*/
int can1_test(void)
{
    rt_thread_t can1_tid;
    if (RT_EOK != can_open()) return -RT_ERROR;/*创建线程控制块指针来接收线程创建函数的返回值，目的是通过返回值判断线程是否创建ok*/
    can1_tid = rt_thread_create("can1_test",              /*线程名称，系统打印线程时会显示这个线程的名字*/
                            can1_entry,                  /*线程入口函数,入口函数函数名*/
                            RT_NULL,                    /*入口参数*/
                            1024,                        /*设置内存堆栈大小*/
                            2,                          /*设置优先级*/
                            10);                       /*时间片参数，时间片是在有多个相同优先级线程时，这个线程每次被执行多少个时间片*/

/* 如果获得线程控制块，启动这个线程 */
    if (can1_tid != RT_NULL)
        rt_thread_startup(can1_tid);
    return RT_EOK;
}

INIT_APP_EXPORT(can1_test);
/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(can_write_test, test can write);

```
### 波特率问题
发现只能使用1M波特率，修改波特率后无法通信，drv_can.c中波特率配置如下

```c
    {CAN1MBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ  | CAN_BS2_4TQ | 3)},
    {CAN800kBaud, (CAN_SJW_2TQ | CAN_BS1_8TQ  | CAN_BS2_5TQ | 4)},
    {CAN500kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ  | CAN_BS2_5TQ | 6)},
    {CAN250kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ  | CAN_BS2_5TQ | 12)},
    {CAN125kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ  | CAN_BS2_5TQ | 24)},
    {CAN100kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ  | CAN_BS2_5TQ | 30)},
    {CAN50kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ  | CAN_BS2_5TQ | 60)},
    {CAN20kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ  | CAN_BS2_5TQ | 150)},
    {CAN10kBaud, (CAN_SJW_2TQ | CAN_BS1_9TQ  | CAN_BS2_5TQ | 300)}
```
把这个配置丢到STM32CUBE里面发现除了1M的波特率其他的根本对不上号，时钟频率42没问题。
反推后发现CAN_BS2_5TQ应该配置成CAN_BS2_4TQ
![Snipaste_2024-10-08_14-02-19.png](https://oss-club.rt-thread.org/uploads/20241008/65fa68bd6dc638609a23adff1d4a0053.png)
修改后正常

特此记录~诸位避坑