• RT-thread 中CAN总线的应用

    准备：

            RT-thread Studio 2.2.5

            CubeMX 6.6.1

            rt-thread驱动包 4.0.3  

    1.新建项目

            

    2.打开CubeMX Settings ，设置CAN。

    找到CAN1，并勾选激活，然后直接获取代码（无需任何操作）。然后关闭CubeMX窗口会弹出一个提示框，告诉你：

    原先  drivers目录下：stm32f4xx_hal_conf.h文件 重命名为：stm32f4xx_hal_conf_bak.h(即该配置文件失效了)。并在cubemx/lnc目录下重新生成了新的配置文件。

    注意：要在 ”cubemx/lnc/stm32f4xx_hal_conf.h“ 中取消对  ”#define HAL_UART_MODULE_ENABLED“ 的注释。因为控制台中有用到串口，这里不取消注释会报错。

     

     

     

     3.修改board.h文件

    1. /*    在board.h中添加宏定义 启用CAN*/
    2. #define BSP_USING_CAN
    3. #define BSP_USING_CAN1

     4.启用CAN组件,并在示例/rt-thread设备驱动示例中打开can device。

     5.在drivers目录下添加drv_can.c 和drv_can.h文件

    这两个文件在下面这个目录中：

    X:\RT-ThreadStudio\repo\Extract\RT-Thread_Source_Code\RT-Thread\4.0.3\bsp\stm32\libraries\HAL_Drivers

     6.添加官方示例

    1. /*
    2.  * 程序清单：这是一个 CAN 设备使用例程
    3.  * 例程导出了 can_sample 命令到控制终端
    4.  * 命令调用格式：can_sample can1
    5.  * 命令解释：命令第二个参数是要使用的 CAN 设备名称，为空则使用默认的 CAN 设备
    6.  * 程序功能：通过 CAN 设备发送一帧，并创建一个线程接收数据然后打印输出。
    7. */
    8.  
    9. #include 
    10. #include "rtdevice.h"
    11.  
    12. #define CAN_DEV_NAME       "can1"      /* CAN 设备名称 */
    13.  
    14. static struct rt_semaphore rx_sem;     /* 用于接收消息的信号量 */
    15. static rt_device_t can_dev;            /* CAN 设备句柄 */
    16.  
    17. /* 接收数据回调函数 */
    18. static rt_err_t can_rx_call(rt_device_t dev, rt_size_t size)
    19. {
    20.     /* CAN 接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
    21.     rt_sem_release(&rx_sem);
    22.  
    23.     return RT_EOK;
    24. }
    25.  
    26. static void can_rx_thread(void *parameter)
    27. {
    28.     int i;
    29.     rt_err_t res;
    30.     struct rt_can_msg rxmsg = {0};
    31.  
    32.     /* 设置接收回调函数 */
    33.     rt_device_set_rx_indicate(can_dev, can_rx_call);
    34.  
    35. #ifdef RT_CAN_USING_HDR
    36.     struct rt_can_filter_item items[5] =
    37.     {
    38.         RT_CAN_FILTER_ITEM_INIT(0x100, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x100~0x1ff，hdr 为 - 1，设置默认过滤表 */
    39.         RT_CAN_FILTER_ITEM_INIT(0x300, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x300~0x3ff，hdr 为 - 1 */
    40.         RT_CAN_FILTER_ITEM_INIT(0x211, 0, 0, 0, 0x7ff, RT_NULL, RT_NULL), /* std,match ID:0x211，hdr 为 - 1 */
    41.         RT_CAN_FILTER_STD_INIT(0x486, RT_NULL, RT_NULL),                  /* std,match ID:0x486，hdr 为 - 1 */
    42.         {0x555, 0, 0, 0, 0x7ff, 7,}                                       /* std,match ID:0x555，hdr 为 7，指定设置 7 号过滤表 */
    43.     };
    44.     struct rt_can_filter_config cfg = {5, 1, items}; /* 一共有 5 个过滤表 */
    45.     /* 设置硬件过滤表 */
    46.     res = rt_device_control(can_dev, RT_CAN_CMD_SET_FILTER, &cfg);
    47.     RT_ASSERT(res == RT_EOK);
    48. #endif
    49.  
    50.     while (1)
    51.     {
    52.         /* hdr 值为 - 1，表示直接从 uselist 链表读取数据 */
    53.         rxmsg.hdr = -1;
    54.         /* 阻塞等待接收信号量 */
    55.         rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
    56.         /* 从 CAN 读取一帧数据 */
    57.         rt_device_read(can_dev, 0, &rxmsg, sizeof(rxmsg));
    58.         /* 打印数据 ID 及内容 */
    59.         rt_kprintf("ID:%x", rxmsg.id);
    60.         for (i = 0; i < 8; i++)
    61.         {
    62.             rt_kprintf("%2x", rxmsg.data[i]);
    63.         }
    64.  
    65.         rt_kprintf("\n");
    66.     }
    67. }
    68.  
    69. int can_sample(int argc, char *argv[])
    70. {
    71.     struct rt_can_msg msg = {0};
    72.     rt_err_t res;
    73.     rt_size_t  size;
    74.     rt_thread_t thread;
    75.     char can_name[RT_NAME_MAX];
    76.  
    77.     if (argc == 2)
    78.     {
    79.         rt_strncpy(can_name, argv[1], RT_NAME_MAX);
    80.     }
    81.     else
    82.     {
    83.         rt_strncpy(can_name, CAN_DEV_NAME, RT_NAME_MAX);
    84.     }
    85.     /* 查找 CAN 设备 */
    86.     can_dev = rt_device_find(can_name);
    87.     if (!can_dev)
    88.     {
    89.         rt_kprintf("find %s failed!\n", can_name);
    90.         return RT_ERROR;
    91.     }
    92.  
    93.     /* 初始化 CAN 接收信号量 */
    94.     rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
    95.  
    96.     /* 以中断接收及发送方式打开 CAN 设备 */
    97.     res = rt_device_open(can_dev, RT_DEVICE_FLAG_INT_TX | RT_DEVICE_FLAG_INT_RX);
    98.     RT_ASSERT(res == RT_EOK);
    99.     /* 创建数据接收线程 */
    100.     thread = rt_thread_create("can_rx", can_rx_thread, RT_NULL, 1024, 25, 10);
    101.     if (thread != RT_NULL)
    102.     {
    103.         rt_thread_startup(thread);
    104.     }
    105.     else
    106.     {
    107.         rt_kprintf("create can_rx thread failed!\n");
    108.     }
    109.  
    110.     msg.id = 0x78;              /* ID 为 0x78 */
    111.     msg.ide = RT_CAN_STDID;     /* 标准格式 */
    112.     msg.rtr = RT_CAN_DTR;       /* 数据帧 */
    113.     msg.len = 8;                /* 数据长度为 8 */
    114.     /* 待发送的 8 字节数据 */
    115.     msg.data[0] = 0x00;
    116.     msg.data[1] = 0x11;
    117.     msg.data[2] = 0x22;
    118.     msg.data[3] = 0x33;
    119.     msg.data[4] = 0x44;
    120.     msg.data[5] = 0x55;
    121.     msg.data[6] = 0x66;
    122.     msg.data[7] = 0x77;
    123.     /* 发送一帧 CAN 数据 */
    124.     size = rt_device_write(can_dev, 0, &msg, sizeof(msg));
    125.     if (size == 0)
    126.     {
    127.         rt_kprintf("can dev write data failed!\n");
    128.     }
    129.  
    130.     return res;
    131. }
    132. /* 导出到 msh 命令列表中 */
    133. MSH_CMD_EXPORT(can_sample, can device sample);

    7.注意把application中的main.c与cubemx中的main.c合并，并注释掉一个，不然会冲突。

    8.在控制台中输入can_sample命令就可以用CAN接收工具收到数据了。波特率默认1MHz

  • 相关阅读:
    Web后端-请求响应
    统计元音字母个数
    Java设计模式之单例设计模式
    c语言练习65:写一个程序拷贝文件
    【C++笔试强训】第二十四天
    Java基础——Java语言与面向对象
    ABC 327
    一文了解如何获取GPT4账号及AI绘图应用
    使用Spring-data-jpa
    【C/C++】哈希
  • 原文地址：https://blog.csdn.net/qq_41675998/article/details/126664178