sudo apt update
sudo apt install build-essential
sudo apt install can-utils  # 安裝 can-utils 工具包
sudo apt install libsocketcan-dev  # 如果需要安裝 SocketCAN 開(kāi)發(fā)庫(kù)

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>              // 包含輸入輸出流，用于打印日志或調(diào)試信息
#include <string>                // 包含 string 類(lèi)的定義，用于字符串操作
#include <cstring>               // 包含 C 風(fēng)格字符串操作函數(shù)的定義
#include <unistd.h>              // 包含 POSIX 系統(tǒng)調(diào)用，例如 close, read, write
#include <net/if.h>              // 包含網(wǎng)絡(luò)接口相關(guān)的定義
#include <sys/ioctl.h>           // 包含 I/O 控制相關(guān)的函數(shù)定義，例如 SIOCGIFINDEX
#include <fcntl.h>               // 包含文件控制相關(guān)的定義
#include <linux/can.h>           // 包含 CAN 協(xié)議相關(guān)的定義
#include <linux/can/raw.h>       // 包含原始 CAN 套接字定義
#include <sys/socket.h>          // 包含 socket 套接字的相關(guān)定義
#include <thread>                // 包含多線程支持的定義
#include <atomic>                // 包含原子操作的定義，用于線程安全
#include <mutex>                 // 包含互斥量的定義，用于線程同步
#include <vector>                // 包含 vector 容器的定義
#include <queue>                 // 包含隊(duì)列容器的定義
#include <functional>            // 包含函數(shù)對(duì)象的定義，用于隊(duì)列任務(wù)
#include <condition_variable>    // 包含條件變量定義，用于線程同步
#include <chrono>                // 包含時(shí)間相關(guān)定義，用于控制線程等待時(shí)間
#include <iostream>              // 包含 I/O 相關(guān)功能
 
// 線程池類(lèi)，用于管理多個(gè)線程，執(zhí)行異步任務(wù)
class ThreadPool {
public:
    // 構(gòu)造函數(shù)，初始化線程池，啟動(dòng) numThreads 個(gè)線程
    ThreadPool(size_t numThreads) : stop(false) {
        // 創(chuàng)建并啟動(dòng)工作線程
        for (size_t i = 0; i < numThreads; ++i) {
            workers.push_back(std::thread([this]() { workerLoop(); }));
        }
    }
 
    // 析構(gòu)函數(shù)，停止線程池中的所有線程
    ~ThreadPool() {
        stop = true;             // 設(shè)置停止標(biāo)志
        condVar.notify_all();    // 通知所有線程退出
        for (std::thread &worker : workers) {
            worker.join();        // 等待所有線程結(jié)束
        }
    }
 
    // 向線程池隊(duì)列中添加一個(gè)任務(wù)
    void enqueue(std::function<void()> task) {
        {
            std::lock_guard<std::mutex> lock(queueMutex);  // 鎖住隊(duì)列，避免多線程訪問(wèn)沖突
            tasks.push(task);  // 將任務(wù)放入隊(duì)列
        }
        condVar.notify_one();  // 喚醒一個(gè)等待的線程
    }
 
private:
    // 線程池中的工作線程函數(shù)
    void workerLoop() {
        while (!stop) {  // 當(dāng) stop 為 false 時(shí)，線程繼續(xù)工作
            std::function<void()> task;  // 定義一個(gè)任務(wù)對(duì)象
            {
                // 鎖住隊(duì)列，線程安全地訪問(wèn)任務(wù)隊(duì)列
                std::unique_lock<std::mutex> lock(queueMutex);
                condVar.wait(lock, [this]() { return stop || !tasks.empty(); });  // 等待任務(wù)或停止信號(hào)
 
                // 如果 stop 為 true 且隊(duì)列為空，退出循環(huán)
                if (stop && tasks.empty()) {
                    return;
                }
 
                task = tasks.front();  // 獲取隊(duì)列中的第一個(gè)任務(wù)
                tasks.pop();  // 從隊(duì)列中移除該任務(wù)
            }
 
            task();  // 執(zhí)行任務(wù)
        }
    }
 
    std::vector<std::thread> workers;           // 線程池中的所有線程
    std::queue<std::function<void()>> tasks;    // 任務(wù)隊(duì)列，存儲(chǔ)待處理的任務(wù)
    std::mutex queueMutex;                      // 互斥鎖，用于保護(hù)任務(wù)隊(duì)列
    std::condition_variable condVar;            // 條件變量，用于通知線程執(zhí)行任務(wù)
    std::atomic<bool> stop;                     // 原子變量，用于控制線程池的停止
};
 
// CAN 通信類(lèi)，用于發(fā)送和接收 CAN 消息
class CanCommunication {
public:
    // 構(gòu)造函數(shù)，初始化 CAN 通信
    CanCommunication(const std::string &interfaceName) : stopReceiving(false) {
        sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);  // 創(chuàng)建原始 CAN 套接字
        if (sock < 0) {  // 如果套接字創(chuàng)建失敗，輸出錯(cuò)誤并退出
            perror("Error while opening socket");
            exit(EXIT_FAILURE);
        }
 
        struct ifreq ifr;  // 網(wǎng)絡(luò)接口請(qǐng)求結(jié)構(gòu)體
        strncpy(ifr.ifr_name, interfaceName.c_str(), sizeof(ifr.ifr_name) - 1);  // 設(shè)置接口名
        ioctl(sock, SIOCGIFINDEX, &ifr);  // 獲取網(wǎng)絡(luò)接口的索引
 
        struct sockaddr_can addr;  // CAN 地址結(jié)構(gòu)體
        addr.can_family = AF_CAN;  // 設(shè)置地址族為 CAN
        addr.can_ifindex = ifr.ifr_ifindex;  // 設(shè)置接口索引
 
        if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {  // 綁定套接字到指定的 CAN 接口
            perror("Error while binding socket");
            exit(EXIT_FAILURE);
        }
    }
 
    // 析構(gòu)函數(shù)，關(guān)閉 CAN 套接字
    ~CanCommunication() {
        if (sock >= 0) {
            close(sock);  // 關(guān)閉套接字
        }
    }
 
    // 發(fā)送 CAN 消息
    void sendCanMessage(const can_frame &frame) {
        if (write(sock, &frame, sizeof(frame)) != sizeof(frame)) {  // 寫(xiě)入套接字發(fā)送數(shù)據(jù)
            perror("Error while sending CAN message");
        }
    }
 
    // 接收 CAN 消息
    void receiveCanMessages(ThreadPool &threadPool) {
        while (!stopReceiving) {  // 如果沒(méi)有接收停止信號(hào)，繼續(xù)接收數(shù)據(jù)
            can_frame frame;  // 定義一個(gè) CAN 幀
            int nbytes = read(sock, &frame, sizeof(frame));  // 從套接字中讀取數(shù)據(jù)
            if (nbytes < 0) {  // 如果讀取失敗，輸出錯(cuò)誤信息
                perror("Error while receiving CAN message");
                continue;
            }
 
            // 將解析任務(wù)提交到線程池
            threadPool.enqueue([this, frame]() {
                this->parseCanMessage(frame);  // 解析 CAN 消息
            });
        }
    }
 
    // 停止接收數(shù)據(jù)
    void stopReceivingData() {
        stopReceiving = true;  // 設(shè)置停止接收標(biāo)志
    }
 
private:
    int sock;  // 套接字描述符
    std::atomic<bool> stopReceiving;  // 原子標(biāo)志，表示是否停止接收數(shù)據(jù)
    std::mutex parseMutex;  // 解析數(shù)據(jù)時(shí)的互斥鎖
 
    // 解析 CAN 消息
    void parseCanMessage(const can_frame &frame) {
        std::lock_guard<std::mutex> lock(parseMutex);  // 鎖住互斥量，確保解析數(shù)據(jù)時(shí)的線程安全
        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 數(shù)據(jù)字節(jié)
            std::cout << std::hex << (int)frame.data[i] << " ";  // 打印每個(gè)字節(jié)的十六進(jìn)制表示
        }
        std::cout << std::endl;
    }
};
 
// 主函數(shù)
int main() {
    ThreadPool threadPool(4);  // 創(chuàng)建一個(gè)有 4 個(gè)線程的線程池
    CanCommunication canComm("vcan0");  // 創(chuàng)建一個(gè) CanCommunication 對(duì)象，使用虛擬 CAN 接口 "vcan0"
    
    // 啟動(dòng)一個(gè)線程來(lái)接收 CAN 消息
    std::thread receiverThread(&CanCommunication::receiveCanMessages, &canComm, std::ref(threadPool));
 
    // 創(chuàng)建并發(fā)送一個(gè) CAN 消息
    can_frame sendFrame;
    sendFrame.can_id = 0x123;  // 設(shè)置 CAN ID 為 0x123
    sendFrame.can_dlc = 8;  // 設(shè)置數(shù)據(jù)長(zhǎng)度為 8 字節(jié)
    for (int i = 0; i < 8; ++i) {
        sendFrame.data[i] = i;  // 填充數(shù)據(jù)
    }
 
    canComm.sendCanMessage(sendFrame);  // 發(fā)送 CAN 消息
 
    std::this_thread::sleep_for(std::chrono::seconds(5));  // 等待 5 秒，以便接收和處理消息
    
    canComm.stopReceivingData();  // 停止接收數(shù)據(jù)
    receiverThread.join();  // 等待接收線程結(jié)束
 
    return 0;  // 程序正常退出
}