vcan配置与使用

火红色祥云

已于 2024-06-26 13:21:10 修改

阅读量1.9k

点赞数 9

分类专栏： Linux学习过程笔记随笔文章标签： linux 网络

于 2024-06-26 11:01:46 首次发布

火红色祥云

本文链接：https://blog.csdn.net/weixin_43739167/article/details/139983677

版权

随笔同时被 2 个专栏收录

97 篇文章

订阅专栏

Linux学习过程笔记

51 篇文章

订阅专栏

vcan

什么是vcan？

vcan（Virtual CAN）是一种虚拟CAN接口，它是Linux内核中的一个虚拟网络接口驱动程序。vcan接口模拟了CAN总线的行为，但没有实际的硬件依赖。这使得它非常适用于开发、测试和调试CAN网络协议和应用程序，而不需要实际的CAN硬件。

vcan的特点

虚拟化：vcan接口在内核中实现，不需要任何物理CAN硬件。
模拟真实CAN总线行为：vcan接口能够模拟CAN总线的数据帧传输、接受等基本功能。
方便测试和调试：开发人员可以在没有CAN硬件的环境中测试和调试CAN相关的软件。
独立于物理硬件：由于vcan接口完全虚拟化，它可以在任何支持Linux的硬件平台上使用。

vcan的使用场景

开发和调试：开发人员可以使用vcan接口在没有物理CAN硬件的情况下开发和调试CAN网络应用程序。这可以大大简化开发过程，并且减少了对物理设备的依赖。
自动化测试：在自动化测试环境中，vcan接口可以用于模拟CAN总线，以便进行单元测试、集成测试和回归测试。这种方法可以确保代码的质量和稳定性。
教育和培训：vcan接口是教学和培训的理想工具。学生和培训人员可以学习和实验CAN总线协议和应用程序，而不需要昂贵的硬件设备。
原型设计：在原型设计阶段，使用vcan接口可以快速验证概念和设计，而不需要等待物理硬件的可用性。
系统仿真：在某些情况下，系统仿真需要模拟完整的网络环境，包括CAN总线。vcan接口可以用于创建虚拟CAN网络，以进行系统级仿真和测试。

如何使用vcan接口

配置vcan接口

加载vcan模块
```
sudo modprobe vcan
```
创建虚拟CAN接口
```
sudo ip link add dev vcan0 type vcan
```
启动虚拟CAN接口
```
sudo ip link set up vcan0
```

发送和接收CAN消息

使用can-utils工具包可以方便地发送和接收CAN消息。

发送CAN消息
```
cansend vcan0 123#1122334455667788
```
这里，123是CAN ID，#后面是数据字段。
接收CAN消息
打开一个新的终端窗口，然后运行：
```
candump vcan0
```

环境

测试是否安装can-utils

cangen -v

测试系统平台是否使能vcan

lsmod | grep vcan

内核使能vcan

Device Drivers --->
  Network device support --->
    CAN bus subsystem support --->
      CAN Device Drivers --->
        [*] Virtual CAN interface (vcan)

前置条件

安装必要的软件：

sudo apt-get update
sudo apt-get install can-utils

配置虚拟CAN接口：

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

发送CAN消息的C程序

创建一个名为sender.c的C程序，内容如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>

int main() {
    int s;
    struct sockaddr_can addr;
    struct ifreq ifr;
    struct can_frame frame;

    // 创建socket
    s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (s < 0) {
        perror("socket");
        return 1;
    }

    // 指定CAN接口
    strcpy(ifr.ifr_name, "vcan0");
    ioctl(s, SIOCGIFINDEX, &ifr);

    // 绑定socket到CAN接口
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        return 1;
    }

    // 构造CAN帧
    frame.can_id = 0x123;
    frame.can_dlc = 8;
    frame.data[0] = 0x11;
    frame.data[1] = 0x22;
    frame.data[2] = 0x33;
    frame.data[3] = 0x44;
    frame.data[4] = 0x55;
    frame.data[5] = 0x66;
    frame.data[6] = 0x77;
    frame.data[7] = 0x88;

    // 发送CAN帧
    while (1) {
        if (write(s, &frame, sizeof(struct can_frame)) != sizeof(struct can_frame)) {
            perror("write");
            return 1;
        }
        printf("Sent CAN frame\n");
        sleep(1);  // 1 second interval
    }

    close(s);
    return 0;
}

接收CAN消息的C程序

创建一个名为receiver.c的C程序，内容如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>

int main() {
    int s;
    struct sockaddr_can addr;
    struct ifreq ifr;
    struct can_frame frame;

    // 创建socket
    s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (s < 0) {
        perror("socket");
        return 1;
    }

    // 指定CAN接口
    strcpy(ifr.ifr_name, "vcan0");
    ioctl(s, SIOCGIFINDEX, &ifr);

    // 绑定socket到CAN接口
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        return 1;
    }

    // 接收CAN帧
    while (1) {
        if (read(s, &frame, sizeof(struct can_frame)) < 0) {
            perror("read");
            return 1;
        }
        printf("Received CAN frame: ID=0x%X DLC=%d data[0]=0x%X data[1]=0x%X data[2]=0x%X data[3]=0x%X data[4]=0x%X data[5]=0x%X data[6]=0x%X data[7]=0x%X\n",
               frame.can_id, frame.can_dlc,
               frame.data[0], frame.data[1], frame.data[2], frame.data[3],
               frame.data[4], frame.data[5], frame.data[6], frame.data[7]);
    }

    close(s);
    return 0;
}

编译和运行程序

编译发送程序和接收程序：

gcc -o sender sender.c
gcc -o receiver receiver.c

在两个不同的终端窗口中运行这两个程序：
- 运行发送程序：
```
./sender
```
- 运行接收程序：
```
./receiver
```

使用candump查看数据

在第三个终端窗口中运行candump工具来查看vcan0接口上的CAN数据：

candump vcan0

这个命令将输出vcan0接口上的所有CAN消息，如下所示：

vcan0  123   [8]  11 22 33 44 55 66 77 88

总结

配置vcan接口。
编写发送CAN消息的C程序sender.c。
编写接收CAN消息的C程序receiver.c。
编译并运行两个程序。
使用candump工具实时查看传输的CAN消息。

通过这种方式，你可以在Linux平台上测试两个进程之间使用vcan接口进行通信，并使用candump工具来查看和验证传输的数据。

可以使用C语言测试vcan的负载率。下面是一个示例，展示了如何使用C语言读取vcan接口上的CAN帧，并计算总线的负载率。

步骤概述

初始化vcan接口
接收CAN帧
计算负载率

示例代码

初始化vcan接口

首先，确保已经加载了vcan模块并创建了vcan接口：

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

接收CAN帧并计算负载率

以下是一个使用C语言的完整示例程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <time.h>

// 计算单个CAN帧的传输时间
double calculate_can_frame_time(int dlc, int bitrate) {
    int total_bits = 47 + (dlc * 8); // 47个固定开销位，加上DLC的数据位
    return (double)total_bits / bitrate;
}

// 监控vcan接口负载率
void monitor_can_load(const char *interface, int duration, int bitrate) {
    int s;
    struct sockaddr_can addr;
    struct ifreq ifr;
    struct can_frame frame;
    struct timeval start, end;

    // 创建socket
    s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (s < 0) {
        perror("socket");
        exit(1);
    }

    // 指定CAN接口
    strcpy(ifr.ifr_name, interface);
    ioctl(s, SIOCGIFINDEX, &ifr);

    // 绑定socket到CAN接口
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        exit(1);
    }

    // 记录开始时间
    gettimeofday(&start, NULL);

    int frame_count = 0;
    double total_frame_time = 0;

    // 接收CAN帧并计算负载率
    while (1) {
        // 记录当前时间
        gettimeofday(&end, NULL);

        // 计算经过的时间
        double elapsed_time = (end.tv_sec - start.tv_sec) + (end.tv_usec - start.tv_usec) / 1e6;
        if (elapsed_time > duration) {
            break;
        }

        int nbytes = read(s, &frame, sizeof(struct can_frame));
        if (nbytes < 0) {
            perror("read");
            exit(1);
        }

        frame_count++;
        total_frame_time += calculate_can_frame_time(frame.can_dlc, bitrate);

        printf("Received frame: ID=0x%X DLC=%d Data=", frame.can_id, frame.can_dlc);
        for (int i = 0; i < frame.can_dlc; i++) {
            printf("%02X ", frame.data[i]);
        }
        printf("\n");
    }

    double bus_load = (total_frame_time / duration) * 100;
    printf("\nMonitoring Duration: %d seconds\n", duration);
    printf("Total Frames Received: %d\n", frame_count);
    printf("Total Frame Time: %.6f seconds\n", total_frame_time);
    printf("Bus Load: %.2f%%\n", bus_load);

    close(s);
}

int main(int argc, char **argv) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <duration> <bitrate>\n", argv[0]);
        exit(1);
    }

    int duration = atoi(argv[1]);
    int bitrate = atoi(argv[2]);

    monitor_can_load("vcan0", duration, bitrate);
    return 0;
}

编译和运行

将代码保存为can_load_monitor.c。

编译代码：

gcc -o can_load_monitor can_load_monitor.c

运行程序：

./can_load_monitor <duration> <bitrate>

例如，监控10秒，假设比特率为1 Mbps：

./can_load_monitor 10 1000000

解释

calculate_can_frame_time：计算单个CAN帧的传输时间。
monitor_can_load：接收CAN帧并计算总线负载率。它计算每个CAN帧的传输时间并累计，然后根据传输的总时间计算总线负载率。
main：程序入口，接受命令行参数来设置监控持续时间和比特率。

通过这种方式，你可以使用C语言在Linux平台上测试vcan接口的负载率。这种方法不仅适用于虚拟CAN接口，也适用于实际的CAN硬件接口，只需要更改接口名称即可。