在Linux中配置和使用CAN通信的详细指南

sudo apt update
sudo apt install build-essential
sudo apt install can-utils  # 安装 can-utils 工具包
sudo apt install libsocketcan-dev  # 如果需要安装 SocketCAN 开发库

sudo modprobe vcan 

sudo ip link add dev vcan0 type vcan
sudo ip link set vcan0 up

cansend vcan0 123#deadbeef 

candump vcan0 

ip link show 

sudo ip link set can0 up type can bitrate 500000 

cansend can0 123#deadbeef

candump can0 

cansend vcan0 123#deadbeef 

candump vcan0 

vcan0 123 [4] dead 

canplayer -I can_logfile.log 

#include <iostream>              // 包含输入输出流，用于打印日志或调试信息
#include <string>                // 包含 string 类的定义，用于字符串操作
#include <cstring>               // 包含 C 风格字符串操作函数的定义
#include <unistd.h>              // 包含 POSIX 系统调用，例如 close, read, write
#include <net/if.h>              // 包含网络接口相关的定义
#include <sys/ioctl.h>           // 包含 I/O 控制相关的函数定义，例如 SIOCGIFINDEX
#include <fcntl.h>               // 包含文件控制相关的定义
#include <linux/can.h>           // 包含 CAN 协议相关的定义
#include <linux/can/raw.h>       // 包含原始 CAN 套接字定义
#include <sys/socket.h>          // 包含 socket 套接字的相关定义
#include <thread>                // 包含多线程支持的定义
#include <atomic>                // 包含原子操作的定义，用于线程安全
#include <mutex>                 // 包含互斥量的定义，用于线程同步
#include <vector>                // 包含 vector 容器的定义
#include <queue>                 // 包含队列容器的定义
#include <functional>            // 包含函数对象的定义，用于队列任务
#include <condition_variable>    // 包含条件变量定义，用于线程同步
#include <chrono>                // 包含时间相关定义，用于控制线程等待时间
#include <iostream>              // 包含 I/O 相关功能
 
// 线程池类，用于管理多个线程，执行异步任务
class ThreadPool {
public:
    // 构造函数，初始化线程池，启动 numThreads 个线程
    ThreadPool(size_t numThreads) : stop(false) {
        // 创建并启动工作线程
        for (size_t i = 0; i < numThreads; ++i) {
            workers.push_back(std::thread([this]() { workerLoop(); }));
        }
    }
 
    // 析构函数，停止线程池中的所有线程
    ~ThreadPool() {
        stop = true;             // 设置停止标志
        condVar.notify_all();    // 通知所有线程退出
        for (std::thread &worker : workers) {
            worker.join();        // 等待所有线程结束
        }
    }
 
    // 向线程池队列中添加一个任务
    void enqueue(std::function<void()> task) {
        {
            std::lock_guard<std::mutex> lock(queueMutex);  // 锁住队列，避免多线程访问冲突
            tasks.push(task);  // 将任务放入队列
        }
        condVar.notify_one();  // 唤醒一个等待的线程
    }
 
private:
    // 线程池中的工作线程函数
    void workerLoop() {
        while (!stop) {  // 当 stop 为 false 时，线程继续工作
            std::function<void()> task;  // 定义一个任务对象
            {
                // 锁住队列，线程安全地访问任务队列
                std::unique_lock<std::mutex> lock(queueMutex);
                condVar.wait(lock, [this]() { return stop || !tasks.empty(); });  // 等待任务或停止信号
 
                // 如果 stop 为 true 且队列为空，退出循环
                if (stop && tasks.empty()) {
                    return;
                }
 
                task = tasks.front();  // 获取队列中的第一个任务
                tasks.pop();  // 从队列中移除该任务
            }
 
            task();  // 执行任务
        }
    }
 
    std::vector<std::thread> workers;           // 线程池中的所有线程
    std::queue<std::function<void()>> tasks;    // 任务队列，存储待处理的任务
    std::mutex queueMutex;                      // 互斥锁，用于保护任务队列
    std::condition_variable condVar;            // 条件变量，用于通知线程执行任务
    std::atomic<bool> stop;                     // 原子变量，用于控制线程池的停止
};
 
// CAN 通信类，用于发送和接收 CAN 消息
class CanCommunication {
public:
    // 构造函数，初始化 CAN 通信
    CanCommunication(const std::string &interfaceName) : stopReceiving(false) {
        sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);  // 创建原始 CAN 套接字
        if (sock < 0) {  // 如果套接字创建失败，输出错误并退出
            perror("Error while opening socket");
            exit(EXIT_FAILURE);
        }
 
        struct ifreq ifr;  // 网络接口请求结构体
        strncpy(ifr.ifr_name, interfaceName.c_str(), sizeof(ifr.ifr_name) - 1);  // 设置接口名
        ioctl(sock, SIOCGIFINDEX, &ifr);  // 获取网络接口的索引
 
        struct sockaddr_can addr;  // CAN 地址结构体
        addr.can_family = AF_CAN;  // 设置地址族为 CAN
        addr.can_ifindex = ifr.ifr_ifindex;  // 设置接口索引
 
        if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {  // 绑定套接字到指定的 CAN 接口
            perror("Error while binding socket");
            exit(EXIT_FAILURE);
        }
    }
 
    // 析构函数，关闭 CAN 套接字
    ~CanCommunication() {
        if (sock >= 0) {
            close(sock);  // 关闭套接字
        }
    }
 
    // 发送 CAN 消息
    void sendCanMessage(const can_frame &frame) {
        if (write(sock, &frame, sizeof(frame)) != sizeof(frame)) {  // 写入套接字发送数据
            perror("Error while sending CAN message");
        }
    }
 
    // 接收 CAN 消息
    void receiveCanMessages(ThreadPool &threadPool) {
        while (!stopReceiving) {  // 如果没有接收停止信号，继续接收数据
            can_frame frame;  // 定义一个 CAN 帧
            int nbytes = read(sock, &frame, sizeof(frame));  // 从套接字中读取数据
            if (nbytes < 0) {  // 如果读取失败，输出错误信息
                perror("Error while receiving CAN message");
                continue;
            }
 
            // 将解析任务提交到线程池
            threadPool.enqueue([this, frame]() {
                this->parseCanMessage(frame);  // 解析 CAN 消息
            });
        }
    }
 
    // 停止接收数据
    void stopReceivingData() {
        stopReceiving = true;  // 设置停止接收标志
    }
 
private:
    int sock;  // 套接字描述符
    std::atomic<bool> stopReceiving;  // 原子标志，表示是否停止接收数据
    std::mutex parseMutex;  // 解析数据时的互斥锁
 
    // 解析 CAN 消息
    void parseCanMessage(const can_frame &frame) {
        std::lock_guard<std::mutex> lock(parseMutex);  // 锁住互斥量，确保解析数据时的线程安全
        std::cout << "Received CAN ID: " << frame.can_id << std::endl;  // 打印 CAN ID
        std::cout << "Data: ";
        for (int i = 0; i < frame.can_dlc; ++i) {  // 遍历 CAN 数据字节
            std::cout << std::hex << (int)frame.data[i] << " ";  // 打印每个字节的十六进制表示
        }
        std::cout << std::endl;
    }
};
 
// 主函数
int main() {
    ThreadPool threadPool(4);  // 创建一个有 4 个线程的线程池
    CanCommunication canComm("vcan0");  // 创建一个 CanCommunication 对象，使用虚拟 CAN 接口 "vcan0"
    
    // 启动一个线程来接收 CAN 消息
    std::thread receiverThread(&CanCommunication::receiveCanMessages, &canComm, std::ref(threadPool));
 
    // 创建并发送一个 CAN 消息
    can_frame sendFrame;
    sendFrame.can_id = 0x123;  // 设置 CAN ID 为 0x123
    sendFrame.can_dlc = 8;  // 设置数据长度为 8 字节
    for (int i = 0; i < 8; ++i) {
        sendFrame.data[i] = i;  // 填充数据
    }
 
    canComm.sendCanMessage(sendFrame);  // 发送 CAN 消息
 
    std::this_thread::sleep_for(std::chrono::seconds(5));  // 等待 5 秒，以便接收和处理消息
    
    canComm.stopReceivingData();  // 停止接收数据
    receiverThread.join();  // 等待接收线程结束
 
    return 0;  // 程序正常退出
}