SerialManager.cpp

#include "SerialManager.h"
#include <QDebug>

SerialManager::SerialManager(QObject *parent)
    : QObject(parent), m_serial(new QSerialPort(this))
{
    connect(m_serial, &QSerialPort::readyRead, this, &SerialManager::onReadyRead);
    connect(m_serial, &QSerialPort::errorOccurred, this, &SerialManager::onError);
}

SerialManager::~SerialManager() {
    close();
}

QList<QSerialPortInfo> SerialManager::availablePorts() const {
    return QSerialPortInfo::availablePorts();
}

bool SerialManager::open(const QString &portName, qint32 baudRate) {
    if (m_serial->isOpen()) close();

    m_serial->setPortName(portName);
    m_serial->setBaudRate(baudRate);
    m_serial->setDataBits(QSerialPort::Data8);
    m_serial->setParity(QSerialPort::NoParity);
    m_serial->setStopBits(QSerialPort::OneStop);
    m_serial->setFlowControl(QSerialPort::NoFlowControl);

    if (m_serial->open(QIODevice::ReadWrite)) {
        m_buffer.clear();
        m_readPos = 0;
        emit portOpened(portName);
        return true;
    }
    emit errorOccurred(m_serial->errorString());
    return false;
}

void SerialManager::close() {
    if (m_serial->isOpen()) {
        m_serial->close();
        m_buffer.clear();
        m_readPos = 0;
        emit portClosed();
    }
}

bool SerialManager::isOpen() const {
    return m_serial->isOpen();
}

// ===== 帧组装 =====

QByteArray SerialManager::buildFrame(uint8_t channel, const QByteArray &payload) {
    QByteArray frame;
    frame.reserve(FRAME_HEADER_SIZE + payload.size());
    frame.append(static_cast<char>(HEADER_DOWN));
    frame.append(static_cast<char>(channel));
    frame.append(static_cast<char>(payload.size() & 0xFF));
    frame.append(static_cast<char>((payload.size() >> 8) & 0xFF));
    frame.append(payload);
    return frame;
}

// ===== 下行发送 =====

void SerialManager::sendCanFrame(uint32_t id, bool extended, bool rtr, const QByteArray &data) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(extended ? 1 : 0));
    p.append(static_cast<char>(rtr ? 1 : 0));
    p.append(static_cast<char>(id & 0xFF));
    p.append(static_cast<char>((id >> 8) & 0xFF));
    p.append(static_cast<char>((id >> 16) & 0xFF));
    p.append(static_cast<char>((id >> 24) & 0xFF));
    p.append(static_cast<char>(data.size() & 0xFF));
    p.append(data.left(8));
    m_serial->write(buildFrame(CH_CAN, p));
}

void SerialManager::sendUsartData(uint8_t channel, const QByteArray &data) {
    if (!m_serial->isOpen()) return;
    m_serial->write(buildFrame(channel, data));
}

void SerialManager::sendSpiRequest(const QByteArray &writeData, uint8_t readLen) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0)); // NSS reserved
    p.append(static_cast<char>(writeData.size()));
    p.append(static_cast<char>(readLen));
    p.append(writeData);
    m_serial->write(buildFrame(CH_SPI1, p));
}

void SerialManager::sendI2cWrite(uint8_t channel, uint8_t devAddr, const QByteArray &data) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x01));
    p.append(static_cast<char>(devAddr));
    p.append(static_cast<char>(data.size()));
    p.append(data);
    m_serial->write(buildFrame(channel, p));
}

void SerialManager::sendI2cRead(uint8_t channel, uint8_t devAddr, uint8_t readLen) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x02));
    p.append(static_cast<char>(devAddr));
    p.append(static_cast<char>(readLen));
    m_serial->write(buildFrame(channel, p));
}

void SerialManager::sendI2cMemWrite(uint8_t channel, uint8_t devAddr, uint32_t memAddr,
                                     uint8_t memAddrLen, const QByteArray &data) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x03));
    p.append(static_cast<char>(devAddr));
    p.append(static_cast<char>(memAddrLen));
    for (uint8_t i = 0; i < memAddrLen; i++)
        p.append(static_cast<char>((memAddr >> (8 * i)) & 0xFF));
    p.append(static_cast<char>(data.size()));
    p.append(data);
    m_serial->write(buildFrame(channel, p));
}

void SerialManager::sendI2cMemRead(uint8_t channel, uint8_t devAddr, uint32_t memAddr,
                                    uint8_t memAddrLen, uint8_t readLen) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x04));
    p.append(static_cast<char>(devAddr));
    p.append(static_cast<char>(memAddrLen));
    for (uint8_t i = 0; i < memAddrLen; i++)
        p.append(static_cast<char>((memAddr >> (8 * i)) & 0xFF));
    p.append(static_cast<char>(readLen));
    m_serial->write(buildFrame(channel, p));
}

void SerialManager::sendAdcStart() {
    if (!m_serial->isOpen()) return;
    m_serial->write(buildFrame(CH_ADC, QByteArray(1, static_cast<char>(0x01))));
}

void SerialManager::sendAdcStop() {
    if (!m_serial->isOpen()) return;
    m_serial->write(buildFrame(CH_ADC, QByteArray(1, static_cast<char>(0x02))));
}

void SerialManager::sendAdcSetRate(uint16_t psc, uint16_t per) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x03));
    p.append(static_cast<char>(psc & 0xFF));
    p.append(static_cast<char>((psc >> 8) & 0xFF));
    p.append(static_cast<char>(per & 0xFF));
    p.append(static_cast<char>((per >> 8) & 0xFF));
    m_serial->write(buildFrame(CH_ADC, p));
}

void SerialManager::sendSetUsart1Baud(uint32_t baud) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x01));
    p.append(static_cast<char>(baud & 0xFF));
    p.append(static_cast<char>((baud >> 8) & 0xFF));
    p.append(static_cast<char>((baud >> 16) & 0xFF));
    p.append(static_cast<char>((baud >> 24) & 0xFF));
    m_serial->write(buildFrame(CH_SYS_CMD, p));
}

void SerialManager::sendSetUsart2Baud(uint32_t baud) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x02));
    p.append(static_cast<char>(baud & 0xFF));
    p.append(static_cast<char>((baud >> 8) & 0xFF));
    p.append(static_cast<char>((baud >> 16) & 0xFF));
    p.append(static_cast<char>((baud >> 24) & 0xFF));
    m_serial->write(buildFrame(CH_SYS_CMD, p));
}

void SerialManager::sendSetCanBaud(uint32_t baud) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x03));
    p.append(static_cast<char>(baud & 0xFF));
    p.append(static_cast<char>((baud >> 8) & 0xFF));
    p.append(static_cast<char>((baud >> 16) & 0xFF));
    p.append(static_cast<char>((baud >> 24) & 0xFF));
    m_serial->write(buildFrame(CH_SYS_CMD, p));
}

void SerialManager::sendSetI2c1Speed(uint32_t speed) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x04));
    p.append(static_cast<char>(speed & 0xFF));
    p.append(static_cast<char>((speed >> 8) & 0xFF));
    p.append(static_cast<char>((speed >> 16) & 0xFF));
    p.append(static_cast<char>((speed >> 24) & 0xFF));
    m_serial->write(buildFrame(CH_SYS_CMD, p));
}

void SerialManager::sendSetI2c2Speed(uint32_t speed) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x05));
    p.append(static_cast<char>(speed & 0xFF));
    p.append(static_cast<char>((speed >> 8) & 0xFF));
    p.append(static_cast<char>((speed >> 16) & 0xFF));
    p.append(static_cast<char>((speed >> 24) & 0xFF));
    m_serial->write(buildFrame(CH_SYS_CMD, p));
}

void SerialManager::sendSetSpi1Presc(uint8_t presc) {
    if (!m_serial->isOpen()) return;
    QByteArray p;
    p.append(static_cast<char>(0x06));
    p.append(static_cast<char>(presc));
    m_serial->write(buildFrame(CH_SYS_CMD, p));
}

void SerialManager::sendQueryInfo() {
    if (!m_serial->isOpen()) return;
    m_serial->write(buildFrame(CH_SYS_CMD, QByteArray(1, static_cast<char>(0x10))));
}

// ===== 上行接收 =====

void SerialManager::onReadyRead() {
    QByteArray data = m_serial->readAll();
    m_buffer.append(data);
    processBuffer();
}

void SerialManager::onError(QSerialPort::SerialPortError error) {
    if (error == QSerialPort::NoError || error == QSerialPort::NotOpenError) {
        return;
    }
    emit errorOccurred(m_serial->errorString());
}

void SerialManager::compactBuffer() {
    if (m_readPos > COMPACT_THRESHOLD) {
        m_buffer = m_buffer.mid(m_readPos);
        m_readPos = 0;
    }
}

void SerialManager::processBuffer() {
    while (m_buffer.size() - m_readPos >= FRAME_HEADER_SIZE) {
        if (static_cast<uint8_t>(m_buffer[m_readPos]) != HEADER_UP) {
            m_readPos++;
            continue;
        }

        uint8_t channel = static_cast<uint8_t>(m_buffer[m_readPos + 1]);
        uint16_t payloadLen = static_cast<uint8_t>(m_buffer[m_readPos + 2])
                            | (static_cast<uint8_t>(m_buffer[m_readPos + 3]) << 8);

        if (m_buffer.size() - m_readPos < FRAME_HEADER_SIZE + payloadLen) {
            break; // 数据不完整，等待更多
        }

        QByteArray payload = m_buffer.mid(m_readPos + FRAME_HEADER_SIZE, payloadLen);

        // 非 ADC 通道才发送原始数据到调试区
        if (channel != CH_ADC) {
            QByteArray rawFrame = m_buffer.mid(m_readPos, FRAME_HEADER_SIZE + payloadLen);
            emit rawDataReceived(rawFrame);
        }

        m_readPos += FRAME_HEADER_SIZE + payloadLen;

        handleUplink(channel, payload);
    }

    compactBuffer();
}

void SerialManager::handleUplink(uint8_t channel, const QByteArray &payload) {
    switch (channel) {
    case CH_CAN: {
        if (payload.size() < 7) return;
        bool extended = static_cast<uint8_t>(payload[0]) != 0;
        bool rtr = static_cast<uint8_t>(payload[1]) != 0;
        uint32_t id = static_cast<uint8_t>(payload[2])
                    | (static_cast<uint8_t>(payload[3]) << 8)
                    | (static_cast<uint8_t>(payload[4]) << 16)
                    | (static_cast<uint8_t>(payload[5]) << 24);
        uint8_t dlc = static_cast<uint8_t>(payload[6]);
        QByteArray data = payload.mid(7, dlc);
        emit canFrameReceived(id, extended, rtr, data);
        break;
    }
    case CH_USART1:
    case CH_USART2:
        emit usartDataReceived(channel, payload);
        break;
    case CH_SPI1: {
        if (payload.size() < 2) return;
        uint8_t result = static_cast<uint8_t>(payload[0]);
        uint8_t readLen = static_cast<uint8_t>(payload[1]);
        QByteArray readData = payload.mid(2, readLen);
        emit spiResponseReceived(result, readData);
        break;
    }
    case CH_I2C1:
    case CH_I2C2: {
        if (payload.size() < 2) return;
        uint8_t result = static_cast<uint8_t>(payload[0]);
        uint8_t readLen = static_cast<uint8_t>(payload[1]);
        QByteArray readData = payload.mid(2, readLen);
        emit i2cResponseReceived(channel, result, readData);
        break;
    }
    case CH_ADC: {
        if (payload.size() < 2) return;
        uint16_t seqNum = static_cast<uint8_t>(payload[0])
                        | (static_cast<uint8_t>(payload[1]) << 8);
        emit adcDataReceived(seqNum, payload.mid(2));
        break;
    }
    case CH_SYS_STS: {
        if (payload.size() < 2) return;
        uint8_t cmd = static_cast<uint8_t>(payload[0]);
        uint8_t result = static_cast<uint8_t>(payload[1]);
        if (cmd == 0x10 && payload.size() >= 5) {
            emit deviceInfoReceived(static_cast<uint8_t>(payload[2]),
                                    static_cast<uint8_t>(payload[3]),
                                    static_cast<uint8_t>(payload[4]));
        } else {
            emit sysCmdResult(cmd, result);
        }
        break;
    }
    default:
        break;
    }
}