1. 从零到一：理解Linux CAN应用编程的基石

如果你是一名嵌入式或汽车电子领域的开发者，最近在调试一个车载控制器或者机器人底盘，发现数据手册里反复提到CAN总线，而你的开发环境又跑在Linux上，那么“Linux CAN应用编程”就是你绕不开的必修课。这不仅仅是打开一个设备文件然后读写那么简单，它背后涉及一整套与硬件、网络协议栈打交道的逻辑。简单来说，它就是在Linux系统上，通过一套标准的Socket CAN接口，让你能够像操作网络一样去操作CAN总线，收发那些承载着车辆速度、电机转速、电池状态等关键信息的数据帧。

我最初接触时也犯过嘀咕：不就是个串行通信总线吗，用起来能有多复杂？真正上手才发现，从理解“Socket CAN”这个设计哲学，到正确配置比特率、处理错误帧、管理报文ID过滤，每一步都有不少门道。搞懂了这些，你就能让Linux系统变身为一个强大的CAN网络分析仪、网关或者控制器，无论是做数据监听、模拟节点测试，还是开发上层控制应用，都得心应手。这篇文章，我就结合自己踩过的坑和项目经验，带你彻底吃透Linux下的CAN应用编程，从概念到实战，让你能独立完成一个稳定可靠的CAN通信程序。

2. 核心概念与Socket CAN架构解析

2.1 CAN总线与Socket CAN模型

CAN（Controller Area Network）总线本质上是一种广播式的串行通信协议，广泛用于汽车、工业自动化等对实时性和可靠性要求极高的领域。它的特点是多主结构、基于优先级的仲裁、以及强大的错误检测与处理机制。在Linux中，为了将CAN设备集成到庞大的网络子系统里，内核开发者们引入了“Socket CAN”的概念。

这可能是整个学习过程中最关键的一个认知转变：在Linux中，CAN总线被抽象成了一个网络设备。这意味着，每一个物理的CAN控制器（比如芯片MCP2515、SJA1000，或者SoC内部的CAN核心）在系统里都会呈现为一个网络接口，通常命名为can0、can1等。你不再使用传统的open()、read()、write()去操作一个字符设备，而是使用标准的Berkeley Socket API（就是你在网络编程里用的socket(),bind(),sendto(),recvfrom()那一套）来与这个“网络”进行通信。

这种设计带来了巨大的优势：

1. 统一性：开发者可以使用熟悉的网络编程模型，学习成本降低。
2. 强大性：可以直接利用网络子系统已有的功能，如过滤、多播、队列管理等。
3. 灵活性：可以方便地结合其他网络协议栈，比如通过can2udp这样的工具将CAN帧封装成UDP包在以太网上传输。

2.2 关键数据结构：struct can_frame

当你通过Socket发送或接收数据时，操作的基本单位是struct can_frame。理解它的每个字段至关重要，这直接关系到你的数据是否正确。

#include <linux/can.h> struct can_frame { canid_t can_id; /* 32位 CAN ID + 标志位 */ __u8 can_dlc; /* 数据长度码 (0-8) */ __u8 __pad; /* 填充字节 */ __u8 __res0; /* 保留字节 */ __u8 __res1; /* 保留字节 */ __u8 data[8] __attribute__((aligned(8))); /* 数据域 */ };

• can_id： 这是最核心的字段。它不仅仅是11位（标准帧）或29位（扩展帧）的标识符。它的低29位用于存放CAN ID本身。而更高的几个比特位被用作标志位（Flags）：
  • CAN_EFF_FLAG(0x80000000U)： 如果设置，表示这是一个29位的扩展帧（Extended Frame）；否则是11位的标准帧。
  • CAN_RTR_FLAG(0x40000000U)： 如果设置，表示这是一个远程传输请求帧（Remote Transmission Request），即请求其他节点发送指定ID的数据，此时data字段无效。
  • CAN_ERR_FLAG(0x20000000U)： 如果设置，表示这是一个错误帧（Error Frame），用于总线错误通知。
  • 因此，在设置ID时，你需要这样操作：frame.can_id = (0x123 & CAN_SFF_MASK)表示标准帧；frame.can_id = (0x12345678 & CAN_EFF_MASK) | CAN_EFF_FLAG表示扩展帧。
• can_dlc： 数据长度码，表示data字段中有效数据的字节数。CAN FD（灵活数据速率）出现前，这个值只能是0到8。即使你只发送3个字节，can_dlc也要设为3，data[3]之后的内容不会被发送。
• data[8]： 实际的数据负载。注意它是8字节对齐的，这有助于提高访问效率。

注意：在实际编程中，我们通常使用#include <linux/can.h>来获取这个结构体以及相关的常量和宏定义。直接操作can_id的比特位容易出错，建议使用系统定义的宏，如CAN_EFF_FLAG,CAN_SFF_MASK等。

3. 环境准备与接口配置实战

3.1 硬件与驱动准备

在开始写代码之前，你需要确保Linux系统已经正确识别了你的CAN硬件。这通常分为两种情况：

1. 内置CAN控制器：许多嵌入式SoC（如NXP i.MX系列、TI Sitara系列）都集成了CAN控制器。你需要在编译内核时启用对应的驱动（如CONFIG_CAN_FLEXCAN），并在设备树（Device Tree）中正确配置引脚复用和时钟。启动后，使用ip link命令应该能看到can0这样的接口。
2. 外置CAN适配器：通过USB、SPI或UART连接的CAN适配卡（如PCAN-USB, MCP2515 SPI模块）。你需要加载对应的内核模块。例如，对于常见的基于MCP2515芯片的SPI模块：

   sudo modprobe can sudo modprobe can_raw sudo modprobe can_dev sudo modprobe mcp251x

   加载后，使用dmesg | tail查看内核日志，通常会有类似“CAN device driver interface”或“mcp251x spi0.0 can0: MCP2515 successfully initialized”的提示。

检查CAN接口是否就绪：

ip link show

寻找类似can0: <NOARP,ECHO> mtu 16 qdisc noop state DOWN mode DEFAULT group default qlen 10的输出。state DOWN表示接口还未激活。

3.2 配置CAN接口参数

CAN接口必须配置正确的比特率（波特率）和模式后才能使用。这是通过ip命令来自iproute2工具集完成的。

设置比特率与启动接口：

# 设置 can0 的比特率为 500 kbit/s，并启动接口 sudo ip link set can0 type can bitrate 500000 sudo ip link set can0 up

• type can：指定设备类型为CAN。
• bitrate 500000：设置比特率为500kbps。这是汽车领域最常用的速率之一。其他常见速率有125k（车身控制）、250k、1M（高速应用）。
• up：启动接口。

更详细的配置示例：

# 设置比特率、采样点、重启时间等参数 sudo ip link set can0 type can bitrate 500000 sample-point 0.875 restart-ms 100 # 启用环回模式（用于自发自收测试） sudo ip link set can0 type can loopback on # 启用监听模式（只接收，不发送，不影响总线） sudo ip link set can0 type can listen-only on sudo ip link set can0 up

• sample-point：采样点位置，通常设置在位时间的75%-90%之间，0.875是个常用值。
• restart-ms：总线关闭（Bus-Off）后，控制器自动恢复的时间（毫秒）。
• loopback：环回模式，非常适合在不连接真实总线的情况下测试应用程序的收发逻辑。
• listen-only：监听模式，用于总线监控，不会发送任何帧（包括ACK位），不会干扰总线。

关闭接口：

sudo ip link set can0 down

实操心得：在开发初期，强烈建议先使用loopback on模式进行测试。这样你的程序发送的帧会被自己立刻接收，可以快速验证收发代码路径是否正确，而无需连接真实的CAN总线或其他节点。避免了一开始就因物理层问题（如终端电阻、线缆）导致的调试困难。

4. Socket CAN 应用编程核心步骤

现在进入正题，我们来看如何用C语言编写一个完整的CAN收发程序。整个过程和UDP网络编程非常相似。

4.1 创建Socket与绑定

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <net/if.h> #include <sys/ioctl.h> #include <sys/socket.h> #include <linux/can.h> #include <linux/can/raw.h> int main() { int s; // Socket 描述符 struct sockaddr_can addr; struct ifreq ifr; const char *ifname = "can0"; // 1. 创建Socket // PF_CAN 表示协议族是CAN // SOCK_RAW 表示原始套接字，我们可以直接操作can_frame // CAN_RAW 是Socket CAN的原始协议 if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) { perror("Socket creation failed"); return 1; } // 2. 指定要使用的CAN网络接口 strcpy(ifr.ifr_name, ifname); // 使用ioctl获取接口索引 if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) { perror("ioctl SIOCGIFINDEX failed"); close(s); return 1; } // 3. 绑定Socket到该CAN接口 addr.can_family = AF_CAN; addr.can_ifindex = ifr.ifr_ifindex; // 从ioctl获取的接口索引 if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { perror("Bind failed"); close(s); return 1; } printf("Socket successfully bound to interface %s (index %d)\n", ifname, addr.can_ifindex); // ... 后续进行收发操作 close(s); return 0; }

关键点解析：

• socket(PF_CAN, SOCK_RAW, CAN_RAW)：这是创建CAN Socket的标准方式。PF_CAN是协议族，SOCK_RAW提供对原始数据帧的访问，CAN_RAW是具体的协议类型，它允许我们发送和接收struct can_frame。
• struct ifreq ifr：这是一个用于配置网络接口请求的通用结构体。我们通过它来传递接口名（如“can0”）并获取其索引。
• ioctl(s, SIOCGIFINDEX, &ifr)：这个系统调用根据接口名（ifr.ifr_name）获取其对应的内核索引号，并存回ifr.ifr_ifindex。
• struct sockaddr_can addr：CAN专用的地址结构体，我们只需要填充协议族AF_CAN（与PF_CAN值相同）和接口索引can_ifindex。
• bind()：将Socket与一个具体的CAN接口关联起来。一个Socket只能绑定一个接口。如果你想监听多个CAN接口，需要创建多个Socket。

4.2 发送CAN帧

发送帧使用write()或sendto()函数。由于我们已经用bind()指定了出口，通常使用write()更简单。

int send_can_frame(int socket, canid_t can_id, const unsigned char *data, int data_len) { struct can_frame frame; int nbytes; // 检查数据长度 if (data_len < 0 || data_len > CAN_MAX_DLEN) { // CAN_MAX_DLEN 通常是8 fprintf(stderr, "Invalid data length: %d\n", data_len); return -1; } // 填充CAN帧结构体 frame.can_id = can_id; // 调用者需要负责设置标志位（如CAN_EFF_FLAG） frame.can_dlc = data_len; memcpy(frame.data, data, data_len); // 发送帧 nbytes = write(socket, &frame, sizeof(struct can_frame)); if (nbytes != sizeof(struct can_frame)) { perror("Write failed or incomplete"); return -1; } printf("Sent frame: ID=0x%03X, DLC=%d, Data=", frame.can_id & CAN_EFF_MASK, frame.can_dlc); for (int i = 0; i < frame.can_dlc; i++) { printf("%02X ", frame.data[i]); } printf("\n"); return 0; } // 调用示例：发送一个标准数据帧，ID为0x123，数据为0xDE, 0xAD, 0xBE, 0xEF unsigned char data[] = {0xDE, 0xAD, 0xBE, 0xEF}; send_can_frame(s, 0x123, data, 4); // 调用示例：发送一个扩展远程请求帧，请求ID为0x12345678的数据 send_can_frame(s, 0x12345678 | CAN_EFF_FLAG | CAN_RTR_FLAG, NULL, 0);

4.3 接收CAN帧

接收帧使用read()或recvfrom()。这是一个典型的阻塞式接收循环：

void receive_can_loop(int socket) { struct can_frame frame; int nbytes; struct timeval timeout = {1, 0}; // 设置1秒超时 fd_set readfds; while(1) { FD_ZERO(&readfds); FD_SET(socket, &readfds); // 使用select实现带超时的接收，避免永久阻塞 int ret = select(socket + 1, &readfds, NULL, NULL, &timeout); if (ret < 0) { perror("Select error"); break; } else if (ret == 0) { // 超时，可以在这里处理一些周期性任务或检查退出条件 // printf("Timeout, no data received.\n"); continue; } // Socket可读 if (FD_ISSET(socket, &readfds)) { nbytes = read(socket, &frame, sizeof(struct can_frame)); if (nbytes < 0) { perror("Read failed"); break; } if (nbytes != sizeof(struct can_frame)) { fprintf(stderr, "Incomplete CAN frame read\n"); continue; } // 解析并打印接收到的帧 printf("Received frame: "); if (frame.can_id & CAN_ERR_FLAG) { printf("ERROR FRAME - "); } if (frame.can_id & CAN_EFF_FLAG) { printf("EXT ID=0x%08X ", frame.can_id & CAN_EFF_MASK); } else { printf("STD ID=0x%03X ", frame.can_id & CAN_SFF_MASK); } if (frame.can_id & CAN_RTR_FLAG) { printf("[RTR]"); } printf(" DLC=%d Data=", frame.can_dlc); for (int i = 0; i < frame.can_dlc; i++) { printf("%02X ", frame.data[i]); } printf("\n"); } } }

关键点解析：

• select()：用于实现I/O多路复用和超时控制。在等待CAN数据的同时，程序还可以响应其他事件或安全地退出循环。这是生产环境代码的必备结构，避免read()无限阻塞。
• frame.can_id & CAN_EFF_MASK：通过掩码操作，从can_id中提取出纯粹的29位扩展标识符。
• frame.can_id & CAN_SFF_MASK：提取出纯粹的11位标准标识符。
• 对CAN_RTR_FLAG和CAN_ERR_FLAG的检查至关重要，它们决定了帧的类型和后续处理逻辑。错误帧通常需要专门的处理例程。

5. 高级特性与性能优化

5.1 报文过滤（Filtering）

在复杂的CAN网络中，节点可能只关心特定ID范围的报文。让内核在驱动层进行过滤，比在用户空间接收所有帧再进行软件过滤要高效得多。这是通过setsockopt()设置CAN_RAW_FILTER选项实现的。

int setup_can_filter(int socket) { struct can_filter rfilter[2]; // 定义过滤器数组 // 过滤器1：只接收标准ID为0x100到0x103的帧 rfilter[0].can_id = 0x100; // 目标ID rfilter[0].can_mask = 0x7FC; // 掩码：0x7FC = 111 1111 1100，匹配ID的低2位可变 // 过滤器2：只接收扩展ID为0x20000000的帧 rfilter[1].can_id = 0x20000000 | CAN_EFF_FLAG; // 目标ID，必须带上扩展帧标志 rfilter[1].can_mask = CAN_EFF_MASK; // 掩码：完全匹配所有29位 // 设置过滤器 if (setsockopt(socket, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter)) < 0) { perror("Setsockopt filter failed"); return -1; } printf("CAN filter set successfully.\n"); return 0; }

过滤规则详解：

• can_mask决定了can_id中哪些位需要精确匹配。掩码位为1表示必须匹配，为0表示不关心（即该位可以是0或1）。
• 对于标准帧（11位ID），can_id和can_mask只使用低11位。can_mask = 0x7FF(二进制 111 1111 1111) 表示精确匹配所有11位。can_mask = 0x7FC(111 1111 1100) 表示匹配高9位，低2位任意，因此能匹配 0x100, 0x101, 0x102, 0x103。
• 对于扩展帧，需要使用CAN_EFF_FLAG标志，并操作29位。CAN_EFF_MASK是系统定义的29位全1掩码。
• 可以设置多个过滤器，只要报文匹配其中任意一个，就会被传递到用户空间。
• 如果想接收所有报文，可以传递一个空过滤器数组：setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0)。

5.2 错误帧处理

CAN总线具有强大的错误检测和信令机制。当总线发生错误（如位错误、填充错误、CRC错误等）时，控制器会产生错误帧。通过Socket CAN，我们可以接收并分析这些错误帧。

int enable_error_frames(int socket) { int recv_own_msgs = 1; // 可选：设置为1以接收自己发送的帧（在非环回模式下） can_err_mask_t err_mask = CAN_ERR_MASK; // 接收所有错误帧类型 // 启用接收自己发送的帧（用于诊断） if (setsockopt(socket, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS, &recv_own_msgs, sizeof(recv_own_msgs)) < 0) { perror("Setsockopt RECV_OWN_MSGS failed"); } // 设置错误帧掩码 if (setsockopt(socket, SOL_CAN_RAW, CAN_RAW_ERR_FILTER, &err_mask, sizeof(err_mask)) < 0) { perror("Setsockopt ERR_FILTER failed"); return -1; } printf("Error frame reception enabled.\n"); return 0; } // 在接收循环中，需要增加对错误帧的解析 if (frame.can_id & CAN_ERR_FLAG) { // 这是一个错误帧 struct can_frame *eframe = &frame; // can_id字段的低8位包含了错误类型（CAN_ERR_*） // data[0]到data[7]包含了更详细的错误信息，具体格式参考linux/can/error.h printf("ERROR FRAME detected. Error code: 0x%02X\n", eframe->can_id & 0xFF); // 可以进一步解析data[]中的错误位置、控制器状态等 // 例如，检查是否是总线关闭状态 if (eframe->data[1] & CAN_ERR_CRTL_RX_OVERFLOW) { printf(" -> RX buffer overflow\n"); } }

5.3 性能考量：非阻塞IO与缓冲区

对于高波特率（如1Mbps）或高负载总线，处理性能很重要。

1. 非阻塞Socket：在创建Socket后，使用fcntl()将其设置为非阻塞模式。这样read()和write()在无数据或缓冲区满时会立即返回EAGAIN错误，而不是阻塞。

   int flags = fcntl(s, F_GETFL, 0); fcntl(s, F_SETFL, flags | O_NONBLOCK);

   然后你的接收循环需要配合select()/poll()/epoll()来高效处理。

2. Socket缓冲区大小：默认的发送和接收缓冲区可能在高负载下不够用，导致丢帧。可以调整它们。

   int sndbuf_size = 1024 * 1024; // 1MB 发送缓冲区 int rcvbuf_size = 1024 * 1024; // 1MB 接收缓冲区 setsockopt(s, SOL_SOCKET, SO_SNDBUF, &sndbuf_size, sizeof(sndbuf_size)); setsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcvbuf_size, sizeof(rcvbuf_size));

3. 使用recvmsg()和sendmsg()：对于需要获取或设置额外信息（如时间戳）的高级应用，可以使用recvmsg()和sendmsg()。特别是recvmsg()可以配合辅助数据（ancillary data）来获取内核为每个CAN帧打上的高精度时间戳，这对于报文分析至关重要。

   struct timeval tv; struct iovec iov; struct msghdr msg; struct cmsghdr *cmsg; char ctrlmsg[CMSG_SPACE(sizeof(struct timeval))]; struct can_frame frame; iov.iov_base = &frame; iov.iov_len = sizeof(frame); msg.msg_iov = &iov; msg.msg_iovlen = 1; msg.msg_control = ctrlmsg; msg.msg_controllen = sizeof(ctrlmsg); msg.msg_name = NULL; msg.msg_namelen = 0; nbytes = recvmsg(socket, &msg, 0); if (nbytes > 0) { for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) { if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_TIMESTAMP) { memcpy(&tv, CMSG_DATA(cmsg), sizeof(tv)); printf("Frame received at sec=%ld, usec=%ld\n", tv.tv_sec, tv.tv_usec); } } }

   要启用时间戳，需要在绑定Socket前设置选项：int enable = 1; setsockopt(s, SOL_SOCKET, SO_TIMESTAMP, &enable, sizeof(enable));。

6. 实战：构建一个简单的CAN工具与调试技巧

6.1 编写一个简易的CAN数据收发器

结合以上所有知识点，我们可以编写一个简单的命令行工具，具备发送特定帧和接收并打印所有帧的功能。这里给出核心框架：

// can_tool.c - 一个极简的CAN收发示例 #include ... // 包含所有必要的头文件 int main(int argc, char **argv) { int s; struct sockaddr_can addr; struct ifreq ifr; const char *ifname = "can0"; int opt; int send_mode = 0; struct can_frame send_frame; // 解析命令行参数（示例：-i can0 -s 0x123:deadbeef） // ... 使用getopt进行解析，这里省略详细代码 // 如果-s参数存在，则填充send_frame，并设置send_mode=1 // 创建并绑定Socket (参考4.1节) // ... // 设置过滤器（可选，例如只接收错误帧和特定ID） // ... // 启用错误帧接收（可选） // ... if (send_mode) { // 发送单帧 if (write(s, &send_frame, sizeof(send_frame)) != sizeof(send_frame)) { perror("Send failed"); } else { printf("Frame sent.\n"); } close(s); return 0; } else { // 进入接收循环 printf("Starting CAN listener on %s. Press Ctrl+C to stop.\n", ifname); receive_can_loop(s); // 调用4.3节中的接收循环函数 } close(s); return 0; }

编译：gcc -o can_tool can_tool.c。

6.2 系统工具与调试技巧

在开发过程中，Linux自带的一些工具非常有用：

1. candump(来自 can-utils 包)：这是最常用的CAN监听工具。安装：sudo apt install can-utils。

   # 监听can0上所有帧 candump can0 # 以彩色高亮显示变化的字节 candump can0 -c -d # 将数据记录到文件 candump can0 -l # 监听特定ID（标准帧0x123和扩展帧0x12345678） candump can0,123:7FF,12345678:1FFFFFFF

2. cansend(来自 can-utils 包)：发送单帧的利器。

   # 发送标准数据帧：ID 0x123，数据 11 22 33 44 cansend can0 123#11223344 # 发送扩展数据帧：ID 0x12345678，数据 AA BB CC cansend can0 12345678#AABBCC # 发送标准远程帧：请求ID为0x321的数据 cansend can0 321#R

3. ip -details link show can0：查看CAN接口的详细状态和统计信息，包括错误计数器、状态（ERROR-ACTIVE, ERROR-PASSIVE, BUS-OFF）等，对于诊断物理层问题至关重要。

4. ifconfig can0：较老的工具，也能查看接口状态和统计信息（如丢包数 RX/TX dropped）。

5. /proc/net/can/stats：查看系统级的CAN协议统计信息。

避坑指南：当你发现程序收不到任何帧时，按以下顺序排查：

1. 接口状态：ip link show can0确认接口是state UP而不是DOWN。
2. 比特率匹配：确保你的程序、ip link set命令以及总线上其他节点的比特率设置完全一致。1%的偏差都可能导致无法通信。
3. 终端电阻：CAN总线两端（最远的两个节点）必须各接一个120欧姆的终端电阻，测量总线CAN_H和CAN_L之间的电阻应为60欧姆左右。没有终端电阻会导致信号反射，通信极不稳定或完全失败。
4. 硬件连接：检查线缆是否接反（CAN_H, CAN_L, GND）。CAN_H和CAN_L不能互换。
5. 过滤器设置：你是否无意中设置了过于严格的过滤器，把想要的帧过滤掉了？尝试注释掉过滤器设置代码。
6. 权限问题：普通用户可能无法访问CAN Socket。需要将用户加入dialout组，或者使用sudo运行程序。更安全的方式是创建udev规则，赋予特定设备节点（如/dev/ttyUSB*转换的CAN）合适的权限。

7. 从应用到深入：CAN FD与广播/多播

7.1 CAN FD支持

CAN FD（Flexible Data Rate）是对经典CAN的扩展，支持更高的数据段速率（最高可达8Mbps或更高）和更长的数据场（最多64字节）。Linux内核从某个版本开始也支持CAN FD。

使用CAN FD的主要变化：

1. 帧结构：使用struct canfd_frame，其定义在<linux/can.h>中。它与can_frame类似，但len字段（对应can_dlc）使用不同的编码，可以表示0-64的长度，并且数据域data是64字节。
2. Socket创建：创建Socket时，协议类型应指定为CAN_RAW_FD（如果系统支持）。

   int s = socket(PF_CAN, SOCK_RAW, CAN_RAW_FD);

3. 接口配置：在启用接口时，需要指定fd on参数，并可以分别设置仲裁段（控制段）和数据段的比特率。

   sudo ip link set can0 type can bitrate 500000 dbitrate 2000000 fd on sudo ip link set can0 up

   这里bitrate 500000是仲裁段速率（与经典CAN节点通信时需一致），dbitrate 2000000是数据段速率，fd on启用FD功能。
4. 收发操作：发送和接收时使用struct canfd_frame，并注意其长度。内核和驱动会自动处理经典CAN帧与CAN FD帧的转换（如果硬件支持）。

7.2 广播与多播地址

Socket CAN也支持类似IP的多播概念，允许一个帧发送到多个“逻辑”地址。这通过struct sockaddr_can中的can_ifindex和can_addr来实现。can_addr.tp结构体包含了目标地址信息。不过，在实际的汽车或工业网络中，基于CAN ID的过滤和软件层面的分发更为常见，原生的CAN多播使用较少，它更多用于一些特定的路由或网关场景。

一个更实用的“广播”概念是：在总线上发送一个帧，所有监听该总线的节点（只要过滤器允许）都能收到。这本身就是CAN总线广播特性的体现，无需特殊编程。

掌握以上内容，你已经具备了在Linux环境下进行稳健的CAN应用开发的能力。从简单的数据收发，到复杂的网络诊断、网关开发，这套Socket CAN接口都是你坚实的基石。剩下的就是在具体的项目需求中，设计好你的报文协议（如CANopen, J1939, UDS等），并利用这些底层工具去实现它了。记住，理解帧结构、善用过滤器和系统工具，是高效调试和开发的关键。