ubuntu 使用虚拟can 与 socketCAN使用

原文链接：https://blog.csdn.net/xiandang8023/article/details/127990159

创建虚拟CAN接口

在Linux上能使用虚拟CAN接口之前，需要在终端执行以下三个步骤：

加载vcan内核模块: sudo modprobe vcan

创建虚拟CAN接口: sudo ip link add dev vcan0 type vcan

将虚拟CAN接口处于在线状态: sudo ip link set up vcan0 或 sudo ip link set dev vcan0 up

将虚拟CAN接口处于离线状态: sudo ip link set down vcan0 或 sudo ip link set dev vcan0 down

删除虚拟CAN接口: sudo ip link del dev vcan0

然后，通过命令ip addr | grep "can" 来验证是否可用并处于在线状态

也可以通过shell脚本来自动化实现以上步骤：

创建一个vcan.sh文件。然后将其标记为可执行文件: chmod +x ~/vcan.sh，之后执行这个文件 ./vcan.sh

#!/bin/bash
# Make sure the script runs with super user priviliges.
[ "$UID" -eq 0 ] || exec sudo bash "$0" "$@"
# Load the kernel module.
modprobe vcan
# Create the virtual CAN interface.
ip link add dev vcan0 type vcan
# Bring the virutal CAN interface online.
ip link set up vcan0

使用 can-utils 测试CAN通信

接下来我们要基于上面创建的虚拟CAN接口，来测试一下CAN通信情况。工具包 can-utils 是一个命令行工具，可以完美的满足我们的需求。我们只需要在电脑上安装一下这个工具包即可:

Ubuntu/Debian: sudo apt install can-utils

接下来，我们打开两个终端窗口，一个是用来查看所有的CAN消息，另一个是用来发送CAN消息。

在用来查看CAN消息的终端中执行以下命令：

candump -tz vcan0

在用来发送CAN消息的终端中，模拟发送CAN请求：

cansend vcan0 123#00FFAA5501020304

在发送完CAN请求后，就会在第一个查看CAN消息的终端中看到发送的CAN消息：

发送CAN信息

melvyn@melvyn:~$ cansend vcan0 123#00FFAA5501020304
melvyn@melvyn:~$ cansend vcan0 123#00FFAA5501020304

查看CAN信息

 (000.000000)  vcan0  123   [8]  00 FF AA 55 01 02 03 04
 (001.919922)  vcan0  123   [8]  00 FF AA 55 01 02 03 04

从上面的输出可以验证使用新创建的vcan0虚拟CAN接口可以正常进行CAN通信。

CAN数据读取的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <net/if.h>
int main(void)
{
    struct ifreq ifr = {0};
    struct sockaddr_can can_addr = {0};
    struct can_frame frame = {0};
    int sockfd = -1;
    int i;
    int ret;

    /* 打开套接字 */
    sockfd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if(0 > sockfd) {
        perror("socket error");
        exit(EXIT_FAILURE);
    }

    /* 指定can0设备 */
    strcpy(ifr.ifr_name, "vcan0");
    ioctl(sockfd, SIOCGIFINDEX, &ifr);
    can_addr.can_family = AF_CAN;
    can_addr.can_ifindex = ifr.ifr_ifindex;

    /* 将can0与套接字进行绑定 */
    ret = bind(sockfd, (struct sockaddr *)&can_addr, sizeof(can_addr));
    if (0 > ret) {
        perror("bind error");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    /* 设置过滤规则 */
    //setsockopt(sockfd, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

    /* 接收数据 */
    for ( ; ; ) {
        if (0 > read(sockfd, &frame, sizeof(struct can_frame))) {
            perror("read error");
            break;
        }

        /* 校验是否接收到错误帧 */
        if (frame.can_id & CAN_ERR_FLAG) {
            printf("Error frame!\n");
            break;
        }

        /* 校验帧格式 */
        if (frame.can_id & CAN_EFF_FLAG)    //扩展帧
            printf("扩展帧 <0x%08x> ", frame.can_id & CAN_EFF_MASK);
        else        //标准帧
            printf("标准帧 <0x%03x> ", frame.can_id & CAN_SFF_MASK);

        /* 校验帧类型：数据帧还是远程帧 */
        if (frame.can_id & CAN_RTR_FLAG) {
            printf("remote request\n");
            continue;
        }

        /* 打印数据长度 */
        printf("[%d] ", frame.can_dlc);

        /* 打印数据 */
        for (i = 0; i < frame.can_dlc; i++)
            printf("%02x ", frame.data[i]);
        printf("\n");
    }

    /* 关闭套接字 */
    close(sockfd);
    exit(EXIT_SUCCESS);
}

CAN数据写入的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <net/if.h>
int main(void)
{
    struct ifreq ifr = {0};
    struct sockaddr_can can_addr = {0};
    struct can_frame frame = {0};
    int sockfd = -1;
    int ret;

    /* 打开套接字 */
    sockfd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if(0 > sockfd) {
        perror("socket error");
        exit(EXIT_FAILURE);
    }

    /* 指定can0设备 */
    strcpy(ifr.ifr_name, "vcan0");
    ioctl(sockfd, SIOCGIFINDEX, &ifr);
    can_addr.can_family = AF_CAN;
    can_addr.can_ifindex = ifr.ifr_ifindex;

    /* 将can0与套接字进行绑定 */
    ret = bind(sockfd, (struct sockaddr *)&can_addr, sizeof(can_addr));
    if (0 > ret) {
        perror("bind error");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    /* 设置过滤规则：不接受任何报文、仅发送数据 */
    setsockopt(sockfd, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

    /* 发送数据 */
    frame.data[0] = 0xA0;
    frame.data[1] = 0xB0;
    frame.data[2] = 0xC0;
    frame.data[3] = 0xD0;
    frame.data[4] = 0xE0;
    frame.data[5] = 0xF0;
    frame.can_dlc = 6;    //一次发送6个字节数据
    frame.can_id = 0x123;//帧ID为0x123,标准帧

    for ( ; ; ) {

        ret = write(sockfd, &frame, sizeof(frame)); //发送数据
        if(sizeof(frame) != ret) { //如果ret不等于帧长度，就说明发送失败
            perror("write error");
            goto out;
        }

        sleep(1);        //一秒钟发送一次
    }

out:
    /* 关闭套接字 */
    close(sockfd);
    exit(EXIT_SUCCESS);
}

运行结果

补充 CAN 的常用操作命令：

可以使用ip命令来查看或设置CAN，使用ifconfig或ip命令来开启/关闭CAN，canconfig工具来配置和调试CAN，cansend 和 candump用于收发CAN报文。

#ifconfig -a //查到当前can网络 can0 can1，包括收发包数量、是否有错误等等
#ip link set vcan0 down //关闭can设备；或使用ifconfig canX down
#ip link set vcan0 up //开启can设备；或使用ifconfig canX up
#ip -details link show vcan0 //显示can设备详细信息；
#ip link set vcan0 up type can bitrate 250000 //设置can波特率
#canconfig vcan0 ctrlmode loopback on //回环测试；
#canconfig vcan0 restart // 重启can设备；
#canconfig vcan0 stop //停止can设备；
#canecho vcan0 //查看can设备总线状态；
#candump vcan0 //接收can总线发来的数据；
#cansend vcan0 --identifier=ID+数据 //发送数据；
#candump vcan0 --filter=ID：mask//使用滤波器接收ID匹配的数据

复杂版程序

原文链接：https://zhuanlan.zhihu.com/p/429616854

#ifndef _CAN_H_
#define _CAN_H_

#ifdef __cplusplus
extern "C" {
#endif

int iface_is_up(char *iface);
int can_iface_down(char *iface);
int can_iface_up(char *iface, int baudrate, int fdon, int dbaudrate);
int can_open(char *iface, int canid, int canfd_on);
int can_send(int sock, int canid, unsigned char *data, int len);
int canfd_send(int sock, int canid, unsigned char *data, int len);
int can_recv(int sock, unsigned char *data, int len, int *canid);
int canfd_recv(int sock, unsigned char *data, int len, int *canid);
int can_close(int sock);

#ifdef __cplusplus
}
#endif

#endif

#include <stdio.h>
#include <stdlib.h>
#include <errno.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 "can.h"

#define CAN_IFACE_TXQUEUELEN 100

int iface_is_up(char *iface)
{
    int sock;
    struct ifreq ifr;
    int ret;
    sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (sock < 0) {
        perror("socket err.\n");
        return 0;
    }
    strcpy(ifr.ifr_name, iface);
    ioctl(sock, SIOCGIFFLAGS, &ifr);
    if (ifr.ifr_ifru.ifru_flags & IFF_RUNNING) {
        ret = 1;
    } else {
        ret = 0;
    }
    close(sock);
    return ret;
}

int can_iface_down(char *iface)
{
    char cmd[128];
    snprintf(cmd, sizeof(cmd), "sudo ifconfig %s down", iface);
    system(cmd);
    return 0;
}

int can_iface_up(char *iface, int baudrate, int fdon, int dbaudrate)
{
    char cmd[256];
    int len = 0;
    if (iface_is_up(iface)) {
        printf("Can Iface [%s] is up\n", iface);
        return 0;
    }
    printf("Try to Start Can Iface [%s]...\n", iface);
    len += snprintf(cmd + len, sizeof(cmd) - len, "sudo ip link set %s up type can bitrate %d ", iface, baudrate);
    if (fdon) {
        len += snprintf(cmd + len, sizeof(cmd) - len, " fd on dbitrate %d ", dbaudrate);
    } else {
        // len += snprintf(cmd + len, sizeof(cmd) - len, " fd off");
    }
    system(cmd);
    sleep(1);
    len = snprintf(cmd, sizeof(cmd), "sudo ifconfig %s txqueuelen %d", iface, CAN_IFACE_TXQUEUELEN);
    system(cmd);
    printf("Can Iface [%s] start finish.\n", iface);
    return 0;
}

int can_open(char *iface, int canid, int canfd_on)
{
    int sock;
    struct ifreq ifr;
    struct sockaddr_can addr;
    struct can_filter rfilter[1];
    if (!iface_is_up(iface)) {
        perror("iface err..\n");
        return -1;
    }
    sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (sock < 0) {
        perror("socket err.\n");
        return -1;
    }
    strcpy(ifr.ifr_name, iface);
    ioctl(sock, SIOCGIFINDEX, &ifr);
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    if (bind(sock, (struct sockaddr *)&addr, sizeof(addr))) {
        perror("bind err.\n");
        return -1;
    }
    if (canid > 0) {
        rfilter[0].can_id = canid;
        rfilter[0].can_mask = CAN_SFF_MASK;
        if (setsockopt(sock, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter))) {
            perror("setsockopt [SOL_CAN_RAW/CAN_RAW_FILTER] err.\n");
            return -1;
        }
    }
    if (canfd_on > 0) {
        if (setsockopt(sock, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on))) {
            perror("setsockopt [SOL_CAN_RAW/CAN_RAW_FD_FRAMES] err.\n");
            return -1;
        }
    }
    /* int loopback = 0;
    if (setsockopt(sock, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback, sizeof(loopback))) {
                perror("setsockopt [SOL_CAN_RAW/CAN_RAW_LOOPBACK] err.\n");
                return -1;
        } */
    return sock;
}

int can_send(int sock, int canid, unsigned char *data, int len)
{
    int nr;
    struct can_frame frame;
    if (len > sizeof(frame.data)) {
        printf("can_send: len more than 8 is not support.\n");
        return -1;
    }
    frame.can_dlc = len;
    frame.can_id = canid;
    memcpy(frame.data, data, len);
    nr = write(sock, &frame, sizeof(struct can_frame));
    if (nr != sizeof(struct can_frame)) {
        printf("can_send: write ret=%d[%s].\n", nr, strerror(errno));
        return -1;
    }
    return frame.can_id;
}

int can_recv(int sock, unsigned char *data, int len, int *canid)
{
    int nr;
    struct can_frame frame;
    nr = read(sock, &frame, sizeof(struct can_frame));
    if (nr < 0) {
        // perror("can_recv: read err.\n");
        return -1;
    }
    if (nr == 0) {
        perror("can_recv: read ret 0, peer may closed.\n");
        return -1;
    }
    if (canid) {
        *canid = frame.can_id;
    }
    if (len < frame.can_dlc) {
        printf("can_recv: recv data buffer too small, data has trunced.\n");
        memcpy(data, frame.data, len);
        return len;
    } else {
        memcpy(data, frame.data, frame.can_dlc);
    }
    return frame.can_dlc;
}

int canfd_send(int sock, int canid, unsigned char *data, int len)
{
    int nr;
    struct canfd_frame frame;
    if (len > sizeof(frame.data)) {
        printf("can_send: len more than 8 is not support.\n");
        return -1;
    }
    frame.len = len;
    frame.can_id = canid;
    frame.flags = 0xF;
    memcpy(frame.data, data, len);
    nr = write(sock, &frame, sizeof(struct canfd_frame));
    if (nr != sizeof(struct canfd_frame)) {
        perror("can_send: write err.\n");
        return -1;
    }
    return frame.can_id;
}

int canfd_recv(int sock, unsigned char *data, int len, int *canid)
{
    int nr;
    struct canfd_frame frame;
    nr = read(sock, &frame, sizeof(struct canfd_frame));
    if (nr < 0) {
        //perror("can_recv: read err.\n");
        return -1;
    }
    if (nr == 0) {
        perror("can_recv: read ret 0, peer may closed.\n");
        return -1;
    }
    if (len < frame.len) {
        printf("can_recv: recv data buffer too small, data has trunced.\n");
        memcpy(data, frame.data, len);
        return len;
    } else {
        memcpy(data, frame.data, frame.len);
    }
    if (canid) {
        *canid = frame.can_id;
    }
    return frame.len;
}

int can_close(int sock)
{
    return close(sock);
}

#include "can.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <fcntl.h>

unsigned char sent_data[8];

void show_hex(unsigned char * data, int len)
{
    int i = 0;
    while(i < len)
    {
        if(!(i % 16))
        {
            printf("0x%08x ", i);
        }
        printf("%02x ", data[i]);
        if(i % 16 == 15)
        {
            printf("\n");
        }
        i = i + 1;
    }
    printf("\n\n");
}

void * can_aux_loop(int sock_)
{
    int nr, canid, i, failure = 0;
    unsigned char data[8];
    while(true)
    {
        usleep(100);
        nr = can_recv(sock_, data, sizeof(data), &canid);
        if(nr > 0)
        {
            printf("can_recv canid: %03x.\n", canid);
            show_hex(data, nr);
        }
        else
        {
            failure = failure + 1;
            if(failure > 20)
            {
                break;
            }
            continue;
        }
        i = 0;
        while(i < 8)
        {
            if(data[i] != sent_data[i])
            {
                break;
            }
            i = i + 1;
        }
        if(i == 8)
        {
            break;
        }
        else
        {
            failure = failure + 1;
            if(failure > 20)
            {
                break;
            }
        }
    }
}

void * can_send_loop(int sock0, int sock_, int send_canid)
{
    fcntl(sock_, F_SETFL, fcntl(sock_, F_GETFL, 0) | O_NONBLOCK);
    int nr, i;
    time_t t;
    srand((unsigned) time(&t));
    unsigned char send_byte, data[8];
    while(true)
    {
        send_byte = rand() % 256;
        memset(data, send_byte, sizeof(data));
        nr = can_send(sock0, send_canid, data, sizeof(data));
        if(nr < 0)
        {
            continue;
        }
        printf("can_send [8 byte of '%02x'] canid: %03x.\n\n", send_byte, send_canid);
        i = 0;
        while(i < 8)
        {
            sent_data[i] = data[i];
            i = i + 1;
        }
        can_aux_loop(sock_);
    }
    can_close(sock0);
    can_close(sock_);
}

void * can_recv_loop(int sock1)
{
    int nr, canid;
    unsigned char data[8];
    while(true)
    {
        nr = can_recv(sock1, data, sizeof(data), &canid);
        if(nr > 0)
        {
            printf("can_recv canid: %03x.\n", canid);
            show_hex(data, nr);
        }
    }
    can_close(sock1);
}

int main(int argc, char ** argv)
{
    char * can_device = argv[2];
    int send_canid = 0x20C, recv_canid = 0x000, baudrate = 1000000, fd = 0, dbaudrate = 4000000;
    can_iface_up(can_device, baudrate, fd, dbaudrate);
    if(strcmp(argv[1], "send") == 0)
    {
        int sock0 = can_open(can_device, send_canid, fd), sock_ = can_open(can_device, send_canid, fd);
        if(sock0 < 0)
        {
            printf("can_app: open can_device [%s] failed.\n", can_device);
            return -1;
        }
        can_send_loop(sock0, sock_, send_canid);
    }
    else if(strcmp(argv[1], "recv") == 0)
    {
        int sock1 = can_open(can_device, recv_canid, fd);
        if(sock1 < 0)
        {
            printf("can_app: open can_device [%s] failed.\n", can_device);
            return -1;
        }
        can_recv_loop(sock1);
    }
    return 0;
}