EC100工业计算机工控机双N设计-开发指南

软件

版本

硬件接口

设备文件

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <fcntl.h>

#include <termios.h>

#include <errno.h>

#include <sys/select.h>

#define BUFFER_SIZE 256

typedef struct {

    int baud_rate;      // 波特率

    int data_bits;      // 数据位 (5,6,7,8)

    int stop_bits;      // 停止位 (1,2)

    char parity;        // 校验位 (N:无校验, O:奇校验, E:偶校验)

} SerialConfig;

int set_serial_attr(int fd, SerialConfig *config)

{

    struct termios tty;

    if (tcgetattr(fd, &tty) < 0) {

        perror("tcgetattr");

        return -1;

    }

    // 设置波特率

    speed_t speed;

    switch (config->baud_rate) {

        case 9600:   speed = B9600; break;

        case 19200:  speed = B19200; break;

        case 38400:  speed = B38400; break;

        case 57600:  speed = B57600; break;

        case 115200: speed = B115200; break;

        default:

            fprintf(stderr, "Unsupported baud rate, using 115200\n");

            speed = B115200;

    }

    cfsetispeed(&tty, speed);

    cfsetospeed(&tty, speed);

    // 设置数据位

    tty.c_cflag &= ~CSIZE;

    switch (config->data_bits) {

        case 5: tty.c_cflag |= CS5; break;

        case 6: tty.c_cflag |= CS6; break;

        case 7: tty.c_cflag |= CS7; break;

        case 8: tty.c_cflag |= CS8; break;

        default:

            fprintf(stderr, "Unsupported data bits, using 8\n");

            tty.c_cflag |= CS8;

    }

    // 设置停止位

    if (config->stop_bits == 2) {

        tty.c_cflag |= CSTOPB;

    } else {

        tty.c_cflag &= ~CSTOPB;

    }

    // 设置校验位

    switch (config->parity) {

        case 'N': case 'n':

            tty.c_cflag &= ~PARENB;  // 无校验

            break;

        case 'O': case 'o':

            tty.c_cflag |= PARENB;   // 奇校验

            tty.c_cflag |= PARODD;

            break;

        case 'E': case 'e':

            tty.c_cflag |= PARENB;   // 偶校验

            tty.c_cflag &= ~PARODD;

            break;

        default:

            fprintf(stderr, "Unsupported parity, using N\n");

            tty.c_cflag &= ~PARENB;

    }

    // 其他设置

    tty.c_cflag |= (CLOCAL | CREAD);    // 启用接收和本地模式

    tty.c_cflag &= ~CRTSCTS;            // 无硬件流控

    tty.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // 原始输入模式

    tty.c_oflag &= ~OPOST;              // 原始输出模式

    tty.c_cc[VMIN] = 1;                 // 最小读取字符数

    tty.c_cc[VTIME] = 0;                // 读取超时时间（单位：0.1秒）

    if (tcsetattr(fd, TCSANOW, &tty) < 0) {

        perror("tcsetattr");

        return -1;

    }

    return 0;

}

int main(int argc, char *argv[])

{

    int fd;

    char *portname;

    if (argc < 2) {

        fprintf(stderr, "Usage: %s <serial_port>\n", argv[0]);

        exit(EXIT_FAILURE);

    }

    portname = argv[1];

    // 配置串口参数

    SerialConfig config = {

        .baud_rate = 115200,  // 波特率

        .data_bits = 8,       // 数据位

        .stop_bits = 1,       // 停止位

        .parity = 'N'         // 校验位 (N:无校验, O:奇校验, E:偶校验)

    };

    fd = open(portname, O_RDWR | O_NOCTTY | O_NONBLOCK);

    if (fd < 0) {

        perror("open");

        exit(EXIT_FAILURE);

    }

    if (set_serial_attr(fd, &config)) {

        close(fd);

        exit(EXIT_FAILURE);

    }

    printf("Serial port echo test running on %s\n", portname);

    printf("Configuration: %d baud, %d data bits, %d stop bit, %c parity\n",

           config.baud_rate, config.data_bits, config.stop_bits, config.parity);

    printf("Press Ctrl+C to exit.\n");

    fd_set readfds;

    char buffer[BUFFER_SIZE];

    int n;

    while (1) {

        FD_ZERO(&readfds);

        FD_SET(fd, &readfds);

        // 无限等待数据到达（移除了超时设置）

        if (select(fd + 1, &readfds, NULL, NULL, NULL) < 0) {

            perror("select");

            break;

        }

        if (FD_ISSET(fd, &readfds)) {

            n = read(fd, buffer, BUFFER_SIZE - 1);

            if (n > 0) {

                buffer[n] = '\0';

                printf("Received %d bytes: %s\n", n, buffer);

                // 回显数据

                write(fd, buffer, n);

            } else if (n < 0) {

                if (errno != EAGAIN && errno != EWOULDBLOCK) {

                    perror("read");

                    break;

                }

            }

        }

    }

    close(fd);

    return 0;

}

硬件接口

IO索引

IO编号

chip组

备注

#!/bin/bash

# 检查是否传入了GPIO索引

if [ -z "$1" ]; then

    echo "Usage: $0 <gpio_number>"

    exit 1

fi

GPIO=$1

GPIO_PATH="/sys/class/gpio/gpio$GPIO"

EXPORT_PATH="/sys/class/gpio/export"

# 判断GPIO是否已经导出

if [ ! -d "$GPIO_PATH" ]; then

    echo "Exporting GPIO $GPIO..."

    echo "$GPIO" > "$EXPORT_PATH"

    if [ $? -ne 0 ]; then

        echo "Failed to export GPIO $GPIO. Check permissions or if it's in use."

        exit 1

    fi

else

    echo "GPIO $GPIO is already exported."

fi

# 设置GPIO方向为输出

echo "out" > "$GPIO_PATH/direction"

# 设置初始值为低电平

echo 0 > "$GPIO_PATH/value"

echo "Toggling GPIO $GPIO every 1 second. Press Ctrl+C to stop."

# 开始循环翻转

while true; do

    echo 1 > "$GPIO_PATH/value"

    sleep 1

    echo 0 > "$GPIO_PATH/value"

    sleep 1

done

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <linux/gpio.h>

#include <errno.h>

#define GPIO_CHIP "/dev/gpiochip1"  // 使用gpiochip1

#define GPIO_LINE 38%32             // 要控制的GPIO在chip1上的偏移

#define PERIOD_US 500000            // 周期时间(微秒)

int main() {

    struct gpiohandle_request req;

    struct gpiohandle_data data;

    int fd, ret;

    // 打开GPIO字符设备

    fd = open(GPIO_CHIP, O_RDWR);

    if (fd < 0) {

        perror("无法打开GPIO设备");

        return EXIT_FAILURE;

    }

    // 设置GPIO请求

    memset(&req, 0, sizeof(req));

    req.lineoffsets[0] = GPIO_LINE;  // GPIO线号

    req.flags = GPIOHANDLE_REQUEST_OUTPUT;  // 设置为输出模式

    req.default_values[0] = 0;       // 初始值设为低电平

    strcpy(req.consumer_label, "gpio-toggle");  // 消费者标签

    req.lines = 1;                   // 要控制的GPIO线数量

    // 请求GPIO控制

    ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &req);

    if (ret < 0) {

        perror("无法获取GPIO控制权");

        close(fd);

        return EXIT_FAILURE;

    }

    // 关闭GPIO字符设备(我们已经获得了线句柄)

    close(fd);

    printf("正在控制GPIO chip1 line %d，周期为%.1f秒...\n", 

           GPIO_LINE, PERIOD_US/1000000.0);

    // 周期切换GPIO电平

    while (1) {

        data.values[0] = 1;  // 高电平

        ret = ioctl(req.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &data);

        if (ret < 0) {

            perror("设置GPIO高电平失败");

            break;

        }

        usleep(PERIOD_US/2);

        data.values[0] = 0;  // 低电平

        ret = ioctl(req.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &data);

        if (ret < 0) {

            perror("设置GPIO低电平失败");

            break;

        }

        usleep(PERIOD_US/2);

    }

    // 关闭GPIO线句柄

    close(req.fd);

    return EXIT_SUCCESS;

}

硬件接口

网络接口

#首先初始化 can0 与 can1，波特率选择 500k，使用 canfd，然后选择 can0 接受数据，can1 发送数据

ip link set can0 down

ip link set can1 down

ip link set can0 type can bitrate 500000 sample-point 0.8 dbitrate 2000000 sample-point 0.8 fd on

ip link set can1 type can bitrate 500000 sample-point 0.8 dbitrate 2000000 sample-point 0.8 fd on

ip link set can0 up

ip link set can1 up

echo 4096 > /sys/class/net/can0/tx_queue_len

echo 4096 > /sys/class/net/can1/tx_queue_len

candump can0 &

cansend can1 001234EF#00.11.22.33.44.55.66.77

#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 <fcntl.h>

#include <errno.h>

#include <stdint.h>  

#define CAN_INTERFACE "can0"

#define BITRATE 500000

#define DATA_BITRATE 2000000

#define SAMPLE_POINT 0.8

#define TX_QUEUE_LEN 4096

// 配置CAN FD接口

int setup_can_fd_interface(const char *ifname) {

    char cmd[512];

    FILE *fp;

    // 关闭接口

    snprintf(cmd, sizeof(cmd), "ip link set %s down", ifname);

    system(cmd);

    // 设置CAN FD参数

    snprintf(cmd, sizeof(cmd), 

             "ip link set %s type can bitrate %d sample-point %.1f "

             "dbitrate %d dsample-point %.1f fd on", 

             ifname, BITRATE, SAMPLE_POINT, DATA_BITRATE, SAMPLE_POINT);

    if (system(cmd) != 0) {

        fprintf(stderr, "Failed to configure CAN FD interface %s\n", ifname);

        return -1;

    }

    // 设置TX队列长度

    snprintf(cmd, sizeof(cmd), "/sys/class/net/%s/tx_queue_len", ifname);

    fp = fopen(cmd, "w");

    if (fp == NULL) {

        perror("Failed to open tx_queue_len");

        return -1;

    }

    fprintf(fp, "%d", TX_QUEUE_LEN);

    fclose(fp);

    // 启用接口

    snprintf(cmd, sizeof(cmd), "ip link set %s up", ifname);

    if (system(cmd) != 0) {

        fprintf(stderr, "Failed to bring up CAN interface %s\n", ifname);

        return -1;

    }

    printf("CAN FD interface %s configured:\n", ifname);

    printf("  Bitrate: %d\n", BITRATE);

    printf("  Data bitrate: %d\n", DATA_BITRATE);

    printf("  Sample point: %.1f\n", SAMPLE_POINT);

    printf("  TX queue length: %d\n", TX_QUEUE_LEN);

    return 0;

}

// 发送CAN FD帧

int send_can_fd_frame(int sock, uint32_t can_id, uint8_t *data, uint8_t len) {

    struct canfd_frame frame;

    memset(&frame, 0, sizeof(frame));

    frame.can_id = can_id;

    frame.len = len;

    memcpy(frame.data, data, len);

    frame.flags = CANFD_BRS; // 启用比特率切换

    int nbytes = write(sock, &frame, sizeof(frame));

    if (nbytes != sizeof(frame)) {

        perror("CAN FD frame send failed");

        return -1;

    }

    printf("Sent CAN FD frame: ID 0x%08X, data: ", can_id);

    for (int i = 0; i < len; i++) {

        printf("%02X ", data[i]);

    }

    printf("\n");

    return 0;

}

// 接收CAN帧（支持经典CAN和CAN FD）

void receive_can_messages(int sock) {

    struct canfd_frame frame;

    int nbytes;

    printf("Starting to receive CAN messages (Ctrl+C to stop)...\n");

    while (1) {

        nbytes = read(sock, &frame, sizeof(frame));

        if (nbytes < 0) {

            if (errno == EAGAIN || errno == EWOULDBLOCK) {

                continue;

            }

            perror("CAN frame read failed");

            break;

        }

        if (nbytes == CAN_MTU) {

            // 经典CAN帧

            printf("Received CAN frame: ID 0x%08X, DLC %d, data: ", 

                   frame.can_id, frame.len);

        } else if (nbytes == CANFD_MTU) {

            // CAN FD帧

            printf("Received CAN FD frame: ID 0x%08X, DLC %d, data: ", 

                   frame.can_id, frame.len);

        } else {

            printf("Received frame with unexpected size %d\n", nbytes);

            continue;

        }

        for (int i = 0; i < frame.len; i++) {

            printf("%02X ", frame.data[i]);

        }

        printf("\n");

    }

}

int main() {

    int s;

    struct sockaddr_can addr;

    struct ifreq ifr;

    // 配置CAN FD接口

    if (setup_can_fd_interface(CAN_INTERFACE) < 0) {

        return 1;

    }

    // 创建socket

    if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {

        perror("Socket creation failed");

        return 1;

    }

    // 启用CAN FD支持

    int enable_canfd = 1;

    if (setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, 

                  &enable_canfd, sizeof(enable_canfd)) < 0) {

        perror("Failed to enable CAN FD support");

        close(s);

        return 1;

    }

    // 指定CAN接口

    strcpy(ifr.ifr_name, CAN_INTERFACE);

    if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {

        perror("IOCTL SIOCGIFINDEX failed");

        close(s);

        return 1;

    }

    // 绑定socket到CAN接口

    addr.can_family = AF_CAN;

    addr.can_ifindex = ifr.ifr_ifindex;

    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {

        perror("Bind failed");

        close(s);

        return 1;

    }

    // 发送测试CAN FD帧 (ID 0x001234EF, 数据 00.11.22.33.44.55.66.77)

    uint8_t test_data[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};

    if (send_can_fd_frame(s, 0x001234EF, test_data, sizeof(test_data)) < 0) {

        close(s);

        return 1;

    }

    // 开始接收CAN消息

    receive_can_messages(s);

    close(s);

    return 0;

}