55、C++项目实战：CAN总线通信

CAN总线，搞嵌入式的人都不陌生。说白了，它就是汽车、工业设备里用来让各个“大脑”互相说话的一条高速公路。我最早接触CAN总线是在一个车载诊断项目里，那时候被它的仲裁机制折腾得不轻——嗯，今天咱们就把这个硬骨头啃下来。

CAN总线到底是什么？

CAN（Controller Area Network）是一种多主总线通信协议。你想想看，一条总线上挂着几十个节点，谁想说话谁就说，不会乱套吗？这就是CAN的厉害之处——它用优先级仲裁机制解决了冲突问题。

我个人习惯把CAN总线理解成一个“圆桌会议”：

  • 多主架构：任何节点都可以主动发消息，没有“老大”
  • 广播式通信：一个节点说话，所有节点都能听到
  • 基于ID的优先级：ID越小，优先级越高，抢到发言权

核心要点：CAN总线不是点对点通信，而是“所有人听一个人说”。每个节点根据消息ID决定要不要处理这条消息。

CAN帧结构——你得看懂这些位

CAN总线有两种帧格式：标准帧（11位ID）和扩展帧（29位ID）。我在项目中遇到过最坑的事，就是标准帧和扩展帧混用，结果节点之间互相“装聋作哑”。

来看一个标准数据帧的结构：

字段 位数 说明
SOF 1 帧起始，同步信号
标识符 11 决定优先级，越小越高
RTR 1 远程帧标志
控制段 6 包含DLC（数据长度）
数据段 0~64 实际传输的数据，最多8字节
CRC 15 循环冗余校验
ACK 2 应答槽
EOF 7 帧结束

小技巧：CAN总线上最多传8字节数据。如果你要传超过8字节，就得拆成多帧。我曾经见过有人硬塞9字节进去，结果总线直接报错——嗯，协议就是这么死板。

用C++实现CAN通信——从驱动到应用

在Linux系统下，CAN总线被抽象成了网络套接字。你操作CAN就像操作socket一样。我建议用SocketCAN这套接口，它成熟、稳定。

先看一个最基础的CAN发送示例：

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <linux/can.h>
#include <linux/can/raw.h>

class CanBus {
private:
    int sock;
    struct sockaddr_can addr;
    struct ifreq ifr;

public:
    CanBus() : sock(-1) {}

    bool open(const std::string& interface) {
        // 创建socket
        sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
        if (sock < 0) {
            std::cerr << "创建CAN socket失败" << std::endl;
            return false;
        }

        // 指定CAN接口
        std::strcpy(ifr.ifr_name, interface.c_str());
        if (ioctl(sock, SIOCGIFINDEX, &ifr) < 0) {
            std::cerr << "获取接口索引失败" << std::endl;
            return false;
        }

        // 绑定socket
        addr.can_family = AF_CAN;
        addr.can_ifindex = ifr.ifr_ifindex;
        if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
            std::cerr << "绑定失败" << std::endl;
            return false;
        }

        return true;
    }

    bool sendFrame(uint32_t id, const uint8_t* data, uint8_t len) {
        struct can_frame frame;
        frame.can_id = id;
        frame.can_dlc = len > 8 ? 8 : len;  // 最多8字节
        std::memcpy(frame.data, data, frame.can_dlc);

        int nbytes = write(sock, &frame, sizeof(frame));
        return nbytes == sizeof(frame);
    }

    void close() {
        if (sock >= 0) {
            ::close(sock);
            sock = -1;
        }
    }
};

这段代码看着简单，但有几个坑我得提醒你：

避坑指南：我曾经在发送时忘记设置can_dlc，结果数据长度默认是0，总线上的其他节点死活收不到数据。排查了整整一下午才发现是这个小问题。

接收CAN帧——别让数据丢了

接收比发送复杂一点。因为CAN总线是实时通信，你必须在数据到达时立刻处理。我一般用多线程或者select模型来做。

class CanReceiver {
private:
    int sock;
    std::atomic<bool> running;

public:
    void startReceive() {
        running = true;
        std::thread([this]() {
            struct can_frame frame;
            while (running) {
                int nbytes = read(sock, &frame, sizeof(frame));
                if (nbytes > 0) {
                    // 处理接收到的帧
                    processFrame(frame);
                }
            }
        }).detach();
    }

    void processFrame(const can_frame& frame) {
        std::cout << "收到帧 ID: 0x" << std::hex << frame.can_id;
        std::cout << " 数据: ";
        for (int i = 0; i < frame.can_dlc; i++) {
            std::cout << std::hex << (int)frame.data[i] << " ";
        }
        std::cout << std::endl;
    }
};

经验之谈：接收线程里千万别做耗时操作。我见过有人直接在接收回调里写日志文件，结果总线拥堵，丢帧严重。正确的做法是：收到数据后扔到队列里，另起线程慢慢处理。

CAN总线通信的核心流程

下面这张图是我自己总结的CAN通信全流程，从初始化到数据收发，每一步都标出来了：

CAN总线通信核心流程 1. 初始化CAN接口 2. 创建CAN Socket 3. 绑定到CAN接口 4. 数据收发循环 发送：write() 接收：read() 5. 关闭Socket 虚线：循环收发

实战：模拟两个节点通信

咱们来写一个完整的例子。假设有两个节点：一个发送车速信息，一个接收并显示。我习惯把代码拆成三个文件：

// can_common.h - 公共定义
#pragma once
#include <cstdint>

// 定义消息ID
constexpr uint32_t ID_VEHICLE_SPEED = 0x100;
constexpr uint32_t ID_ENGINE_RPM    = 0x101;

// 定义数据结构
#pragma pack(push, 1)
struct VehicleSpeedData {
    uint16_t speed;      // 车速，单位0.01 km/h
    uint8_t  direction;  // 0:前进 1:后退
};

struct EngineRPMData {
    uint16_t rpm;        // 发动机转速
    uint8_t  status;     // 0:正常 1:故障
};
#pragma pack(pop)
// can_sender.cpp - 发送节点
#include "can_common.h"
#include <thread>
#include <chrono>

int main() {
    CanBus can;
    if (!can.open("can0")) {
        return -1;
    }

    VehicleSpeedData speedData;
    speedData.speed = 6000;  // 60 km/h
    speedData.direction = 0;

    while (true) {
        can.sendFrame(ID_VEHICLE_SPEED, 
                     reinterpret_cast<uint8_t*>(&speedData), 
                     sizeof(speedData));
        
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        speedData.speed += 100;  // 模拟加速
    }

    return 0;
}
// can_receiver.cpp - 接收节点
#include "can_common.h"

int main() {
    CanBus can;
    if (!can.open("can0")) {
        return -1;
    }

    CanReceiver receiver;
    receiver.setSocket(can.getSocket());
    receiver.startReceive();

    // 主线程做其他事情
    std::this_thread::sleep_for(std::chrono::seconds(60));
    return 0;
}

重要提醒：实际项目中，CAN总线上的数据是实时变化的。我曾经遇到过一个bug：发送节点每10ms发一次数据，接收节点却用1s的间隔去读，结果读到的永远是旧数据。记住：接收要快，处理要异步。

CAN总线的常见坑与调试技巧

搞CAN开发，有几个问题你早晚会遇到：

  • 总线关闭：某个节点疯狂发错误帧，总线会把它踢出去。我遇到过硬件故障导致总线关闭，排查了三天才发现是CAN收发器坏了。
  • 位时序配置：波特率不对，所有节点都收不到数据。用 ip link set can0 type can bitrate 500000 设置，别搞错。
  • 终端电阻：CAN总线两端必须各加一个120欧姆电阻。不加的话，信号反射会让你怀疑人生。

调试神器：candump can0 可以监听总线上的所有消息。cansend can0 123#11223344 可以手动发送测试帧。这两个工具我几乎天天用。

总结

CAN总线通信说白了就是一套“谁抢到谁说话”的规则。用C++实现时，核心就是SocketCAN这套接口。记住三点：

  • 帧结构要搞懂，特别是ID和DLC
  • 收发要异步，别阻塞主流程
  • 调试靠工具，candump和cansend是你的好帮手

嗯，CAN总线的内容就聊到这儿。代码都在上面了，你拿去跑一跑，有问题随时调。搞嵌入式就是这样，多踩坑才能长记性。

公众号：蓝海资料掘金营，微信deep3321
← 上一章 📖 返回目录 下一章 →