1 /*
2 * Copyright (c) 2022-2024, Xiaohua Semiconductor Co., Ltd.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2024-12-30 CDT first version
9 */
10
11 /*
12 * 功能
13 * 展示 CAN1、CAN2、CAN3 接收消息和回发消息。
14 * 代码使用方法
15 * 在终端执行：can_sample 参数选择：can1 | can2 | can3 以启动CAN收发测试
16 *
17 * 默认波特率
18 * 仲裁段:波特率500K,采样率80%
19 * 数据段:波特率为4M,采样率80% (仅支持CAN FD的单元)
20 *
21 * 接收和发送消息
22 * CAN1:
23 * 仅接收满足以下过滤条件的消息，并发送接收到的消息
24 * 1）标准帧：match ID:0x100~0x1ff
25 * 2）扩展帧：match ID:0x12345100~0x123451ff
26 * 3）固定ID帧: match ID: 0x555
27 * 测试设备发送满足以上过滤条件的消息后，会在终端打印接收到的ID和消息，并将消息原样发回给测试设备。
28 *
29 * 命令行命令
30 * 1）设置时序： (仅支持CAN FD的单元)
31 * 注意：使用此项设置前，需修改 MSH 最大参数格式为 20
32 * （menuconfig-->RT-Thread Components-->MSH: command shell-->The number of arguments for a shell command）
33 * 格式：
34 * can set_bittiming <count> <rt_can_bit_timing_arbitration> <rt_can_bit_timing_data>
35 * 示例:
36 * MSH >can set_bittiming 1 1 64 16 16 0 (设置can 仲裁段波特率500K)
37 * MSH >can set_bittiming 2 1 64 16 16 0 1 16 4 4 16 (设置can 仲裁段波特率500K,数据段波特率2M)
38 * 2）设置仲裁段波特率：
39 * 格式：
40 * can set_baud <baud>
41 * 示例：
42 * MSH >can set_baud 1000000 （设置can仲裁段波特率1M）
43 * 3）设置数据段波特率： (仅支持CAN FD的单元)
44 * 格式：
45 * can set_baudfd <baudfd>
46 * 示例：
47 * MSH >can set_baudfd 2000000 （设置can数据段波特率2M）
48 * 4）发送消息：
49 * 格式：
50 * can send_msg
51 * 示例：
52 * MSH >can send_msg （触发can发送数据）
53 */
54 #include <stdlib.h>
55 #include <string.h>
56 #include <rtthread.h>
57 #include "rtdevice.h"
58 #include "drv_can.h"
59
60 #define MSH_USAGE_CAN_SAMPLE "can_sample <can1 | can2 | mcan1 | mcan2> - open can device and test\n"
61 #define MSH_USAGE_CAN_SET_BAUD "can set_baud <baud> - set can baud\n"
62 #define MSH_USAGE_CAN_SET_BAUDFD "can set_baudfd <baudfd> - set can baudfd\n"
63 #define MSH_USAGE_CAN_SET_BITTIMING "can set_bittiming <count> <rt_can_bit_timing_arbitration> <rt_can_bit_timing_data> - set can bit timing,\n"
64 #define MSH_USAGE_CAN_SEND_MSG "can send_msg \n"
65
66 #define MSH_RESULT_STR(result) ((result == RT_EOK) ? "success" : "failure")
67
68 static rt_device_t can_dev = RT_NULL;
69 static struct rt_semaphore can_rx_sem;
70 static rt_mutex_t can_mutex = RT_NULL;
71 static rt_thread_t rx_thread;
72
73 #define CAN_IF_INIT() do { \
74 if (can_dev == RT_NULL || can_mutex == RT_NULL) { \
75 rt_kprintf("failed! please first execute can_sample cmd!\n"); \
76 return; \
77 } \
78 } while (0)
79
can_rx_call(rt_device_t dev,rt_size_t size)80 static rt_err_t can_rx_call(rt_device_t dev, rt_size_t size)
81 {
82 rt_sem_release(&can_rx_sem);
83 return RT_EOK;
84 }
85
_set_default_filter(void)86 static void _set_default_filter(void)
87 {
88 #ifdef RT_CAN_USING_HDR
89 struct rt_can_filter_item can_items[3] =
90 {
91 RT_CAN_FILTER_ITEM_INIT(0x100, RT_CAN_STDID, RT_CAN_DTR, 1, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x100~0x1ff，过滤表模式为1(0表示标识符列表模式，1表示标识符屏蔽位模式)，hdr = -1(表示不指定过滤表号)，设置默认过滤表，过滤表回调函数和参数均为NULL */
92 RT_CAN_FILTER_ITEM_INIT(0x12345100, RT_CAN_EXTID, RT_CAN_DTR, 1, 0xFFFFFF00, RT_NULL, RT_NULL), /* ext,match ID:0x12345100~0x123451ff，hdr = -1 */
93 {0x555, RT_CAN_STDID, RT_CAN_DTR, 1, 0x7ff, 7} /* std,match ID:0x555，hdr= 7，指定设置7号过滤表 */
94 };
95 struct rt_can_filter_config cfg = {3, 1, can_items}; /* 一共有3个过滤表，1表示初始化过滤表控制块 */
96 rt_err_t res;
97 res = rt_device_control(can_dev, RT_CAN_CMD_SET_FILTER, &cfg);
98 RT_ASSERT(res == RT_EOK);
99 #endif
100 }
101
can_rx_thread(void * parameter)102 static void can_rx_thread(void *parameter)
103 {
104 struct rt_can_msg rxmsg = {0};
105 rt_size_t size;
106
107 while (1)
108 {
109 rt_memset(&rxmsg, 0, sizeof(struct rt_can_msg));
110 rt_sem_take(&can_rx_sem, RT_WAITING_FOREVER);
111 rt_mutex_take(can_mutex, RT_WAITING_FOREVER);
112 /* hdr 值为 - 1，表示直接从 uselist 链表读取数据 */
113 rxmsg.hdr_index = -1;
114 /* 从 CAN 读取一帧数据 */
115 rt_device_read(can_dev, 0, &rxmsg, sizeof(rxmsg));
116 /* 打印数据 ID 及内容 */
117 rt_kprintf("ID:%x Data:", rxmsg.id);
118 for (int i = 0; i < rxmsg.len; i++)
119 {
120 rt_kprintf("%2x ", rxmsg.data[i]);
121 }
122 rt_kprintf("\n");
123 /* 发送接收到的消息 */
124 size = rt_device_write(can_dev, 0, &rxmsg, sizeof(rxmsg));
125 rt_mutex_release(can_mutex);
126 if (size == 0)
127 {
128 rt_kprintf("can dev write data failed!\n");
129 }
130 }
131 }
132
_msh_cmd_set_baud(int argc,char ** argv)133 static void _msh_cmd_set_baud(int argc, char **argv)
134 {
135 rt_err_t result;
136
137 if (argc == 3)
138 {
139 uint32_t baud = atoi(argv[2]);
140 CAN_IF_INIT();
141 rt_mutex_take(can_mutex, RT_WAITING_FOREVER);
142 result = rt_device_control(can_dev, RT_CAN_CMD_SET_BAUD, (void *)baud);
143 rt_mutex_release(can_mutex);
144 rt_kprintf("set %s \n", MSH_RESULT_STR(result));
145 }
146 else
147 {
148 rt_kprintf(MSH_USAGE_CAN_SET_BAUD);
149 rt_kprintf(" e.g. MSH >can set_baud 500000\n");
150 }
151 }
152
153 #ifdef RT_CAN_USING_CANFD
_msh_cmd_set_timing(int argc,char ** argv)154 void _msh_cmd_set_timing(int argc, char **argv)
155 {
156 rt_err_t result;
157
158 if (argc == 8 || argc == 13)
159 {
160 uint32_t count = atoi(argv[2]);
161 if (count > 2)
162 {
163 rt_kprintf("param error: count exceed max value 2 \n");
164 return;
165 }
166
167 struct rt_can_bit_timing items[2];
168 struct rt_can_bit_timing_config cfg;
169 uint32_t pos = 3;
170 items[0].prescaler = atoi(argv[pos++]);
171 items[0].num_seg1 = atoi(argv[pos++]);
172 items[0].num_seg2 = atoi(argv[pos++]);
173 items[0].num_sjw = atoi(argv[pos++]);
174 items[0].num_sspoff = atoi(argv[pos++]);
175 if (count > 1)
176 {
177 items[1].prescaler = atoi(argv[pos++]);
178 items[1].num_seg1 = atoi(argv[pos++]);
179 items[1].num_seg2 = atoi(argv[pos++]);
180 items[1].num_sjw = atoi(argv[pos++]);
181 items[1].num_sspoff = atoi(argv[pos]);
182 }
183 cfg.count = count;
184 cfg.items = items;
185 CAN_IF_INIT();
186 rt_mutex_take(can_mutex, RT_WAITING_FOREVER);
187 result = rt_device_control(can_dev, RT_CAN_CMD_SET_BITTIMING, &cfg);
188 rt_mutex_release(can_mutex);
189 rt_kprintf("set %s \n", MSH_RESULT_STR(result));
190 }
191 else
192 {
193 rt_kprintf(MSH_USAGE_CAN_SET_BITTIMING);
194 rt_kprintf(" e.g. MSH >can set_bittiming 1 1 64 16 16 0\n");
195 rt_kprintf(" e.g. MSH >can set_bittiming 2 1 64 16 16 0 1 16 4 4 16\n");
196 }
197 }
198
_msh_cmd_set_baudfd(int argc,char ** argv)199 void _msh_cmd_set_baudfd(int argc, char **argv)
200 {
201 rt_err_t result;
202
203 if (argc == 3)
204 {
205 uint32_t baudfd = atoi(argv[2]);
206 CAN_IF_INIT();
207 rt_mutex_take(can_mutex, RT_WAITING_FOREVER);
208 result = rt_device_control(can_dev, RT_CAN_CMD_SET_BAUD_FD, (void *)baudfd);
209 rt_mutex_release(can_mutex);
210 rt_kprintf("set %s \n", MSH_RESULT_STR(result));
211 }
212 else
213 {
214 rt_kprintf(MSH_USAGE_CAN_SET_BAUDFD);
215 rt_kprintf(" e.g. MSH >can set_baudfd 4000000\n");
216 }
217 }
218 #endif
219
_msh_cmd_send_msg(int argc,char ** argv)220 void _msh_cmd_send_msg(int argc, char **argv)
221 {
222 rt_size_t size;
223 struct rt_can_msg msg = {0};
224 uint8_t u8Tick;
225
226 if (argc == 2)
227 {
228 CAN_IF_INIT();
229 rt_mutex_take(can_mutex, RT_WAITING_FOREVER);
230 #ifdef RT_CAN_USING_CANFD
231 msg.id = 0x300;
232 msg.ide = RT_CAN_STDID;
233 msg.rtr = RT_CAN_DTR;
234 msg.len = 0xFU;
235 msg.fd_frame = 1;
236 msg.brs = 1;
237 for (u8Tick = 0; u8Tick < 64; u8Tick++)
238 {
239 msg.data[u8Tick] = u8Tick + 1 + 0xA0;
240 }
241 #else
242 msg.id = 0x300;
243 msg.ide = RT_CAN_STDID;
244 msg.rtr = RT_CAN_DTR;
245 #ifdef BSP_USING_MCAN
246 msg.len = MCAN_DLC8;
247 #else
248 msg.len = CAN_DLC8;
249 #endif
250 for (u8Tick = 0; u8Tick < 8; u8Tick++)
251 {
252 msg.data[u8Tick] = u8Tick + 1 + 0xA0;
253 }
254 #endif
255 /* 发送一帧 CAN 数据 */
256 size = rt_device_write(can_dev, 0, &msg, sizeof(msg));
257 if (size == 0)
258 {
259 rt_kprintf("can dev write data failed!\n");
260 }
261
262 rt_mutex_release(can_mutex);
263 rt_kprintf("send msg ok! \n");
264 }
265 else
266 {
267 rt_kprintf(MSH_USAGE_CAN_SET_BAUD);
268 rt_kprintf(" e.g. MSH >can send_msg \n");
269 }
270 }
271
_show_usage(void)272 void _show_usage(void)
273 {
274 rt_kprintf("Usage: \n");
275 rt_kprintf(MSH_USAGE_CAN_SET_BAUD);
276 #ifdef RT_CAN_USING_CANFD
277 rt_kprintf(MSH_USAGE_CAN_SET_BAUDFD);
278 rt_kprintf(MSH_USAGE_CAN_SET_BITTIMING);
279 #endif
280 rt_kprintf(MSH_USAGE_CAN_SEND_MSG);
281 }
282
can(int argc,char ** argv)283 int can(int argc, char **argv)
284 {
285 if (!strcmp(argv[1], "set_baud"))
286 {
287 _msh_cmd_set_baud(argc, argv);
288 }
289 #ifdef RT_CAN_USING_CANFD
290 else if (!strcmp(argv[1], "set_baudfd"))
291 {
292 _msh_cmd_set_baudfd(argc, argv);
293 }
294 else if (!strcmp(argv[1], "set_bittiming"))
295 {
296 _msh_cmd_set_timing(argc, argv);
297 }
298 #endif
299 else if (!strcmp(argv[1], "send_msg"))
300 {
301 _msh_cmd_send_msg(argc, argv);
302 }
303 else
304 {
305 _show_usage();
306 return -RT_ERROR;
307 }
308
309 return RT_EOK;
310 }
311 MSH_CMD_EXPORT(can, can function configuration);
312
can_sample(int argc,char ** argv)313 int can_sample(int argc, char **argv)
314 {
315 char can_name[RT_NAME_MAX];
316 char sem_name[RT_NAME_MAX] = "can_sem";
317 char mutex_name[RT_NAME_MAX] = "can_mtx";
318 rt_err_t res;
319
320 if (argc == 2)
321 {
322 rt_strcpy(can_name, argv[1]);
323 /* 设备已经打开则关闭 */
324 if (can_dev != RT_NULL)
325 {
326 rt_device_close(can_dev);
327 }
328 /* 查找设备 */
329 can_dev = rt_device_find(can_name);
330 if (can_dev == RT_NULL)
331 {
332 rt_kprintf("find %s failed!\n", can_name);
333 return -RT_ERROR;
334 }
335 rt_kprintf("found %s\n", can_name);
336
337 if (can_mutex == RT_NULL)
338 {
339 rt_sem_init(&can_rx_sem, sem_name, 0, RT_IPC_FLAG_FIFO);
340 can_mutex = rt_mutex_create(mutex_name, RT_IPC_FLAG_FIFO);
341 }
342
343 res = rt_device_open(can_dev, RT_DEVICE_FLAG_INT_TX | RT_DEVICE_FLAG_INT_RX);
344 RT_ASSERT(res == RT_EOK);
345 res = rt_device_control(can_dev, RT_CAN_CMD_SET_BAUD, (void *)CAN500kBaud);
346 RT_ASSERT(res == RT_EOK);
347 rt_kprintf("baud = %ld\n", CAN500kBaud);
348 res = rt_device_control(can_dev, RT_CAN_CMD_SET_MODE, (void *)RT_CAN_MODE_NORMAL);
349 RT_ASSERT(res == RT_EOK);
350
351 #ifdef RT_CAN_USING_CANFD
352 /* 使能CAN_FD BRS功能 */
353 res = rt_device_control(can_dev, RT_CAN_CMD_SET_CANFD, (void *)CAN_FRAME_ISO_FD);
354 RT_ASSERT(res == RT_EOK);
355 res = rt_device_control(can_dev, RT_CAN_CMD_SET_BAUD_FD, (void *)CANFD_DATA_BAUD_4M);
356 RT_ASSERT(res == RT_EOK);
357 rt_kprintf("baudfd = %ld\n", CANFD_DATA_BAUD_4M);
358 #endif
359 /* 设置接收回调函数 */
360 rt_device_set_rx_indicate(can_dev, can_rx_call);
361 /* 设置过滤器 */
362 _set_default_filter();
363
364 if (rx_thread == RT_NULL)
365 {
366 rx_thread = rt_thread_create("can_rx", can_rx_thread, RT_NULL, 2048, 15, 10);
367 if (rx_thread != RT_NULL)
368 {
369 rt_thread_startup(rx_thread);
370 }
371 else
372 {
373 rt_kprintf("create can_rx rx_thread failed!\n");
374 }
375 }
376
377 return RT_EOK;
378 }
379 else
380 {
381 rt_kprintf(MSH_USAGE_CAN_SAMPLE);
382 rt_kprintf(" e.g. MSH >can_sample can1\n");
383 return -RT_ERROR;
384 }
385 }
386 MSH_CMD_EXPORT(can_sample, can sample: select < can1 | can2 | mcan1 | mcan2 >);
387