1
#pragma once
2

3
#include <iostream>
4
#include <string>
5
#include <vector>
6
#include <cstring>
7
#include <chrono>
8
#include <thread>
9
#include <fcntl.h>
10
#include <unistd.h>
11
#include <termios.h>
12

13
class SerialPort {
14
public:
15
    static constexpr uint8_t FRAME_HEADER = 0xA5;
16
    static constexpr uint8_t FRAME_TAIL   = 0x5A;
17

18
    // 公开 CRC8 算法供发送与接收端统一复用
19
    static uint8_t calculateCRC8(const uint8_t* data, size_t length) {
20
        uint8_t crc = 0x00;
21
        for (size_t i = 0; i < length; ++i) {
22
            crc ^= data[i];
23
            for (int j = 0; j < 8; ++j) {
24
                if (crc & 0x80) crc = (crc << 1) ^ 0x31;
25
                else crc <<= 1;
26
            }
27
        }
28
        return crc;
29
    }
30

31
    SerialPort() : fd_(-1) {}
32

33
    // 析构函数：利用 RAII 确保退出时安全关闭文件描述符
34
    ~SerialPort() {
35
        closePort();
36
    }
37

38
    // 禁止拷贝，防止文件描述符被二次关闭
39
    SerialPort(const SerialPort&) = delete;
40
    SerialPort& operator=(const SerialPort&) = delete;
41

42
    // 允许移动
43
    SerialPort(SerialPort&& other) noexcept : fd_(other.fd_) {
44
        other.fd_ = -1;
45
    }
46

47
    // 打开并配置串口
48
    bool openPort(const std::string& device_path, int baudrate = 115200) {
49
        closePort();
50

51
        // 以读写模式、非控制终端模式打开
52
        fd_ = open(device_path.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
53
        if (fd_ < 0) {
54
            std::cerr << "[SerialPort] 无法打开串口设备: " << device_path
55
                      << " (" << strerror(errno) << ")" << std::endl;
56
            return false;
57
        }
58

59
        // 恢复为阻塞/超时读取模式
60
        fcntl(fd_, F_SETFL, 0);
61

62
        struct termios tty;
63
        if (tcgetattr(fd_, &tty) != 0) {
64
            std::cerr << "[SerialPort] 获取 termios 配置失败！" << std::endl;
65
            closePort();
66
            return false;
67
        }
68

69
        // 设置为 Raw Mode
70
        cfmakeraw(&tty);
71

72
        // 设置波特率
73
        speed_t speed = getBaudrateConstant(baudrate);
74
        cfsetispeed(&tty, speed);
75
        cfsetospeed(&tty, speed);
76

77
        // 8N1 配置
78
        tty.c_cflag |= (CLOCAL | CREAD);
79
        tty.c_cflag &= ~CSIZE;
80
        tty.c_cflag |= CS8;
81
        tty.c_cflag &= ~PARENB;
82
        tty.c_cflag &= ~CSTOPB;
83
        tty.c_cflag &= ~CRTSCTS;
84

85
        // 设置读取超时 (100ms 超时)
86
        tty.c_cc[VMIN]  = 0;
87
        tty.c_cc[VTIME] = 1;
88

89
        tcflush(fd_, TCIOFLUSH);
90
        if (tcsetattr(fd_, TCSANOW, &tty) != 0) {
91
            std::cerr << "[SerialPort] 应用 termios 配置失败！" << std::endl;
92
            closePort();
93
            return false;
94
        }
95

96
        std::cout << "[SerialPort] 串口 " << device_path << " 打开成功，波特率: " << baudrate << std::endl;
97
        return true;
98
    }
99

100
    bool isOpened() const {
101
        return fd_ >= 0;
102
    }
103

104
    void closePort() {
105
        if (fd_ >= 0) {
106
            close(fd_);
107
            fd_ = -1;
108
        }
109
    }
110

111
    // 核心接口：按二进制帧格式打包并发送数据载荷
112
    bool sendPacket(uint8_t cmd_id, const void* payload, uint8_t payload_len) {
113
        if (fd_ < 0 || payload == nullptr || payload_len == 0) return false;
114

115
        // 帧结构: [Header:1] [Len:1] [Cmd:1] [Payload:N] [CRC:1] [Tail:1]
116
        size_t total_len = 1 + 1 + 1 + payload_len + 1 + 1;
117
        std::vector<uint8_t> tx_buffer(total_len);
118

119
        tx_buffer[0] = FRAME_HEADER;
120
        tx_buffer[1] = payload_len;
121
        tx_buffer[2] = cmd_id;
122

123
        // 拷贝 Payload
124
        std::memcpy(&tx_buffer[3], payload, payload_len);
125

126
        // 计算校验值 (对 Header+Len+Cmd+Payload 计算)
127
        uint8_t crc = calculateCRC8(tx_buffer.data(), 3 + payload_len);
128
        tx_buffer[3 + payload_len] = crc;
129

130
        tx_buffer[3 + payload_len + 1] = FRAME_TAIL;
131

132
        // 写入物理串口设备
133
        ssize_t bytes_written = write(fd_, tx_buffer.data(), tx_buffer.size());
134
        return bytes_written == static_cast<ssize_t>(tx_buffer.size());
135
    }
136

137
    // 单次读取原始字节 (供流式状态机按字节循环消费)
138
    int readBytes(uint8_t* buffer, size_t max_len) {
139
        if (fd_ < 0) return -1;
140
        return read(fd_, buffer, max_len);
141
    }
142

143
    // 循环读取直到读满指定字节数，或达到超时 (防范流式传输分包断包)
144
    int readExact(uint8_t* buffer, size_t target_len, int timeout_ms = 100) {
145
        if (fd_ < 0) return -1;
146
        size_t total_read = 0;
147
        auto start_time = std::chrono::steady_clock::now();
148

149
        while (total_read < target_len) {
150
            ssize_t n = read(fd_, buffer + total_read, target_len - total_read);
151
            if (n > 0) {
152
                total_read += n;
153
            }
154
            auto now = std::chrono::steady_clock::now();
155
            if (std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time).count() > timeout_ms) {
156
                break; // 超时退出
157
            }
158
            std::this_thread::sleep_for(std::chrono::microseconds(500));
159
        }
160
        return static_cast<int>(total_read);
161
    }
162

163
private:
164
    int fd_;
165

166
    static speed_t getBaudrateConstant(int baudrate) {
167
        switch (baudrate) {
168
            case 9600:   return B9600;
169
            case 19200:  return B19200;
170
            case 38400:  return B38400;
171
            case 57600:  return B57600;
172
            case 115200: return B115200;
173
            case 230400: return B230400;
174
            case 460800: return B460800;
175
            case 921600: return B921600;
176
            default:     return B115200;
177
        }
178
    }
179
};