CAN通信

清风丿缠绕心扉

于 2024-07-29 22:14:17 发布

阅读量491

点赞数 8

分类专栏：网络通信文章标签： c++

本文链接：https://blog.csdn.net/qq_45031489/article/details/140782166

版权

网络通信专栏收录该内容

4 篇文章 0 订阅

订阅专栏

CAN（Controller Area Network，控制器局域网络）通信是一种专门设计用于高速实时数据传输的串行通信协议。

特点和优势

实时性和高速性： CAN 总线能够以高达 1 Mbps 的速率进行通信，支持实时数据传输需求。
可靠性： CAN 协议设计了多种错误检测和恢复机制，如CRC（循环冗余校验）、ACK（应答确认）、重发机制等，以确保通信的可靠性和稳定性。
多主机网络： CAN 总线采用了分布式的多主机网络结构，每个节点可以独立发送或接收消息，不需要中心控制器。
抗干扰能力： CAN 总线设计了差分信号线路，使其对电磁干扰（EMI）具有较强的抵抗能力，适合于车辆等噪声环境下的使用。
低成本和简单实现： CAN 总线硬件成本相对较低，并且协议本身较为简单，易于实现和集成到不同的设备中。

一些常见的CAN库包括：
SocketCAN：Linux 下的一个开源CAN协议栈，可以通过 socket 接口进行访问。
PCAN：Windows 下的一套CAN接口库，支持多种CAN硬件设备。
Kvaser CANlib SDK：跨平台的CAN库，支持多种操作系统和硬件设备。

1. socketCAN实现CAN通信

使用 Linux 平台上的 SocketCAN 接口来实现 CAN 通讯，实现接收和发送CAN帧。

创建步骤

Socket 创建和绑定：
- 使用 socket() 创建一个原始的 SocketCAN 套接字。
- 使用 ioctl() 和 SIOCGIFINDEX 获取 CAN 接口的索引。
- 使用 bind() 将 SocketCAN 套接字绑定到 CAN 接口。
CAN 帧准备和发送：
- 设置 can_frame 结构体的 can_id（帧标识符）和 data（数据）字段。
- 使用 write() 发送 CAN 帧到 CAN 总线。
CAN 帧接收：
- 使用 read() 从 CAN 总线接收 CAN 帧。
- 解析接收到的 CAN 帧并打印出其 ID 和数据。
Socket 关闭：
- 使用 close() 关闭 SocketCAN 套接字。

示例代码说明

用于在 Linux 上使用 SocketCAN 接口发送和接收 CAN 帧。

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

int main() {
    int s; // Socket描述符
    struct sockaddr_can addr;
    struct ifreq ifr;

    const char *ifname = "can0"; // CAN 接口名称

    // 创建一个原始 SocketCAN 套接字
    if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
        perror("Socket creation failed");
        return 1;
    }

    // 设置 CAN 接口名称
    strcpy(ifr.ifr_name, ifname);
    ioctl(s, SIOCGIFINDEX, &ifr);

    // 绑定到 CAN 接口
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;

    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("Binding to interface failed");
        close(s);
        return 1;
    }

    // 准备一个 CAN 帧
    struct can_frame frame;
    frame.can_id = 0x123; // CAN 帧 ID
    frame.can_dlc = 2;    // 数据长度
    frame.data[0] = 0x11;
    frame.data[1] = 0x22;

    // 发送 CAN 帧
    if (write(s, &frame, sizeof(frame)) != sizeof(frame)) {
        perror("Write to CAN bus failed");
        close(s);
        return 1;
    }

    std::cout << "Message sent to CAN bus" << std::endl;

    // 接收 CAN 帧
    struct can_frame recv_frame;
    ssize_t nbytes = read(s, &recv_frame, sizeof(recv_frame));
    if (nbytes < 0) {
        perror("Read from CAN bus failed");
    } else if (nbytes < sizeof(struct can_frame)) {
        perror("Incomplete CAN frame received");
    } else {
        std::cout << "Received CAN frame: ID = 0x" << std::hex << recv_frame.can_id << ", Data = ";
        for (int i = 0; i < recv_frame.can_dlc; ++i) {
            std::cout << std::hex << static_cast<int>(recv_frame.data[i]) << " ";
        }
        std::cout << std::dec << std::endl;
    }

    // 关闭 SocketCAN 套接字
    close(s);

    return 0;
}

2. PCAN实现CAN通信

以下是一个简单的示例代码，演示如何使用 PCAN-Basic API 在 Windows 平台上通过 PCAN-USB 接口卡进行 CAN 总线通信。
使用 PCAN-Basic API 需要先安装 PEAK 的 PCAN-Basic 驱动和相关软件。

创建步骤

初始化 PCAN 设备：
使用 CAN_Initialize 函数初始化 PCAN 设备，指定使用的通道和波特率（这里是 500 kbps）。
发送 CAN 消息：
使用 CAN_Write 函数发送一个简单的 CAN 消息，设置消息的标识符、长度和数据内容。
读取 CAN 消息：
使用 CAN_Read 函数在循环中读取从 CAN 总线接收到的消息。如果收到消息，将其打印出来；如果没有收到消息，将等待并继续读取。
关闭 PCAN 通道：
最后使用 CAN_Uninitialize 函数关闭 PCAN 设备。

代码示例：

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include "PCANBasic.h"

void main()
{
    // 初始化PCAN设备
    TPCANHandle hnd;
    TPCANStatus status;
    TPCANMsg msg;
    DWORD iBuffer;

    // 打开PCAN通道
    hnd = PCAN_USBBUS1;  // 使用PCAN-USB通道1
    status = CAN_Initialize(hnd, PCAN_BAUD_500K, 0, 0, 0);
    if (status != PCAN_ERROR_OK) {
        printf("Error: CAN_Initialize failed. Status: 0x%x\n", status);
        return;
    }

    // 发送CAN消息
    msg.ID = 0x123;     // CAN标识符
    msg.LEN = 2;        // 消息长度
    msg.MSGTYPE = PCAN_MESSAGE_STANDARD;  // 标准CAN消息
    msg.DATA[0] = 0x01; // 数据字节1
    msg.DATA[1] = 0x02; // 数据字节2

    status = CAN_Write(hnd, &msg);
    if (status != PCAN_ERROR_OK) {
        printf("Error: CAN_Write failed. Status: 0x%x\n", status);
        CAN_Uninitialize(hnd);
        return;
    }

    // 读取CAN消息
    while (!_kbhit()) {
        status = CAN_Read(hnd, &msg, NULL);
        if (status == PCAN_ERROR_OK) {
            printf("Received message. ID: 0x%x, Length: %d, Data: %02x %02x\n",
                   msg.ID, msg.LEN, msg.DATA[0], msg.DATA[1]);
        }
        else if (status != PCAN_ERROR_QRCVEMPTY) {
            printf("Error: CAN_Read failed. Status: 0x%x\n", status);
            break;
        }
        Sleep(100);  // 等待100毫秒
    }

    // 关闭PCAN通道
    CAN_Uninitialize(hnd);
}

3. Kvaser CANlib SDK实现CAN

Kvaser CANlib SDK 是用于 Kvaser CAN 接口卡的软件开发工具包，它允许在多种操作系统下（包括 Windows 和 Linux）进行 CAN 总线通信的开发。
canOPEN_ACCEPT_VIRTUAL

创建步骤

初始化 CANlib：
使用 canInitializeLibrary() 函数初始化 Kvaser CANlib SDK。
打开通道：
使用 canOpenChannel() 函数打开第一个可用的 CAN 通道，并指定canOPEN_ACCEPT_VIRTUAL标志以接受虚拟通道。
设置通道参数：
使用 canSetBusParams() 函数设置通道的波特率。
设置为 canBITRATE_500K，即 500 kbps。
启动 CAN 通道：
使用 canBusOn() 函数启动 CAN 通道，使其能够发送和接收 CAN 消息。
构造和发送 CAN 消息：
构造一个 canMessage 结构体表示要发送的 CAN 消息，并使用 canWrite() 函数发送该消息到 CAN 总线。
接收 CAN 消息：
在 while 循环中，使用 canRead() 函数接收从 CAN 总线上接收到的消息。如果成功接收到消息，将其打印出来。
关闭 CAN 通道：
使用 canBusOff() 函数关闭 CAN 通道，停止 CAN 通信。
使用 canClose() 函数关闭已打开的 CAN 通道。
卸载 CANlib：
使用 canUnloadLibrary() 函数卸载 Kvaser CANlib SDK。

代码示例：

#include <iostream>
#include <canlib.h>

int main() {
    // 初始化 CANlib
    canInitializeLibrary();

    // 打开第一个可用的通道
    int channel = canOpenChannel(0, canOPEN_ACCEPT_VIRTUAL);
    if (channel < 0) {
        std::cerr << "Error: canOpenChannel failed, error code " << channel << std::endl;
        return 1;
    }

    // 设置通道的波特率
    canSetBusParams(channel, canBITRATE_500K, 0, 0, 0, 0, 0);

    // 启动通道
    canStatus status = canBusOn(channel);
    if (status != canOK) {
        std::cerr << "Error: canBusOn failed, status " << status << std::endl;
        canClose(channel);
        return 1;
    }

    // 构造一个 CAN 消息
    canMessage msg;
    msg.id = 0x123;          // CAN 标识符
    msg.len = 2;             // 消息长度
    msg.flags = 0;           // 标准帧
    msg.data[0] = 0x01;      // 数据字节1
    msg.data[1] = 0x02;      // 数据字节2

    // 发送 CAN 消息
    status = canWrite(channel, &msg);
    if (status != canOK) {
        std::cerr << "Error: canWrite failed, status " << status << std::endl;
        canBusOff(channel);
        canClose(channel);
        return 1;
    }

    // 接收 CAN 消息
    canMessage rxMsg;
    while (true) {
        status = canRead(channel, &rxMsg, 0);
        if (status == canOK) {
            std::cout << "Received message. ID: 0x" << std::hex << rxMsg.id << ", Length: "
                      << static_cast<int>(rxMsg.len) << ", Data: ";
            for (int i = 0; i < rxMsg.len; ++i) {
                std::cout << std::hex << static_cast<int>(rxMsg.data[i]) << " ";
            }
            std::cout << std::endl;
        }
        else if (status == canERR_NOMSG) {
            // 没有消息，继续等待
            continue;
        }
        else {
            std::cerr << "Error: canRead failed, status " << status << std::endl;
            break;
        }
    }

    // 关闭 CAN 通道
    canBusOff(channel);
    canClose(channel);

    // 卸载 CANlib
    canUnloadLibrary();

    return 0;
}