MainWindow.cpp

#include "MainWindow.h"
#include <QApplication>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QGroupBox>
#include <QGridLayout>
#include <QMessageBox>
#include <QScrollBar>
#include <QSplitter>
#include <QMenuBar>
#include <QAction>
#include <QTabWidget>
#include <QFormLayout>
#include <QDoubleSpinBox>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent), m_serialManager(new SerialManager(this)), m_adcRunning(false)
{
    setupUi();
    applyTheme();

    // 串口信号
    connect(m_serialManager, &SerialManager::portOpened, this, &MainWindow::onPortOpened);
    connect(m_serialManager, &SerialManager::portClosed, this, &MainWindow::onPortClosed);
    connect(m_serialManager, &SerialManager::errorOccurred, this, &MainWindow::onError);
    connect(m_serialManager, &SerialManager::rawDataReceived, this, &MainWindow::onRawDataReceived);

    // 上行信号
    connect(m_serialManager, &SerialManager::canFrameReceived, this, &MainWindow::onCanFrameReceived);
    connect(m_serialManager, &SerialManager::usartDataReceived, this, &MainWindow::onUsartDataReceived);
    connect(m_serialManager, &SerialManager::spiResponseReceived, this, &MainWindow::onSpiResponseReceived);
    connect(m_serialManager, &SerialManager::i2cResponseReceived, this, &MainWindow::onI2cResponseReceived);
    connect(m_serialManager, &SerialManager::adcDataReceived, this, &MainWindow::onAdcDataReceived);
    connect(m_serialManager, &SerialManager::deviceInfoReceived, this, &MainWindow::onDeviceInfoReceived);
    connect(m_serialManager, &SerialManager::sysCmdResult, this, &MainWindow::onSysCmdResult);

    // UI 节流定时器：每 50ms 批量刷新待显示文本
    m_flushTimer = new QTimer(this);
    m_flushTimer->setInterval(50);
    connect(m_flushTimer, &QTimer::timeout, this, &MainWindow::onFlushPendingText);
    m_flushTimer->start();

    onRefreshPorts();
    setWindowTitle("USB-CAN-Router Upper  v2");
    resize(1100, 750);

    // 帮助菜单
    auto *helpMenu = menuBar()->addMenu("帮助");
    auto *aboutQtAction = helpMenu->addAction("关于 Qt");
    auto *aboutAction = helpMenu->addAction("关于");
    connect(aboutQtAction, &QAction::triggered, this, &MainWindow::onAbout);
    connect(aboutAction, &QAction::triggered, this, [this]() {
        QMessageBox::about(this, "关于",
            "<h3>USB-CAN-Router Upper</h3>"
            "<p>多通道通信协议 v2 上位机</p>"
            "<hr>"
            "<p>本程序使用 <b>Qt 6</b> 开发，遵循 LGPL v3 许可。</p>"
            "<p>Qt 源代码：<a href='https://code.qt.io'>https://code.qt.io</a></p>"
            "<p>LGPL v3：<a href='https://www.gnu.org/licenses/lgpl-3.0.html'>"
            "https://www.gnu.org/licenses/lgpl-3.0.html</a></p>");
    });
}

void MainWindow::applyTheme() {
    QFont monoFont("Consolas", 10);
    for (auto *edit : {m_canRecvEdit, m_usart1RecvEdit, m_usart2RecvEdit,
                       m_spiRecvEdit, m_i2cRecvEdit, m_adcRecvEdit,
                       m_debugEdit, m_sysLogEdit}) {
        edit->setFont(monoFont);
    }
    for (auto *le : {m_canDataEdit, m_usart1SendEdit, m_usart2SendEdit,
                     m_spiWriteEdit, m_i2cMemAddrEdit, m_i2cDataEdit}) {
        le->setFont(monoFont);
    }
    m_canIdSpin->setFont(monoFont);
    m_i2cDevAddrSpin->setFont(monoFont);

    // 按钮样式
    m_connectBtn->setObjectName("connectBtn");
    m_refreshBtn->setObjectName("secondaryBtn");

    QString ss = QString(R"(
        QWidget { background-color: #1e1e2e; color: #cdd6f4; font-family: "Segoe UI","Microsoft YaHei UI",sans-serif; font-size: 13px; }
        QMainWindow { background-color: #1e1e2e; }

        QGroupBox { background-color: #181825; border: 1px solid #313244; border-radius: 8px; margin-top: 12px; padding: 16px 12px 10px 12px; font-weight: bold; font-size: 13px; color: #89b4fa; }
        QGroupBox::title { subcontrol-origin: margin; subcontrol-position: top left; padding: 2px 10px; background-color: #181825; border-radius: 4px; }

        QPushButton { background-color: #313244; color: #cdd6f4; border: 1px solid #45475a; border-radius: 6px; padding: 6px 16px; font-weight: bold; min-height: 20px; }
        QPushButton:hover { background-color: #45475a; border-color: #585b70; }
        QPushButton:pressed { background-color: #585b70; }
        QPushButton:disabled { background-color: #1e1e2e; color: #585b70; border-color: #313244; }

        QPushButton#connectBtn { background-color: #a6e3a1; color: #1e1e2e; border: none; font-weight: bold; padding: 6px 24px; }
        QPushButton#connectBtn:hover { background-color: #94e2d5; }
        QPushButton#secondaryBtn { background-color: #45475a; color: #cdd6f4; border: 1px solid #585b70; }
        QPushButton#secondaryBtn:hover { background-color: #585b70; }

        QComboBox { background-color: #313244; color: #cdd6f4; border: 1px solid #45475a; border-radius: 6px; padding: 5px 10px; min-height: 20px; }
        QComboBox:hover { border-color: #89b4fa; }
        QComboBox::drop-down { border: none; width: 24px; }
        QComboBox::down-arrow { image: url(:/resources/down-arrow.png); width: 10px; height: 6px; }
        QComboBox QAbstractItemView { background-color: #313244; color: #cdd6f4; border: 1px solid #45475a; border-radius: 6px; selection-background-color: #89b4fa; selection-color: #1e1e2e; padding: 4px; }

        QLineEdit { background-color: #313244; color: #cdd6f4; border: 1px solid #45475a; border-radius: 6px; padding: 6px 10px; min-height: 20px; }
        QLineEdit:hover { border-color: #89b4fa; }
        QLineEdit:focus { border-color: #89b4fa; background-color: #282838; }

        QTextEdit, QPlainTextEdit { background-color: #11111b; color: #a6adc8; border: 1px solid #313244; border-radius: 6px; padding: 6px; selection-background-color: #45475a; }

        QSpinBox { background-color: #313244; color: #89b4fa; border: 1px solid #45475a; border-radius: 6px; padding: 5px 10px; min-height: 20px; font-weight: bold; }
        QSpinBox:hover { border-color: #89b4fa; }
        QSpinBox::up-button, QSpinBox::down-button { background-color: #45475a; border: none; width: 20px; }
        QSpinBox::up-button:hover, QSpinBox::down-button:hover { background-color: #585b70; }
        QSpinBox::up-arrow { image: url(:/resources/up-arrow.png); width: 10px; height: 6px; }
        QSpinBox::down-arrow { image: url(:/resources/down-arrow.png); width: 10px; height: 6px; }

        QCheckBox { color: #cdd6f4; spacing: 6px; }
        QCheckBox::indicator { width: 18px; height: 18px; border-radius: 4px; border: 2px solid #45475a; background-color: #313244; }
        QCheckBox::indicator:hover { border-color: #89b4fa; }
        QCheckBox::indicator:checked { background-color: #89b4fa; border-color: #89b4fa; }
        QCheckBox::indicator:checked:hover { background-color: #74c7ec; }

        QLabel { color: #a6adc8; background-color: transparent; }

        QTabWidget::pane { border: 1px solid #313244; border-radius: 6px; background-color: #181825; }
        QTabBar::tab { background-color: #313244; color: #a6adc8; padding: 8px 18px; border-top-left-radius: 6px; border-top-right-radius: 6px; margin-right: 2px; }
        QTabBar::tab:selected { background-color: #181825; color: #89b4fa; font-weight: bold; }
        QTabBar::tab:hover { background-color: #45475a; }

        QSplitter::handle { background-color: #313244; width: 3px; border-radius: 1px; }
        QSplitter::handle:hover { background-color: #89b4fa; }

        QScrollBar:vertical { background-color: transparent; width: 10px; margin: 2px; }
        QScrollBar::handle:vertical { background-color: #45475a; border-radius: 4px; min-height: 20px; }
        QScrollBar::handle:vertical:hover { background-color: #585b70; }
        QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0; }
        QScrollBar::add-page:vertical, QScrollBar::sub-page:vertical { background: none; }
        QScrollBar:horizontal { background-color: transparent; height: 10px; margin: 2px; }
        QScrollBar::handle:horizontal { background-color: #45475a; border-radius: 4px; min-width: 20px; }
        QScrollBar::handle:horizontal:hover { background-color: #585b70; }
        QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal { width: 0; }
        QScrollBar::add-page:horizontal, QScrollBar::sub-page:horizontal { background: none; }

        QMenuBar { background-color: #181825; color: #cdd6f4; border-bottom: 1px solid #313244; padding: 2px; }
        QMenuBar::item:selected { background-color: #313244; border-radius: 4px; }
        QMenu { background-color: #1e1e2e; color: #cdd6f4; border: 1px solid #313244; border-radius: 6px; padding: 4px; }
        QMenu::item:selected { background-color: #313244; border-radius: 4px; }

        QMessageBox { background-color: #1e1e2e; }
        QMessageBox QLabel { color: #cdd6f4; }
        QToolTip { background-color: #313244; color: #cdd6f4; border: 1px solid #45475a; border-radius: 4px; padding: 4px; }
    )");

    qApp->setStyleSheet(ss);
    m_statusLabel->setStyleSheet("color: #6c7086; font-weight: bold; padding: 2px 8px;");
}

void MainWindow::setupUi() {
    auto *central = new QWidget(this);
    auto *mainLayout = new QVBoxLayout(central);
    mainLayout->setContentsMargins(12, 12, 12, 12);
    mainLayout->setSpacing(8);

    // ===== 连接区 =====
    auto *connGroup = new QGroupBox("  串口连接  ", central);
    auto *connLayout = new QHBoxLayout(connGroup);
    connLayout->setContentsMargins(16, 20, 16, 12);
    connLayout->setSpacing(8);

    m_portCombo = new QComboBox(connGroup);
    m_baudCombo = new QComboBox(connGroup);
    m_baudCombo->addItems({"115200", "9600", "19200", "38400", "57600", "230400", "460800", "921600"});
    m_baudCombo->setCurrentText("115200");
    m_refreshBtn = new QPushButton("刷新", connGroup);
    m_connectBtn = new QPushButton("连接", connGroup);
    m_statusLabel = new QLabel("未连接", connGroup);

    connLayout->addWidget(new QLabel("端口"));
    connLayout->addWidget(m_portCombo, 2);
    connLayout->addWidget(new QLabel("波特率"));
    connLayout->addWidget(m_baudCombo, 1);
    connLayout->addWidget(m_refreshBtn);
    connLayout->addWidget(m_connectBtn);
    connLayout->addStretch();
    connLayout->addWidget(m_statusLabel);

    connect(m_refreshBtn, &QPushButton::clicked, this, &MainWindow::onRefreshPorts);
    connect(m_connectBtn, &QPushButton::clicked, this, &MainWindow::onToggleConnection);

    // ===== 通道选项卡 =====
    auto *tabWidget = new QTabWidget(central);

    // --- CAN Tab ---
    {
        auto *w = new QWidget();
        auto *lay = new QVBoxLayout(w);
        lay->setSpacing(6);

        m_canRecvEdit = new QPlainTextEdit(w); m_canRecvEdit->setReadOnly(true); m_canRecvEdit->setMaximumBlockCount(5000);
        m_canHexRecvCheck = new QCheckBox("HEX 显示", w);
        auto *clearBtn = new QPushButton("清空", w);
        clearBtn->setObjectName("ghostBtn");
        auto *bar = new QHBoxLayout();
        bar->addWidget(new QLabel("接收"));
        bar->addStretch();
        bar->addWidget(m_canHexRecvCheck);
        bar->addWidget(clearBtn);
        connect(clearBtn, &QPushButton::clicked, this, &MainWindow::onClearCanRecv);

        m_canIdSpin = new QSpinBox(w);
        m_canIdSpin->setRange(0, 0x1FFFFFFF);
        m_canIdSpin->setDisplayIntegerBase(16);
        m_canIdSpin->setPrefix("0x");
        m_canExtCheck = new QCheckBox("扩展帧 (29位)", w);
        m_canRtrCheck = new QCheckBox("远程帧 (RTR)", w);
        m_canDataEdit = new QLineEdit(w);
        m_canDataEdit->setPlaceholderText("HEX 空格分隔 (如: 01 02 03 04) 最多8字节");
        auto *sendBtn = new QPushButton("发送 CAN 帧", w);
        sendBtn->setObjectName("primaryBtn");
        connect(sendBtn, &QPushButton::clicked, this, &MainWindow::onSendCan);

        auto *sendLayout = new QGridLayout();
        sendLayout->setSpacing(8);
        sendLayout->addWidget(new QLabel("ID"), 0, 0);
        sendLayout->addWidget(m_canIdSpin, 0, 1);
        sendLayout->addWidget(m_canExtCheck, 0, 2);
        sendLayout->addWidget(m_canRtrCheck, 0, 3);
        sendLayout->addWidget(new QLabel("数据"), 1, 0);
        sendLayout->addWidget(m_canDataEdit, 1, 1, 1, 2);
        sendLayout->addWidget(sendBtn, 1, 3);

        lay->addLayout(bar);
        lay->addWidget(m_canRecvEdit, 1);
        lay->addLayout(sendLayout);
        tabWidget->addTab(w, "CAN");
    }

    // --- USART1 Tab ---
    {
        auto *w = new QWidget();
        auto *lay = new QVBoxLayout(w);
        lay->setSpacing(6);

        m_usart1RecvEdit = new QPlainTextEdit(w); m_usart1RecvEdit->setReadOnly(true); m_usart1RecvEdit->setMaximumBlockCount(5000);
        m_usart1HexRecvCheck = new QCheckBox("HEX 显示", w);
        auto *clearBtn = new QPushButton("清空", w);
        clearBtn->setObjectName("ghostBtn");
        auto *bar = new QHBoxLayout();
        bar->addWidget(new QLabel("接收"));
        bar->addStretch();
        bar->addWidget(m_usart1HexRecvCheck);
        bar->addWidget(clearBtn);
        connect(clearBtn, &QPushButton::clicked, this, &MainWindow::onClearUsart1Recv);

        m_usart1SendEdit = new QLineEdit(w);
        m_usart1HexSendCheck = new QCheckBox("HEX 发送", w);
        auto *sendBtn = new QPushButton("发送", w);
        sendBtn->setObjectName("primaryBtn");
        connect(sendBtn, &QPushButton::clicked, this, &MainWindow::onSendUsart1);
        connect(m_usart1SendEdit, &QLineEdit::returnPressed, this, &MainWindow::onSendUsart1);

        auto *sendLayout = new QHBoxLayout();
        sendLayout->addWidget(new QLabel("发送"));
        sendLayout->addWidget(m_usart1SendEdit, 3);
        sendLayout->addWidget(m_usart1HexSendCheck);
        sendLayout->addWidget(sendBtn);

        lay->addLayout(bar);
        lay->addWidget(m_usart1RecvEdit, 1);
        lay->addLayout(sendLayout);
        tabWidget->addTab(w, "USART1");
    }

    // --- USART2 Tab ---
    {
        auto *w = new QWidget();
        auto *lay = new QVBoxLayout(w);
        lay->setSpacing(6);

        m_usart2RecvEdit = new QPlainTextEdit(w); m_usart2RecvEdit->setReadOnly(true); m_usart2RecvEdit->setMaximumBlockCount(5000);
        m_usart2HexRecvCheck = new QCheckBox("HEX 显示", w);
        auto *clearBtn = new QPushButton("清空", w);
        clearBtn->setObjectName("ghostBtn");
        auto *bar = new QHBoxLayout();
        bar->addWidget(new QLabel("接收"));
        bar->addStretch();
        bar->addWidget(m_usart2HexRecvCheck);
        bar->addWidget(clearBtn);
        connect(clearBtn, &QPushButton::clicked, this, &MainWindow::onClearUsart2Recv);

        m_usart2SendEdit = new QLineEdit(w);
        m_usart2HexSendCheck = new QCheckBox("HEX 发送", w);
        auto *sendBtn = new QPushButton("发送", w);
        sendBtn->setObjectName("primaryBtn");
        connect(sendBtn, &QPushButton::clicked, this, &MainWindow::onSendUsart2);
        connect(m_usart2SendEdit, &QLineEdit::returnPressed, this, &MainWindow::onSendUsart2);

        auto *sendLayout = new QHBoxLayout();
        sendLayout->addWidget(new QLabel("发送"));
        sendLayout->addWidget(m_usart2SendEdit, 3);
        sendLayout->addWidget(m_usart2HexSendCheck);
        sendLayout->addWidget(sendBtn);

        lay->addLayout(bar);
        lay->addWidget(m_usart2RecvEdit, 1);
        lay->addLayout(sendLayout);
        tabWidget->addTab(w, "USART2");
    }

    // --- SPI Tab ---
    {
        auto *w = new QWidget();
        auto *lay = new QVBoxLayout(w);
        lay->setSpacing(6);

        m_spiRecvEdit = new QPlainTextEdit(w); m_spiRecvEdit->setReadOnly(true); m_spiRecvEdit->setMaximumBlockCount(5000);
        auto *clearBtn = new QPushButton("清空", w);
        clearBtn->setObjectName("ghostBtn");
        auto *bar = new QHBoxLayout();
        bar->addWidget(new QLabel("响应"));
        bar->addStretch();
        bar->addWidget(clearBtn);
        connect(clearBtn, &QPushButton::clicked, this, &MainWindow::onClearSpiRecv);

        m_spiWriteEdit = new QLineEdit(w);
        m_spiWriteEdit->setPlaceholderText("写入数据 HEX (如: 9F 00 00)");
        m_spiReadLenSpin = new QSpinBox(w);
        m_spiReadLenSpin->setRange(0, 255);
        m_spiReadLenSpin->setValue(0);
        auto *sendBtn = new QPushButton("发送 SPI 请求", w);
        sendBtn->setObjectName("primaryBtn");
        connect(sendBtn, &QPushButton::clicked, this, &MainWindow::onSendSpi);

        auto *sendLayout = new QHBoxLayout();
        sendLayout->addWidget(new QLabel("写数据"));
        sendLayout->addWidget(m_spiWriteEdit, 3);
        sendLayout->addWidget(new QLabel("读长度"));
        sendLayout->addWidget(m_spiReadLenSpin);
        sendLayout->addWidget(sendBtn);

        lay->addLayout(bar);
        lay->addWidget(m_spiRecvEdit, 1);
        lay->addLayout(sendLayout);
        tabWidget->addTab(w, "SPI1");
    }

    // --- I2C Tab ---
    {
        auto *w = new QWidget();
        auto *lay = new QVBoxLayout(w);
        lay->setSpacing(6);

        m_i2cRecvEdit = new QPlainTextEdit(w); m_i2cRecvEdit->setReadOnly(true); m_i2cRecvEdit->setMaximumBlockCount(5000);
        auto *clearBtn = new QPushButton("清空", w);
        clearBtn->setObjectName("ghostBtn");
        auto *bar = new QHBoxLayout();
        bar->addWidget(new QLabel("响应"));
        bar->addStretch();
        bar->addWidget(clearBtn);
        connect(clearBtn, &QPushButton::clicked, this, &MainWindow::onClearI2cRecv);

        m_i2cChannelCombo = new QComboBox(w);
        m_i2cChannelCombo->addItem("I2C1 (0x30)", 0x30);
        m_i2cChannelCombo->addItem("I2C2 (0x31)", 0x31);

        m_i2cOpCombo = new QComboBox(w);
        m_i2cOpCombo->addItem("Write (0x01)", 0x01);
        m_i2cOpCombo->addItem("Read (0x02)", 0x02);
        m_i2cOpCombo->addItem("MemWrite (0x03)", 0x03);
        m_i2cOpCombo->addItem("MemRead (0x04)", 0x04);

        m_i2cDevAddrSpin = new QSpinBox(w);
        m_i2cDevAddrSpin->setRange(0, 0x7F);
        m_i2cDevAddrSpin->setDisplayIntegerBase(16);
        m_i2cDevAddrSpin->setPrefix("0x");
        m_i2cDevAddrSpin->setValue(0);

        m_i2cMemAddrEdit = new QLineEdit(w);
        m_i2cMemAddrEdit->setPlaceholderText("HEX (如: 00 10)");
        m_i2cMemAddrLenSpin = new QSpinBox(w);
        m_i2cMemAddrLenSpin->setRange(1, 4);
        m_i2cMemAddrLenSpin->setValue(1);

        m_i2cDataEdit = new QLineEdit(w);
        m_i2cDataEdit->setPlaceholderText("HEX 写入数据");
        m_i2cReadLenSpin = new QSpinBox(w);
        m_i2cReadLenSpin->setRange(0, 255);
        m_i2cReadLenSpin->setValue(1);

        auto *sendBtn = new QPushButton("发送 I2C 请求", w);
        sendBtn->setObjectName("primaryBtn");
        connect(sendBtn, &QPushButton::clicked, this, &MainWindow::onSendI2c);

        auto *formLayout = new QGridLayout();
        formLayout->setSpacing(8);
        formLayout->addWidget(new QLabel("通道"), 0, 0);
        formLayout->addWidget(m_i2cChannelCombo, 0, 1);
        formLayout->addWidget(new QLabel("操作"), 0, 2);
        formLayout->addWidget(m_i2cOpCombo, 0, 3);
        formLayout->addWidget(new QLabel("设备地址"), 1, 0);
        formLayout->addWidget(m_i2cDevAddrSpin, 1, 1);
        formLayout->addWidget(new QLabel("数据/读长度"), 1, 2);
        formLayout->addWidget(m_i2cDataEdit, 1, 3);
        formLayout->addWidget(new QLabel("内存地址"), 2, 0);
        formLayout->addWidget(m_i2cMemAddrEdit, 2, 1);
        formLayout->addWidget(new QLabel("地址长度"), 2, 2);
        formLayout->addWidget(m_i2cMemAddrLenSpin, 2, 3);
        formLayout->addWidget(new QLabel("读取长度"), 3, 0);
        formLayout->addWidget(m_i2cReadLenSpin, 3, 1);
        formLayout->addWidget(sendBtn, 3, 2, 1, 2);

        lay->addLayout(bar);
        lay->addWidget(m_i2cRecvEdit, 1);
        lay->addLayout(formLayout);
        tabWidget->addTab(w, "I2C");
    }

    // --- ADC Tab ---
    {
        auto *w = new QWidget();
        auto *lay = new QVBoxLayout(w);
        lay->setSpacing(6);

        // 示波器控件
        m_adcScope = new OscilloscopeWidget(w);
        m_adcScope->setVoltageRange(0.0, 3.3);
        m_adcScope->setMaxDisplayPoints(400);

        // 底部：小文本日志 + 控制
        m_adcRecvEdit = new QPlainTextEdit(w);
        m_adcRecvEdit->setReadOnly(true);
        m_adcRecvEdit->setMaximumBlockCount(5000);
        m_adcRecvEdit->setMaximumHeight(80);

        auto *clearBtn = new QPushButton("清空", w);
        clearBtn->setObjectName("ghostBtn");
        auto *bar = new QHBoxLayout();
        bar->addWidget(new QLabel("采样数据"));
        bar->addStretch();
        bar->addWidget(clearBtn);
        connect(clearBtn, &QPushButton::clicked, this, &MainWindow::onClearAdcRecv);

        m_adcStartStopBtn = new QPushButton("启动 ADC", w);
        m_adcStartStopBtn->setObjectName("primaryBtn");
        connect(m_adcStartStopBtn, &QPushButton::clicked, this, &MainWindow::onAdcStartStop);

        m_adcPscSpin = new QSpinBox(w);
        m_adcPscSpin->setRange(0, 65535);
        m_adcPscSpin->setValue(0);
        m_adcPscSpin->setFixedWidth(80);
        m_adcPerSpin = new QSpinBox(w);
        m_adcPerSpin->setRange(0, 65535);
        m_adcPerSpin->setValue(0);
        m_adcPerSpin->setFixedWidth(80);
        auto *setRateBtn = new QPushButton("设置采样率", w);
        connect(setRateBtn, &QPushButton::clicked, this, &MainWindow::onAdcSetRate);

        // 触发控制
        m_adcTrigModeCombo = new QComboBox(w);
        m_adcTrigModeCombo->addItem("Auto", static_cast<int>(OscilloscopeWidget::Auto));
        m_adcTrigModeCombo->addItem("Normal", static_cast<int>(OscilloscopeWidget::Normal));
        m_adcTrigModeCombo->addItem("Single", static_cast<int>(OscilloscopeWidget::Single));

        m_adcTrigEdgeCombo = new QComboBox(w);
        m_adcTrigEdgeCombo->addItem("↑ 上升沿", static_cast<int>(OscilloscopeWidget::Rising));
        m_adcTrigEdgeCombo->addItem("↓ 下降沿", static_cast<int>(OscilloscopeWidget::Falling));
        m_adcTrigEdgeCombo->addItem("↕ 双沿", static_cast<int>(OscilloscopeWidget::Both));

        m_adcTrigLevelSpin = new QDoubleSpinBox(w);
        m_adcTrigLevelSpin->setRange(0.0, 3.3);
        m_adcTrigLevelSpin->setValue(1.65);
        m_adcTrigLevelSpin->setSingleStep(0.01);
        m_adcTrigLevelSpin->setDecimals(2);
        m_adcTrigLevelSpin->setSuffix(" V");
        m_adcTrigLevelSpin->setFixedWidth(85);

        m_adcArmBtn = new QPushButton("重新触发", w);
        m_adcArmBtn->setEnabled(false);
        connect(m_adcArmBtn, &QPushButton::clicked, this, [this]() {
            m_adcScope->armTrigger();
        });

        connect(m_adcTrigModeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this]() {
            auto mode = static_cast<OscilloscopeWidget::TriggerMode>(m_adcTrigModeCombo->currentData().toInt());
            m_adcScope->setTriggerMode(mode);
            m_adcArmBtn->setEnabled(mode == OscilloscopeWidget::Single);
        });
        connect(m_adcTrigEdgeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this]() {
            auto edge = static_cast<OscilloscopeWidget::TriggerEdge>(m_adcTrigEdgeCombo->currentData().toInt());
            m_adcScope->setTriggerEdge(edge);
        });
        connect(m_adcTrigLevelSpin, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, [this](double val) {
            m_adcScope->setTriggerLevel(val);
        });

        auto *ctrlLayout = new QHBoxLayout();
        ctrlLayout->setSpacing(4);
        ctrlLayout->addWidget(m_adcStartStopBtn);
        ctrlLayout->addSpacing(12);
        ctrlLayout->addWidget(new QLabel("PSC"));
        ctrlLayout->addWidget(m_adcPscSpin);
        ctrlLayout->addSpacing(12);
        ctrlLayout->addWidget(new QLabel("PER"));
        ctrlLayout->addWidget(m_adcPerSpin);
        ctrlLayout->addSpacing(12);
        ctrlLayout->addWidget(setRateBtn);
        ctrlLayout->addSpacing(16);
        ctrlLayout->addWidget(new QLabel("触发"));
        ctrlLayout->addWidget(m_adcTrigModeCombo);
        ctrlLayout->addWidget(m_adcTrigEdgeCombo);
        ctrlLayout->addWidget(m_adcTrigLevelSpin);
        ctrlLayout->addWidget(m_adcArmBtn);
        ctrlLayout->addStretch();

        lay->addWidget(m_adcScope, 1);
        lay->addLayout(bar);
        lay->addWidget(m_adcRecvEdit);
        lay->addLayout(ctrlLayout);
        tabWidget->addTab(w, "ADC");
    }

    // --- System Tab ---
    {
        auto *w = new QWidget();
        auto *lay = new QVBoxLayout(w);
        lay->setSpacing(6);

        m_sysLogEdit = new QPlainTextEdit(w); m_sysLogEdit->setReadOnly(true); m_sysLogEdit->setMaximumBlockCount(2000);
        m_sysLogEdit->setMaximumHeight(120);

        auto *queryBtn = new QPushButton("查询固件信息", w);
        queryBtn->setObjectName("primaryBtn");
        connect(queryBtn, &QPushButton::clicked, this, &MainWindow::onQueryInfo);

        m_sysUsart1BaudSpin = new QSpinBox(w);
        m_sysUsart1BaudSpin->setRange(1200, 4000000);
        m_sysUsart1BaudSpin->setValue(115200);
        m_sysUsart1BaudSpin->setSingleStep(9600);
        auto *setU1Btn = new QPushButton("设置", w);
        connect(setU1Btn, &QPushButton::clicked, this, &MainWindow::onSetUsart1Baud);

        m_sysUsart2BaudSpin = new QSpinBox(w);
        m_sysUsart2BaudSpin->setRange(1200, 4000000);
        m_sysUsart2BaudSpin->setValue(115200);
        m_sysUsart2BaudSpin->setSingleStep(9600);
        auto *setU2Btn = new QPushButton("设置", w);
        connect(setU2Btn, &QPushButton::clicked, this, &MainWindow::onSetUsart2Baud);

        m_sysCanBaudSpin = new QSpinBox(w);
        m_sysCanBaudSpin->setRange(10000, 1000000);
        m_sysCanBaudSpin->setValue(500000);
        m_sysCanBaudSpin->setSingleStep(50000);
        auto *setCanBtn = new QPushButton("设置", w);
        connect(setCanBtn, &QPushButton::clicked, this, &MainWindow::onSetCanBaud);

        m_sysI2c1SpeedCombo = new QComboBox(w);
        m_sysI2c1SpeedCombo->addItem("100 kHz", 100000);
        m_sysI2c1SpeedCombo->addItem("400 kHz", 400000);
        auto *setI2c1Btn = new QPushButton("设置", w);
        connect(setI2c1Btn, &QPushButton::clicked, this, &MainWindow::onSetI2c1Speed);

        m_sysI2c2SpeedCombo = new QComboBox(w);
        m_sysI2c2SpeedCombo->addItem("100 kHz", 100000);
        m_sysI2c2SpeedCombo->addItem("400 kHz", 400000);
        auto *setI2c2Btn = new QPushButton("设置", w);
        connect(setI2c2Btn, &QPushButton::clicked, this, &MainWindow::onSetI2c2Speed);

        m_sysSpiPrescCombo = new QComboBox(w);
        for (int p : {4, 8, 16, 32, 64, 128, 256})
            m_sysSpiPrescCombo->addItem(QString::number(p), p);
        auto *setSpiBtn = new QPushButton("设置", w);
        connect(setSpiBtn, &QPushButton::clicked, this, &MainWindow::onSetSpi1Presc);

        auto *cfgLayout = new QGridLayout();
        cfgLayout->setSpacing(8);
        cfgLayout->addWidget(queryBtn, 0, 0, 1, 4);
        cfgLayout->addWidget(new QLabel("USART1 波特率"), 1, 0);
        cfgLayout->addWidget(m_sysUsart1BaudSpin, 1, 1);
        cfgLayout->addWidget(setU1Btn, 1, 2);
        cfgLayout->addWidget(new QLabel("USART2 波特率"), 1, 3);
        cfgLayout->addWidget(m_sysUsart2BaudSpin, 1, 4);
        cfgLayout->addWidget(setU2Btn, 1, 5);
        cfgLayout->addWidget(new QLabel("CAN 波特率"), 2, 0);
        cfgLayout->addWidget(m_sysCanBaudSpin, 2, 1);
        cfgLayout->addWidget(setCanBtn, 2, 2);
        cfgLayout->addWidget(new QLabel("I2C1 速度"), 2, 3);
        cfgLayout->addWidget(m_sysI2c1SpeedCombo, 2, 4);
        cfgLayout->addWidget(setI2c1Btn, 2, 5);
        cfgLayout->addWidget(new QLabel("I2C2 速度"), 3, 0);
        cfgLayout->addWidget(m_sysI2c2SpeedCombo, 3, 1);
        cfgLayout->addWidget(setI2c2Btn, 3, 2);
        cfgLayout->addWidget(new QLabel("SPI 预分频"), 3, 3);
        cfgLayout->addWidget(m_sysSpiPrescCombo, 3, 4);
        cfgLayout->addWidget(setSpiBtn, 3, 5);

        lay->addWidget(new QLabel("日志"));
        lay->addWidget(m_sysLogEdit);
        lay->addLayout(cfgLayout);
        lay->addStretch();
        tabWidget->addTab(w, "System");
    }

    // ===== 调试区 =====
    auto *debugGroup = new QGroupBox("  原始数据 (调试)  ", central);
    auto *debugLayout = new QVBoxLayout(debugGroup);
    debugLayout->setContentsMargins(16, 20, 16, 12);
    debugLayout->setSpacing(6);
    auto *debugBar = new QHBoxLayout();
    auto *debugClearBtn = new QPushButton("清空", debugGroup);
    debugClearBtn->setObjectName("ghostBtn");
    debugBar->addWidget(new QLabel("USB CDC 原始字节流"));
    debugBar->addStretch();
    debugBar->addWidget(debugClearBtn);
    m_debugEdit = new QPlainTextEdit(debugGroup);
    m_debugEdit->setReadOnly(true);
    m_debugEdit->setMaximumBlockCount(5000);
    m_debugEdit->setMaximumHeight(100);
    debugLayout->addLayout(debugBar);
    debugLayout->addWidget(m_debugEdit);
    connect(debugClearBtn, &QPushButton::clicked, this, [this]() { m_debugEdit->clear(); });

    // ===== 组装 =====
    mainLayout->addWidget(connGroup);
    mainLayout->addWidget(tabWidget, 1);
    mainLayout->addWidget(debugGroup);

    central->setLayout(mainLayout);
    setCentralWidget(central);
}

// ===== 连接 =====

void MainWindow::onRefreshPorts() {
    m_portCombo->clear();
    const auto ports = m_serialManager->availablePorts();
    for (const auto &info : ports) {
        QString desc = QString("%1 - %2").arg(info.portName(), info.description());
        m_portCombo->addItem(desc, info.portName());
    }
    if (ports.isEmpty()) {
        m_statusLabel->setText("未发现串口");
        m_statusLabel->setStyleSheet("color: #f38ba8; font-weight: bold; padding: 2px 8px;");
    }
}

void MainWindow::onToggleConnection() {
    if (m_serialManager->isOpen()) {
        m_serialManager->close();
    } else {
        QString portName = m_portCombo->currentData().toString();
        if (portName.isEmpty()) {
            QMessageBox::warning(this, "错误", "请先选择串口");
            return;
        }
        qint32 baud = m_baudCombo->currentText().toInt();
        m_serialManager->open(portName, baud);
    }
}

void MainWindow::onAbout() {
    QMessageBox::aboutQt(this, "关于 Qt");
}

// ===== CAN =====

void MainWindow::onSendCan() {
    if (!m_serialManager->isOpen()) return;
    uint32_t id = static_cast<uint32_t>(m_canIdSpin->value());
    bool extended = m_canExtCheck->isChecked();
    bool rtr = m_canRtrCheck->isChecked();
    QByteArray payload;
    if (!rtr) {
        payload = hexStringToBytes(m_canDataEdit->text().trimmed());
        if (payload.size() > 8) {
            QMessageBox::warning(this, "错误", "CAN数据最多8字节");
            return;
        }
    }
    m_serialManager->sendCanFrame(id, extended, rtr, payload);
}

void MainWindow::onClearCanRecv() { m_canRecvEdit->clear(); }

// ===== USART =====

void MainWindow::onSendUsart1() {
    if (!m_serialManager->isOpen()) return;
    QString text = m_usart1SendEdit->text();
    QByteArray data = m_usart1HexSendCheck->isChecked() ? hexStringToBytes(text) : text.toUtf8();
    m_serialManager->sendUsartData(0x10, data);
}

void MainWindow::onClearUsart1Recv() { m_usart1RecvEdit->clear(); }

void MainWindow::onSendUsart2() {
    if (!m_serialManager->isOpen()) return;
    QString text = m_usart2SendEdit->text();
    QByteArray data = m_usart2HexSendCheck->isChecked() ? hexStringToBytes(text) : text.toUtf8();
    m_serialManager->sendUsartData(0x11, data);
}

void MainWindow::onClearUsart2Recv() { m_usart2RecvEdit->clear(); }

// ===== SPI =====

void MainWindow::onSendSpi() {
    if (!m_serialManager->isOpen()) return;
    QByteArray writeData = hexStringToBytes(m_spiWriteEdit->text().trimmed());
    uint8_t readLen = static_cast<uint8_t>(m_spiReadLenSpin->value());
    m_serialManager->sendSpiRequest(writeData, readLen);
}

void MainWindow::onClearSpiRecv() { m_spiRecvEdit->clear(); }

// ===== I2C =====

void MainWindow::onSendI2c() {
    if (!m_serialManager->isOpen()) return;
    uint8_t channel = static_cast<uint8_t>(m_i2cChannelCombo->currentData().toInt());
    uint8_t op = static_cast<uint8_t>(m_i2cOpCombo->currentData().toInt());
    uint8_t devAddr = static_cast<uint8_t>(m_i2cDevAddrSpin->value());
    uint8_t memAddrLen = static_cast<uint8_t>(m_i2cMemAddrLenSpin->value());
    uint8_t readLen = static_cast<uint8_t>(m_i2cReadLenSpin->value());

    if (op == 0x01) {
        // Write
        QByteArray data = hexStringToBytes(m_i2cDataEdit->text().trimmed());
        m_serialManager->sendI2cWrite(channel, devAddr, data);
    } else if (op == 0x02) {
        // Read
        m_serialManager->sendI2cRead(channel, devAddr, readLen);
    } else if (op == 0x03) {
        // MemWrite
        QByteArray memAddrBytes = hexStringToBytes(m_i2cMemAddrEdit->text().trimmed());
        uint32_t memAddr = 0;
        for (int i = 0; i < qMin(memAddrBytes.size(), 4); i++)
            memAddr |= static_cast<uint8_t>(memAddrBytes[i]) << (8 * i);
        QByteArray data = hexStringToBytes(m_i2cDataEdit->text().trimmed());
        m_serialManager->sendI2cMemWrite(channel, devAddr, memAddr, memAddrLen, data);
    } else if (op == 0x04) {
        // MemRead
        QByteArray memAddrBytes = hexStringToBytes(m_i2cMemAddrEdit->text().trimmed());
        uint32_t memAddr = 0;
        for (int i = 0; i < qMin(memAddrBytes.size(), 4); i++)
            memAddr |= static_cast<uint8_t>(memAddrBytes[i]) << (8 * i);
        m_serialManager->sendI2cMemRead(channel, devAddr, memAddr, memAddrLen, readLen);
    }
}

void MainWindow::onClearI2cRecv() { m_i2cRecvEdit->clear(); }

// ===== ADC =====

void MainWindow::onAdcStartStop() {
    if (!m_serialManager->isOpen()) return;
    if (m_adcRunning) {
        m_serialManager->sendAdcStop();
        m_adcRunning = false;
        m_adcStartStopBtn->setText("启动 ADC");
    } else {
        m_serialManager->sendAdcStart();
        m_adcRunning = true;
        m_adcStartStopBtn->setText("停止 ADC");
    }
}

void MainWindow::onAdcSetRate() {
    if (!m_serialManager->isOpen()) return;
    m_serialManager->sendAdcSetRate(static_cast<uint16_t>(m_adcPscSpin->value()),
                                     static_cast<uint16_t>(m_adcPerSpin->value()));
}

void MainWindow::onClearAdcRecv() {
    m_adcScope->clearData();
    m_adcRecvEdit->clear();
}

// ===== System =====

void MainWindow::onQueryInfo() {
    if (!m_serialManager->isOpen()) return;
    m_serialManager->sendQueryInfo();
}

void MainWindow::onSetUsart1Baud() {
    if (!m_serialManager->isOpen()) return;
    m_serialManager->sendSetUsart1Baud(static_cast<uint32_t>(m_sysUsart1BaudSpin->value()));
}

void MainWindow::onSetUsart2Baud() {
    if (!m_serialManager->isOpen()) return;
    m_serialManager->sendSetUsart2Baud(static_cast<uint32_t>(m_sysUsart2BaudSpin->value()));
}

void MainWindow::onSetCanBaud() {
    if (!m_serialManager->isOpen()) return;
    m_serialManager->sendSetCanBaud(static_cast<uint32_t>(m_sysCanBaudSpin->value()));
}

void MainWindow::onSetI2c1Speed() {
    if (!m_serialManager->isOpen()) return;
    m_serialManager->sendSetI2c1Speed(static_cast<uint32_t>(m_sysI2c1SpeedCombo->currentData().toInt()));
}

void MainWindow::onSetI2c2Speed() {
    if (!m_serialManager->isOpen()) return;
    m_serialManager->sendSetI2c2Speed(static_cast<uint32_t>(m_sysI2c2SpeedCombo->currentData().toInt()));
}

void MainWindow::onSetSpi1Presc() {
    if (!m_serialManager->isOpen()) return;
    m_serialManager->sendSetSpi1Presc(static_cast<uint8_t>(m_sysSpiPrescCombo->currentData().toInt()));
}

// ===== Debug =====

void MainWindow::onClearDebug() { m_debugEdit->clear(); }

// ===== 上行信号处理 =====

void MainWindow::onPortOpened(const QString &portName) {
    m_connectBtn->setText("断开");
    m_connectBtn->setStyleSheet(
        "QPushButton { background-color: #f38ba8; color: #1e1e2e; border: none; font-weight: bold; border-radius: 6px; padding: 6px 24px; }"
        "QPushButton:hover { background-color: #eba0ac; }");
    m_statusLabel->setText("已连接: " + portName);
    m_statusLabel->setStyleSheet("color: #a6e3a1; font-weight: bold; padding: 2px 8px;");
    m_portCombo->setEnabled(false);
    m_baudCombo->setEnabled(false);
    m_refreshBtn->setEnabled(false);
}

void MainWindow::onPortClosed() {
    m_connectBtn->setText("连接");
    m_connectBtn->setStyleSheet("");
    m_statusLabel->setText("未连接");
    m_statusLabel->setStyleSheet("color: #6c7086; font-weight: bold; padding: 2px 8px;");
    m_portCombo->setEnabled(true);
    m_baudCombo->setEnabled(true);
    m_refreshBtn->setEnabled(true);
    m_adcRunning = false;
    m_adcStartStopBtn->setText("启动 ADC");
}

void MainWindow::onError(const QString &error) {
    m_statusLabel->setText("错误: " + error);
    m_statusLabel->setStyleSheet("color: #f38ba8; font-weight: bold; padding: 2px 8px;");
}

void MainWindow::onRawDataReceived(const QByteArray &data) {
    appendPending(m_debugEdit, byteArrayToHex(data));
}

void MainWindow::onCanFrameReceived(uint32_t id, bool extended, bool rtr, const QByteArray &data) {
    QString frameType = extended ? "EXT" : "STD";
    QString rtrStr = rtr ? "RTR" : "DATA";
    QString idStr = QString("%1").arg(id, extended ? 8 : 3, 16, QChar('0')).toUpper();
    QString dataStr = m_canHexRecvCheck->isChecked() ? byteArrayToHex(data) : QString::fromUtf8(data);
    if (data.isEmpty()) dataStr = "(无)";
    QString msg = QString("[%1][%2] ID:0x%3 DLC:%4 DATA:%5")
                      .arg(frameType, rtrStr, idStr)
                      .arg(data.size())
                      .arg(dataStr);
    appendPending(m_canRecvEdit, msg);
}

void MainWindow::onUsartDataReceived(uint8_t channel, const QByteArray &data) {
    QPlainTextEdit *edit = (channel == 0x10) ? m_usart1RecvEdit : m_usart2RecvEdit;
    QCheckBox *hexCheck = (channel == 0x10) ? m_usart1HexRecvCheck : m_usart2HexRecvCheck;
    if (hexCheck->isChecked()) {
        appendPending(edit, byteArrayToHex(data));
    } else {
        appendPending(edit, QString::fromUtf8(data));
    }
}

void MainWindow::onSpiResponseReceived(uint8_t result, const QByteArray &readData) {
    static const char *results[] = {"OK", "Busy", "Error"};
    QString msg = QString("Result: %1").arg(result < 3 ? results[result] : QString::number(result));
    if (!readData.isEmpty()) {
        msg += "  Read: " + byteArrayToHex(readData);
    }
    appendPending(m_spiRecvEdit, msg);
}

void MainWindow::onI2cResponseReceived(uint8_t channel, uint8_t result, const QByteArray &readData) {
    static const char *results[] = {"OK", "NACK", "Timeout", "Error"};
    QString chName = (channel == 0x30) ? "I2C1" : "I2C2";
    QString msg = QString("[%1] Result: %2").arg(chName, result < 4 ? results[result] : QString::number(result));
    if (!readData.isEmpty()) {
        msg += "  Read: " + byteArrayToHex(readData);
    }
    appendPending(m_i2cRecvEdit, msg);
}

void MainWindow::onAdcDataReceived(uint16_t seqNum, const QByteArray &rawData) {
    // 解析 uint16_t 样本（小端序，每2字节一个采样点）
    QVector<uint16_t> samples;
    samples.reserve(rawData.size() / 2);
    for (int i = 0; i + 1 < rawData.size(); i += 2) {
        uint16_t val = static_cast<uint8_t>(rawData[i])
                     | (static_cast<uint8_t>(rawData[i + 1]) << 8);
        samples.append(val);
    }

    // 送入示波器显示
    m_adcScope->appendSamples(samples);

    // 文本日志简要记录
    QString msg = QString("Seq:%1  Samples:%2").arg(seqNum).arg(samples.size());
    if (!samples.isEmpty()) {
        double voltage = (samples.last() / 65535.0) * 3.3;
        msg += QString("  Latest:%1 (%2V)")
                   .arg(samples.last())
                   .arg(voltage, 5, 'f', 3);
    }
    appendPending(m_adcRecvEdit, msg);
}

void MainWindow::onDeviceInfoReceived(uint8_t verMajor, uint8_t verMinor, uint8_t chCount) {
    m_sysLogEdit->appendPlainText(QString("设备信息: v%1.%2, 通道数: %3")
                             .arg(verMajor).arg(verMinor).arg(chCount));
}

void MainWindow::onSysCmdResult(uint8_t cmd, uint8_t result) {
    static const char *results[] = {"OK", "Error", "Not Supported"};
    QString cmdName;
    switch (cmd) {
    case 0x01: cmdName = "SET_USART1_BAUD"; break;
    case 0x02: cmdName = "SET_USART2_BAUD"; break;
    case 0x03: cmdName = "SET_CAN_BAUD"; break;
    case 0x04: cmdName = "SET_I2C1_SPEED"; break;
    case 0x05: cmdName = "SET_I2C2_SPEED"; break;
    case 0x06: cmdName = "SET_SPI1_PRESC"; break;
    default: cmdName = QString("CMD_0x%1").arg(cmd, 2, 16, QChar('0')).toUpper(); break;
    }
    m_sysLogEdit->appendPlainText(QString("%1 → %2")
                             .arg(cmdName, result < 3 ? results[result] : QString::number(result)));
}

// ===== 工具函数 =====

void MainWindow::appendPending(QPlainTextEdit *edit, const QString &text) {
    m_pendingText[edit].append(text);
}

void MainWindow::onFlushPendingText() {
    for (auto it = m_pendingText.begin(); it != m_pendingText.end(); ++it) {
        QPlainTextEdit *edit = it.key();
        const QStringList &lines = it.value();
        if (lines.isEmpty()) continue;

        // 合并为一次追加，减少布局和重绘次数
        edit->appendPlainText(lines.join('\n'));
        auto *sb = edit->verticalScrollBar();
        sb->setValue(sb->maximum());
    }
    m_pendingText.clear();
}

QString MainWindow::byteArrayToHex(const QByteArray &data, bool spaced) {
    if (spaced)
        return QString::fromLatin1(data.toHex(' ').toUpper());
    else
        return QString::fromLatin1(data.toHex().toUpper());
}

QByteArray MainWindow::hexStringToBytes(const QString &hex) {
    QByteArray data;
    QStringList hexList = hex.split(' ', Qt::SkipEmptyParts);
    for (const auto &h : hexList) {
        bool ok;
        uint8_t byte = static_cast<uint8_t>(h.toUInt(&ok, 16));
        if (ok) data.append(byte);
    }
    return data;
}