(六)CAN总线通讯

---

CAN总线回环测试

第一种基于板载CAN测试

第一步确认板载是否支持

确保你的硬件支持 CAN，并且已经精确安装了驱动程序。可以通过以下下令查抄是否检测到了 CAN 设备：

1. ip link show type can

复制代码

可以看到板载自带了can0和can1.

can0 和 can1：是接口的名称，分别表示系统中的第一个和第二个 CAN 接口。
<NOARP,ECHO>：
NOARP：表示该接口不使用 ARP（地址解析协议）。CAN 总线不需要 ARP 由于它不是基于 IP 的网络。
ECHO：可能启用了回环模式，发送的消息会被自己的 CAN 控制器重新吸收。这里不确定是否启用了，可以用指令ip -details link show 检察到：

大概单看can0，can1的状态，以can0为例子：

1. ip -details link show can0

复制代码

mtu 16：最大传输单元（Maximum Transmission Unit），对于 CAN 接口来说MTU 通常是 16 字节，这是由于 CAN 消息的最大有效载荷是 8 字节，加上一些额外的头部信息。
qdisc noop：队列调度算法（Queueing Discipline），这里使用的是 noop，即空操作队列调度器。这意味着没有任何包调度计谋被应用，所有数据包将直接传递而不会排队。
state DOWN：当前接口状态为关闭（DOWN），意味着接口未激活，无法进行通讯。要激活接口，可以使用 ip link set can0 up

或 ip link set can1 up。
mode DEFAULT：表示接口的工作模式，默认情况下是标准模式。
group default：指明这个接口属于哪个组，default 是默认组。
qlen 10：队列长度（Queue Length），表示可以排队等候处理的数据包数量，在这里是 10。
链路范例
link/can：表明这是一个 CAN 范例的接口。

---

第二步关闭 CAN 接口将 CAN 接口置于非运动状态

假如没有激活的情况，直接跳过此步

1. ip link set can0 down

复制代码

---

第三步 配置 CAN 接口

第一步 设置 CAN 接口比特率

1. ip link set can0 type can bitrate 500000

复制代码

ip link set：这是一个用来配置网络接口的下令。
can0：指定要配置的网络接口名称，这里是 can0。
type can：指明该接口是 CAN 范例的。
bitrate 500000：设置 CAN 总线的数据传输速率（比特率）为 500 kbps。这个值应该根据你的硬件支持和需求进行调解。
设置完可以借助指令检察：

1. ip -details link show can0

复制代码

---

第二步 设置 CAN 启用回环模式

指令：

1. ip link set can0 type can loopback on

复制代码

loopback on：启用回环模式。在这种模式下，所有从 CAN 控制器发出的消息都会被重新送回到同一个控制器，而不会真正发送到物理总线上。这对于测试非常有用，由于它允许你在不毗连任何其他设备的情况下验证软件是否正常工作。

设置完同样可以借助指令检察：

1. ip -details link show can0

复制代码

---

第三步 启用 CAN 接口

指令：

1. ip link set can0 up

复制代码

启动成功后同样可以借助指令检察：

1. ip -details link show can0

复制代码

---

第四步 测试CAN总线回环

捕获 CAN 消息

使用 nohup 和 candump 捕获消息并记录到文件

1. nohup candump can0 > log.txt &

复制代码

nohup：使程序在用户退出终端后继续运行。这对于长时间运行的任务很有用。
candump：这是 Linux 下的一个工具，用于捕获并显示 CAN 消息。它会实时监听指定的 CAN 接口，并输出吸收到的消息。
can0：指定要监听的 CAN 接口。
log.txt：将 candump 的输出重定向到一个名为 log.txt 的文件中，而不是打印到屏幕上。
&：将下令放入背景执行，这样可以在同一终端窗口中继续输入其他下令。

发送 CAN 消息

标准数据帧发8位数据：

1. cansend can0 0B000123#00.00.00.00.00.00.00.01

复制代码

#反面每一位数据不加.也行，留意别发错了
cansend：这是 Linux 下的一个工具，用于向指定的 CAN 接口发送 CAN 消息。
can0：指定要使用的 CAN 接口。
0B000123#00.00.00.00.00.00.00.01：这是要发送的 CAN 消息格式。
具体来说：0B000123是 CAN ID，其中 0B 表示标准帧格式（11位ID），000123是具体的 ID 值。
#分隔符，反面跟着的是数据字段。00.00.00.00.00.00.00.01 是数据字段的内容，表示 8 字节的数据。每个字节用两位十六进制数表示。

实在都用默认，就是标准数据帧：

1. cansend can0 123#00.00.00.00.00.00.00.02

复制代码

数据也可以发0-8任意字节：

1. cansend can0 234#88

复制代码

第二种基于Linux库的原生开发

在 Linux 下进行 CAN 总线应用开发时，通常需要通过系统调用和特定的套接字 API 来与 CAN 接口交互。Linux 内核提供了一个叫做 SocketCAN 的子系统，它使得 CAN 通讯可以像普通的网络编程一样使用标准的 BSD 套接字接口来实现。下面是进行 CAN 应用开发的基本步调：
1. 确认硬件支持

1. ip link show type can

复制代码

加粗样式
可以看到板载自带了can0和can1.

---

2. 配置 CAN 接口

先关闭can接口

1. ip link set can0 down

复制代码

配置波特率：

1. ip link set can0 type can bitrate 500000

复制代码

假如使用回环如下操作，不使用大概使用正常模式就跳过此步，我这里接纳回环测试因此执行此步调：

1. ip link set can0 type can loopback on

复制代码

启动can接口

1. ip link set can0 up

复制代码

至此所有配置完成

---

3. 使用 SocketCAN API 编写应用程序

创建 CAN 套接字

在 C/C++ 中，可以通过 socket() 函数创建一个 CAN 套接字。例如：

1. #include <sys/socket.h>
2. #include <linux/can.h>
3. #include <linux/can/raw.h>
5. int s;
6. if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
7.     perror("Socket creation failed");
8.     return -1;
9. }

复制代码

---

绑定 CAN 接口

接下来，将套接字绑定到具体的 CAN 接口（如 can0）。这可以通过 bind() 函数完成：

1. struct ifreq ifr;
2. struct sockaddr_can addr;
4. addr.can_family = AF_CAN;
5. strcpy(ifr.ifr_name, "can0");
7. if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
8.     perror("Interface index get failed");
9.     close(s);
10.     return -1;
11. }
13. addr.can_ifindex = ifr.ifr_ifindex;
15. if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
16.     perror("Bind to CAN interface failed");
17.     close(s);
18.     return -1;
19. }

复制代码

---

发送和吸收 CAN 消息

1. struct can_frame frame;
3. // 构造要发送的 CAN 帧
4. frame.can_id = 0x123; // CAN ID
5. frame.can_dlc = 8;    // 数据长度码（DLC），表示数据域的字节数
6. memset(frame.data, 0x01, frame.can_dlc); // 设置数据域内容
8. // 发送 CAN 帧
9. if (write(s, &frame, sizeof(struct can_frame)) != sizeof(struct can_frame)) {
10.     perror("Write CAN frame failed");
11.     close(s);
12.     return -1;
13. }
15. // 接收 CAN 帧
16. if (read(s, &frame, sizeof(struct can_frame)) != sizeof(struct can_frame)) {
17.     perror("Read CAN frame failed");
18.     close(s);
19.     return -1;
20. }
22. printf("Received CAN ID=%x, DLC=%d\n", frame.can_id, frame.can_dlc);
23. for (int i = 0; i < frame.can_dlc; ++i)
24.     printf("Data[%d]: %02x\n", i, frame.data[i]);

复制代码

---

示例代码

下面是一段完整的示例代码，展示了如何创建 CAN 套接字、绑定接口、发送和吸收消息:
这里我开启了线程，父线程用来写，子线程用来读；代码被屏蔽掉的那部门是，禁止回环模式的，为了防止配置的时候关闭回环失败，因此软件上再关闭一次。

1. #include "can_config.h"
3. #include <stdio.h>
4. #include <stdlib.h>
5. #include <unistd.h>
6. #include <string.h>
7. #include <signal.h>
8. #include <libgen.h>
9. #include <getopt.h>
10. #include <limits.h>
12. #include <sys/types.h>
13. #include <sys/socket.h>
14. #include <sys/uio.h>
15. #include <sys/ioctl.h>
16. #include <net/if.h>
18. #include <linux/can.h>
19. #include <linux/can/raw.h>
21. int main()
22. {
23.         int s; // 就是fd
24.         int n_read = 0; // 读取到的数据个数
25.         //创建 CAN 套接字
26.         if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
27.                 perror("Socket creation failed");
28.                 return -1;
29.         }
30.         printf("socket ok ========================\n");
32.         /*
33.         // 禁用回环模式（如果需要）
34.     int loopback = 0; // 0 表示关闭回环模式
35.     if (setsockopt(s, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback, sizeof(loopback)) < 0) {
36.         perror("Failed to disable loopback mode");
37.         close(s);
38.         return -1;
39.     }
41.     // 禁用监听自己的消息（可选）
42.     int recv_own_msgs = 0; // 0 表示关闭接收自己的消息
43.     if (setsockopt(s, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS, &recv_own_msgs, sizeof(recv_own_msgs)) < 0) {
44.         perror("Failed to disable receiving own messages");
45.         close(s);
46.         return -1;
47.     }
48.         */
50.         // 绑定 CAN 接口
51.         struct ifreq ifr;
52.         struct sockaddr_can addr;
54.         addr.can_family = AF_CAN;
55.         strcpy(ifr.ifr_name, "can0");
56.         if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
57.                 perror("Interface index get failed");
58.                 close(s);
59.                 return -1;
60.         }
61.         addr.can_ifindex = ifr.ifr_ifindex;
62.         if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
63.                 perror("Bind to CAN interface failed");
64.                 close(s);
65.                 return -1;
66.         }
67.         printf("bind ok ========================\n");
68.         // 构造要发送的 CAN 帧
69.         struct can_frame wirte_frame;
70.         struct can_frame recive_frame;
71.         wirte_frame.can_id = 0x123; // CAN ID
72.         wirte_frame.can_dlc = 8;    // 数据长度码（DLC），表示数据域的字节数
73.         memset(wirte_frame.data, 0x01, wirte_frame.can_dlc); // 设置数据域内容
74.        
75.         int data = 0x01;
76.         //开启线程 一个接收一个发送;
77.         __pid_t pid;
78.         pid = fork();//返回的pid号 父进程是正数id号码，子进程是0
79.         // 父进程 write  子进程接收
80.         if(pid>0){
81.                 printf("in farther ok ========================\n");
82.                 while(1){
83.                         // 发送 CAN 帧  间隔3秒写一次
84.                         if (write(s, &wirte_frame, sizeof(struct can_frame)) != sizeof(struct can_frame)) {
85.                                 perror("Write CAN frame failed");
86.                                 close(s);
87.                                 return -1;
88.                         }
89.                         sleep(3);
90.                         memset(wirte_frame.data,++data, wirte_frame.can_dlc); // 设置数据域内容
91.                 }       
92.         }else if(pid==0){
93.                 printf("in son ok ========================\n");
94.                 while(1){
95.                         // 接收 CAN 帧
96.                         if ((n_read = read(s, &recive_frame, sizeof(struct can_frame)) )!= sizeof(struct can_frame)) {
97.                                 perror("Read CAN frame failed");
98.                                 close(s);
99.                                 return -1;
100.                         }
102.                         if(n_read>0){
103.                                 printf("Received CAN ID=%x, DLC=%d\n", recive_frame.can_id, recive_frame.can_dlc);
104.                                 for (int i = 0; i < recive_frame.can_dlc; ++i)
105.                                         printf("Data[%d]: %02x\n", i, recive_frame.data[i]);
107.                         }
108.                 }
109.         }else{
110.                 perror("fork error\n");
111.         }
112.         close(s);
114.         return 0 ;
115. }

复制代码

4. 应用程序测试

先用交错编译工具编译：

1. arm-linux-gnueabi-gcc mycan.c -o mycan

复制代码

---

远程发送到板子：

1. scp ./mycan root@192.168.1.101:/root/zhua

复制代码

执行：

适当改一改代码：

再测试：

这里有个小题目就是write不停写，FIFO文件队列会满，然后就是溢出报错，因此要学习错误处理等操作。
所以末了关于帧格式，位同步，仲裁，错误处理等可以深入相识。保举在学习stm32的时候学习寄存器配置开发，可以深入的相识到。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。