CAN 总线协议详解

一、什么是 CAN 总线

CAN（Controller Area Network，控制器局域网）是一种串行、异步、多主、差分信号的现场总线。它由 Bosch 公司 1986 年为汽车电子设计，目的是用一根总线代替汽车里成百上千根点对点线束，让发动机、变速箱、仪表盘、ABS 等控制器共享一条通信"公路"。

1.1 CAN 的核心特征

• 多主总线：任何节点都可主动发送，不像 RS-485 必须主从轮询
• 非破坏性仲裁：多个节点同时发，ID 小的（优先级高的）自动胜出，数据不丢
• 差分信号：CAN_H / CAN_L 两根线，抗干扰能力强，与 RS-485 同源
• 短帧传输：一帧最多 8 字节数据（经典 CAN），适合实时控制消息
• 内置错误检测：CRC、位填充、帧格式检查、ACK 确认，错误率 < 10⁻¹¹
• 广播通信：所有节点都"听"到所有消息，靠"过滤"决定要不要处理

1.2 CAN vs 传统串口：三个维度的代差

二、CAN 发展简史与版本

2.1 CAN 三个主要版本

三、物理层：差分信号与总线拓扑

3.1 CAN_H 与 CAN_L：差分双线

CAN 使用两根线：CAN_H（高）和 CAN_L（低）。与 RS-485 一样，信号靠"两线电压差"判断，而非绝对电平。

3.2 总线拓扑：菊花链 + 两端终端电阻

3.3 收发器：CAN 控制器与物理总线的桥梁

常见收发器芯片对比

四、CAN 帧结构详解

CAN 有 4 种帧类型：数据帧（最常用）、远程帧（请求数据）、错误帧（报错）、过载帧（请求延迟）。这里重点讲数据帧。

4.1 各字段含义

4.2 远程帧：请求数据的"礼貌问法"

远程帧（Remote Frame）结构同数据帧，但 RTR = 隐性（1），且数据段长度为 0。它表示："有谁能发 ID=xxx 的数据给我？"

五、仲裁机制：越小的 ID 越优先

当多个节点同时开始发送，CAN 会在仲裁段（ID + RTR）逐位比较，ID 数值小的（高位先出现 0 的）获胜。败者立即切到接收模式，等总线空闲后再重发。

5.1 ID 分配原则（工程经验）

• 安全关键消息用小 ID：如刹车请求 ID=0x001，比车窗控制 ID=0x200 优先级高 50 倍
• 周期性消息：按重要性递增分配 ID
• 事件消息：放在中段 ID
• 诊断消息：通常用最大 ID（如 0x7DF），避免影响正常通信

六、错误处理与故障 confinement

CAN 有5 种错误类型和3 种错误状态，让故障节点自动"降级"甚至"离线"，避免拖垮整个总线。

6.1 五种错误类型

6.2 三种节点错误状态

6.3 错误计数器

每个节点有两个 8 位计数器：TEC（发送错误计数器）和 REC（接收错误计数器）。

• 发送错误时 TEC +8，成功 +1（到 0 为止）
• 接收错误时 REC +1~8，成功 −1~8
• TEC ≥ 128 或 REC ≥ 128 → 进入被动错误状态
• TEC ≥ 256 → 进入总线关闭状态

七、CAN 能力矩阵：速率/距离/节点

7.1 速率与距离的反比关系

7.2 CAN 综合能力表

八、CAN FD：经典 CAN 的带宽升级

CAN FD（Flexible Data-rate）是 CAN 的自然进化：仲裁段保持 1 Mbps（兼容性），数据段加速到 5~8 Mbps，数据长度从 8 字节扩到 64 字节。

九、上层应用协议全景

CAN 本身只是"运输公司"（提供可靠传输），但没规定"运什么货"。上层协议定义了消息含义、ID 分配、参数组、网络管理等。

9.1 CANopen：工业领域的瑞士军刀

CANopen由 CiA（CAN in Automation）组织制定，是工业自动化最流行的 CAN 上层协议。核心概念：

• 对象字典（OD）：每个节点维护一个参数表，索引 16 位 + 子索引 8 位
• SDO（Service Data Object）：点对点读写参数（配置用，非实时）
• PDO（Process Data Object）：周期性广播过程数据（实时控制用）
• NMT（Network Management）：主节点管理从节点状态（启动/停止/预操作）
• SYNC：同步帧，所有节点在收到后同时发送 PDO
• Heartbeat：节点周期发心跳，主节点监控存活

9.2 SAE J1939：商用车/工程机械标准

J1939是 SAE 协会为商用车（卡车、客车、挖掘机）制定的 CAN 上层协议。基于 29 位扩展 ID。

• 参数组（PGN）：18 位，标识消息类型（如发动机转速、油温）
• SPN（可疑参数编号）：参数编号，一个 PGN 包含多个 SPN
• 传输率：50ms~10s 周期或事件触发
• 多帧传输：超过 8 字节用 BAM（广播）或 RTS/CTS（点对点）

9.3 OBD-II：汽车诊断协议

OBD-II（On-Board Diagnostics II）是汽车排放诊断标准，通过 CAN 总线读取 ECU 数据。

• 请求 ID = 0x7DF（广播）或 0x7E0~0x7E7（指定 ECU）
• 响应 ID = 0x7E8~0x7EF
• PID（参数 ID）：如 PID 0x0C = 发动机转速（RPM）
• 模式（Mode）：01=当前数据，03=故障码，09=车辆信息

9.4 其他上层协议速览

十、CANoe：Vector 仿真利器

CANoe是德国 Vector Informatik 公司的旗舰工具，是汽车电子行业事实标准的网络分析、仿真、测试平台。

10.1 CANoe 能做什么

• 网络分析：抓包、解析、统计 CAN/CAN FD/LIN/FlexRay/Ethernet 报文
• 节点仿真：用 CAPL 脚本模拟缺失节点，让开发不依赖完整硬件
• 残余总线仿真（RBS）：模拟整车剩余网络，单 ECU 也能测
• 测试自动化：自动化执行测试用例，生成 HTML 报告
• 诊断：支持 UDS/ISO-TP/KWP2000 诊断协议
• 图形面板：拖拽控件搭建仪表盘、按钮、信号灯
• panels 交互：交互式面板，模拟用户操作

10.2 CAPL：CANoe 的编程语言

CAPL（Communication Access Programming Language）是 CANoe 专用脚本语言，类 C 语法，事件驱动。

/* CAPL 示例：模拟发动机 ECU 周期发送转速信号 */
variables {
    msTimer tmrEngineData;
    int engineRpm = 800;     // 怠速 800 RPM
    float coolantTemp = 85.5; // 水温 85.5°C
    message EngineMsg msgEngine;     // 引用 DBC 中定义的报文
}

on start() {
    setTimer(tmrEngineData, 50); // 50ms 周期
}

on timer tmrEngineData {
    engineRpm += (int)random(100) - 50; // 模拟波动
    if (engineRpm < 600) engineRpm = 600;
    if (engineRpm > 3000) engineRpm = 3000;

    msgEngine.EngineSpeed = engineRpm;           // 写入信号值
    msgEngine.CoolantTemp = (int)(coolantTemp + 0.5);
    output(msgEngine);                          // 发送到总线

    setTimer(tmrEngineData, 50);                // 重启定时器
}

on message BrakeMsg msgBrake {
    if (msgBrake.BrakePressed == 1) {
        write("Brake pressed! Reducing RPM");
        engineRpm = 800; // 模拟刹车降速
    }
}

10.3 DBC 文件：信号定义的"字典"

DBC（Data Base CAN）文件是 Vector 定义的 CAN 网络描述文件，定义了报文、信号、节点、缩放等。

// DBC 文件片段示例
VERSION ""

NS_ :
    NS_DESC_
    CM_
    BA_DEF_
    BA_
    VAL_
    ...

BU_: Engine Brake Instrument Gateway

BO_ 61444 EngineMsg: 8 Engine
   SG_ EngineSpeed : 0|16@1+ (0.125,0) [0|8000] "rpm" Engine,Instrument
   SG_ CoolantTemp : 16|8@1+ (1,-40) [-40|215] "degC" Engine,Instrument
   SG_ EngineStatus : 24|2@1+ (1,0) [0|3] "" Engine

BO_ 600 BrakeMsg: 2 Brake
   SG_ BrakePressed : 0|1@1+ (1,0) [0|1] "" Engine,Instrument

10.4 CANoe 工作流程

1. 导入 DBC：File → Import → CANdb++，加载信号定义
2. 配置通道：Configuration → Channel Usage，映射硬件通道
3. 编写 CAPL：在 CAPL Browser 中编写节点仿真逻辑
4. 设计面板：Panel Editor 拖拽控件，绑定信号
5. 开始测量：Start，实时观察 Trace 窗口、Graphics 窗口、Data 窗口
6. 分析数据：离线回放、统计、过滤、生成报告

十一、代码实战：Linux SocketCAN + Qt/C++

Linux 内置 SocketCAN 框架，把 CAN 总线抽象成网络套接字，用标准 socket API 编程。下面用 Qt/C++ 封装一个 CAN 通信类。

11.1 Linux 环境准备

# 1. 加载虚拟 CAN 控制器（用于无硬件测试）
sudo modprobe vcan
sudo ip link add dev can0 type vcan
sudo ip link set up can0

# 2. 真实硬件：设置比特率并启动
sudo ip link set can0 type can bitrate 500000
sudo ip link set can0 up

# 3. 安装 can-utils（命令行工具）
sudo apt install can-utils

# 4. 抓包测试
candump can0            # 持续监听
cansend can0 123#0102030405060708  # 发送一帧

11.2 Qt/C++ CAN 通信类

// CanBus.h —— SocketCAN Qt 封装
#ifndef CANBUS_H
#define CANBUS_H

#include <QObject>
#include <QByteArray>
#include <QSocketNotifier>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <sys/socket.h>
#include <net/if.h>

struct CanFrame {
    quint32 id;
    bool extended;      // 29位扩展帧
    bool rtr;           // 远程帧
    bool fdFrame;       // CAN FD 帧
    QByteArray data;    // 数据段
};

class CanBus : public QObject {
    Q_OBJECT
public:
    explicit CanBus(QObject *parent = nullptr);
    ~CanBus();

    // 打开 CAN 设备（如 "can0"），返回是否成功
    bool open(const QString &ifName);
    void close();

    // 发送一帧
    bool send(const CanFrame &frame);

    // 设置接收过滤器（只收指定 ID）
    void setFilter(const QVector<quint32> &ids);

signals:
    void frameReceived(const CanFrame &frame);
    void errorOccurred(const QString &msg);

private slots:
    void onReadyRead();

private:
    int m_sock = -1;
    QSocketNotifier *m_notifier = nullptr;
};

#endif // CANBUS_H

// CanBus.cpp —— 实现
#include "CanBus.h"
#include <QDebug>
#include <unistd.h>
#include <sys/ioctl.h>

CanBus::CanBus(QObject *parent) : QObject(parent) {}

CanBus::~CanBus() { close(); }

bool CanBus::open(const QString &ifName) {
    // 1. 创建 RAW CAN 套接字
    m_sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (m_sock < 0) {
        emit errorOccurred("无法创建 CAN socket");
        return false;
    }

    // 2. 指定网络接口（如 can0）
    struct ifreq ifr;
    std::strncpy(ifr.ifr_name, ifName.toUtf8().constData(), sizeof(ifr.ifr_name));
    ioctl(m_sock, SIOCGIFINDEX, &ifr);

    struct sockaddr_can addr;
    memset(&addr, 0, sizeof(addr));
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;

    // 3. 绑定
    if (bind(m_sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        emit errorOccurred("绑定 CAN socket 失败");
        ::close(m_sock); m_sock = -1;
        return false;
    }

    // 4. 用 QSocketNotifier 监听可读事件（Qt 事件循环集成）
    m_notifier = new QSocketNotifier(m_sock, QSocketNotifier::Read, this);
    connect(m_notifier, &QSocketNotifier::activated, this, &CanBus::onReadyRead);

    qDebug() << "CAN socket opened on" << ifName;
    return true;
}

void CanBus::close() {
    if (m_notifier) { delete m_notifier; m_notifier = nullptr; }
    if (m_sock >= 0) { ::close(m_sock); m_sock = -1; }
}

bool CanBus::send(const CanFrame &frame) {
    struct can_frame cf;
    memset(&cf, 0, sizeof(cf));

    cf.can_id = frame.id;
    if (frame.extended) cf.can_id |= CAN_EFF_FLAG;  // 29 位扩展帧标志
    if (frame.rtr)      cf.can_id |= CAN_RTR_FLAG; // 远程帧标志

    cf.can_dlc = qMin(frame.data.size(), 8); // 经典 CAN 最多 8 字节
    memcpy(cf.data, frame.data.constData(), cf.can_dlc);

    ssize_t n = ::write(m_sock, &cf, sizeof(cf));
    if (n != sizeof(cf)) {
        emit errorOccurred("发送失败");
        return false;
    }
    return true;
}

void CanBus::setFilter(const QVector<quint32> &ids) {
    if (ids.isEmpty()) {
        // 空列表 = 不设过滤，接收所有
        setsockopt(m_sock, SOL_CAN_RAW, CAN_RAW_FILTER, nullptr, 0);
        return;
    }
    QVector<can_filter> filters;
    for (quint32 id : ids) {
        can_filter f;
        f.can_id = id;
        f.can_mask = CAN_EFF_MASK; // 精确匹配 ID
        filters.append(f);
    }
    setsockopt(m_sock, SOL_CAN_RAW, CAN_RAW_FILTER,
                 filters.data(), sizeof(can_filter) * filters.size());
}

void CanBus::onReadyRead() {
    struct can_frame cf;
    while (true) {
        ssize_t n = ::read(m_sock, &cf, sizeof(cf));
        if (n <= 0) break;  // 无数据或错误

        CanFrame frame;
        frame.id = cf.can_id & CAN_EFF_MASK;
        frame.extended = (cf.can_id & CAN_EFF_FLAG) != 0;
        frame.rtr = (cf.can_id & CAN_RTR_FLAG) != 0;
        frame.data = QByteArray(reinterpret_cast<const char*>(cf.data), cf.can_dlc);

        emit frameReceived(frame);
    }
}

11.3 使用示例：模拟 OBD-II 查发动机转速

// main.cpp —— 使用 CanBus 类模拟 OBD-II 查询
#include "CanBus.h"
#include <QCoreApplication>
#include <QDebug>

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);

    CanBus can;

    // 接收响应处理
    QObject::connect(&can, &CanBus::frameReceived, [](const CanFrame &f) {
        // 只处理 OBD-II 响应 ID: 0x7E8
        if (f.id != 0x7E8) return;

        // 响应格式: [长度] [41=模式01响应] [0C=PID] [高字节] [低字节]
        if (f.data.size() >= 4 &&
            (quint8)f.data[1] == 0x41 &&
            (quint8)f.data[2] == 0x0C) {

            quint16 raw = ((quint8)f.data[3] << 8) | (quint8)f.data[4];
            double rpm = raw / 4.0;
            qDebug() << "Engine RPM:" << rpm;
        }
    });

    if (!can.open("can0")) {
        qDebug() << "打开 can0 失败";
        return -1;
    }

    // 发送 OBD-II 请求：ID=0x7DF, Data=[02 01 0C 00 00 00 00 00]
    CanFrame req;
    req.id = 0x7DF;
    req.extended = false;
    req.rtr = false;
    req.data = QByteArray::fromHex("02010C0000000000");
    can.send(req);

    qDebug() << "OBD-II 查询已发送，等待响应...";

    return app.exec();
}

11.4 Windows 平台方案

Windows 没有 SocketCAN，需要用厂商提供的 DLL（如 PCAN 的 PCANBasic.dll、Vector 的 vxlapi.dll）或 SocketCAN 的 Windows 移植版。

// Windows 方案：Qt SerialBus 模块（跨平台推荐）
// Qt 5.7+ 提供 QCanBus 抽象层，统一封装各厂商驱动

#include <QCanBus>
#include <QCanBusFrame>
#include <QCanBusDevice>

// 列举系统支持的 CAN 插件
QStringList plugins = QCanBus::instance()->availableDevices("socketcan");
for (const QString &p : plugins)
    qDebug() << "Found:" << p;

// 创建设备连接
QCanBusDevice *device = QCanBus::instance()->createDevice(
    "socketcan", "can0");

if (!device || !device->connectDevice()) {
    qDebug() << "连接失败";
    return;
}

// 接收
QObject::connect(device, &QCanBusDevice::framesReceived, [=]() {
    while (device->framesAvailable()) {
        QCanBusFrame frame = device->readFrame();
        qDebug() << "ID:" << QString::number(frame.frameId(), 16)
                 << "Data:" << frame.payload().toHex();
    }
});

// 发送
QCanBusFrame sendFrame;
sendFrame.setFrameId(0x123);
sendFrame.setPayload(QByteArray::fromHex("0102030405060708"));
device->writeFrame(sendFrame);

十二、应用场景与选型建议

12.1 典型应用场景

12.2 CAN vs 其他总线对比

十三、调试技巧与常见问题

13.1 调试三板斧

1. 看总线电平：万用表测 CAN_H 和 CAN_L 对地电压。空闲时都约 2.5V，通信时 CAN_H 升到 3.5V，CAN_L 降到 1.5V
2. 测终端电阻：断电用万用表测 CAN_H-CAN_L 之间，应为 60Ω（两个 120Ω 并联）。如果是 120Ω 说明少接一个，如果是 0Ω 说明短路
3. 抓包对比：用 candump（Linux）或 PCAN-View（Windows）抓原始帧，与预期 ID/数据对比

13.2 常见问题速查

13.3 调试工具链

十四、总结