TSI_Config/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>
#include <QList>
#include <QJsonDocument>
#include <QJsonArray>
#include <QJsonObject>
#include <QInputDialog>
#include "keyphase.h"
#include "singlerelay.h"
#include "tachometer.h"
#include "seismic_monitor.h"
#include <QMessageBox>
#include <QFileDialog>
#include <stdio.h>
#include <QSysInfo>
#include <qsettings.h>
#include <QNetworkProxy>
#include "relaysetting.h"
#include "config_mgr.h"
#include "vibrationdata.h"
#include "connect.h"
#include "tmrrelayassociation.h"
#include "setpoint_tachometer.h"
#include "pointname.h"
#include "ethconfig.h"
#include "macconfig.h"
#include <QDateTime>
#include "dc_outputs.h"
#include "mqtt_config.h"
#include <QInputDialog>

QString g_strServerIp;
QString g_version;

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow) {
    ui->setupUi(this);
    g_version = "1.1";
    current_slot = -1;
    tsi_config_file = "";
    ui->widget_body->setProperty("flag", "title");
    ui->menuBar->setProperty("flag", "menuBar");
    //关联事件过滤器用于双击放大
    ui->widget_body->installEventFilter(this);
    ui->widget_body->setProperty("flag", "body");
    ui->statusBar->setProperty("flag", "status");
    // 创建进度条
    progressBar = new QProgressBar(this);
    // 设置进度条的范围（0到100）
    progressBar->setRange(0, 100);
    // 将进度条添加到状态栏
    statusBar()->addWidget(progressBar);
    progressBar->setVisible(false); // 初始隐藏
    progressBar->setFixedWidth(300);
    //this->initStyle();
    //添加信号槽
    QObject::connect(ui->action_realy, &QAction::triggered, this, &MainWindow::onMenuAction_relay);
    slot_no = -1;
    btnGroup_slot = new QButtonGroup(this);
    btnGroup_slot->addButton(ui->pushButton_slot0);
    btnGroup_slot->addButton(ui->pushButton_slot1);
    btnGroup_slot->addButton(ui->pushButton_slot2);
    btnGroup_slot->addButton(ui->pushButton_slot3);
    btnGroup_slot->addButton(ui->pushButton_slot4);
    btnGroup_slot->addButton(ui->pushButton_slot5);
    btnGroup_slot->addButton(ui->pushButton_slot6);
    btnGroup_slot->addButton(ui->pushButton_slot7);
    btnGroup_slot->addButton(ui->pushButton_slot8);
    btnGroup_slot->addButton(ui->pushButton_slot9);
    btnGroup_slot->addButton(ui->pushButton_slot10);
    btnGroup_slot->addButton(ui->pushButton_slot11);
    btnGroup_slot->addButton(ui->pushButton_slot12);
    btnGroup_slot->addButton(ui->pushButton_slot13);
    btnGroup_slot->addButton(ui->pushButton_slot14);
    btnGroup_slot->addButton(ui->pushButton_slot15);
    list_label.reserve(16);
    list_label.push_back(ui->label_18);
    list_label.push_back(ui->label_1);
    list_label.push_back(ui->label_2);
    list_label.push_back(ui->label_3);
    list_label.push_back(ui->label_4);
    list_label.push_back(ui->label_5);
    list_label.push_back(ui->label_6);
    list_label.push_back(ui->label_7);
    list_label.push_back(ui->label_8);
    list_label.push_back(ui->label_9);
    list_label.push_back(ui->label_10);
    list_label.push_back(ui->label_11);
    list_label.push_back(ui->label_12);
    list_label.push_back(ui->label_13);
    list_label.push_back(ui->label_14);
    list_label.push_back(ui->label_15);
    ui->pushButton_slot->setChecked(true);
    createMenu();
    connect(btnGroup_slot, SIGNAL(buttonClicked(QAbstractButton *)), this, SLOT(OnButtonGroup(QAbstractButton *)));
    QObject::connect(ui->action_connect, &QAction::triggered, this, &MainWindow::onConnect);
    QObject::connect(ui->action_disconnect, &QAction::triggered, this, &MainWindow::onDisconnect);
    QObject::connect(ui->action_eth, &QAction::triggered, this, &MainWindow::onEthConfig);
    QObject::connect(ui->action_mac, &QAction::triggered, this, &MainWindow::onMACConfig);
    QObject::connect(ui->action_time, &QAction::triggered, this, &MainWindow::onSetTime);
    QObject::connect(ui->action_mqtt, &QAction::triggered, this, &MainWindow::onMqttConfig);
    QObject::connect(ui->action_deviveID, &QAction::triggered, this, &MainWindow::onConfigDeviceID);
    QObject::connect(ui->action_get_deviceID, &QAction::triggered, this, &MainWindow::onGetDeviceID);

    QSettings settingsread(QCoreApplication::applicationDirPath() + "\\config\\config.ini", QSettings::IniFormat);
    g_strServerIp = settingsread.value("Server/IP").toString();
    connectServer();
    statusBar()->showMessage("未连接",10000);
    // 设置自定义日志处理函数
#ifndef QT_DEBUG
    //qInstallMessageHandler(messageHandler);
#endif
}

MainWindow::~MainWindow() {
    delete ui;
}

void MainWindow::onDisConnected() {
    statusBar()->showMessage("连接失败！正在重连……", 3000); // 显示3秒
}

void MainWindow::onConnected() {
    statusBar()->showMessage("连接成功！", 3000);
}
void MainWindow::onerrorOccurred(const QString &errorMsg) {
    statusBar()->showMessage(errorMsg, 3000);
}
void MainWindow::connectServer() {
    m_tcpClient = MyTcpClient::instance();
    // 监听信号
    connect(m_tcpClient, SIGNAL(dataReceived(const QByteArray &)), this, SLOT(readData(const QByteArray &)));
    connect(m_tcpClient, SIGNAL(disconnected()), this, SLOT(onDisConnected()));
    connect(m_tcpClient, SIGNAL(connected()), this, SLOT(onConnected()));
    connect(m_tcpClient, SIGNAL(errorOccurred(const QString &)), this, SLOT(onerrorOccurred(const QString &)));
}

void MainWindow::initStyle() {
    //加载样式表
    QString qss;
    QFile file(":/qss/soft.css");
    if (file.open(QFile::ReadOnly)) {
        qss = QLatin1String(file.readAll());
        QString paletteColor = qss.mid(20, 7);
        qApp->setPalette(QPalette(paletteColor));
        qApp->setStyleSheet(qss);
        file.close();
    }
}

void MainWindow::createMenu() {
    QList<QAbstractButton *> buttonList = btnGroup_slot->buttons();
    for (int i = 0; i < buttonList.count(); i++) {
        createMenu(QString("%1").arg(i + 1), (QPushButton *)buttonList[i]);
        map_slot_config[i].slot_btn = (QPushButton *)buttonList[i];
        map_slot_config[i].slot_label = list_label[i];
        std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(i);
        if(base_ptr != nullptr){
            switch (base_ptr->card_type_) {
                case kCardVibSingle :
                    buttonList[i]->setText("振动");
                    break;
                default:
                    break;
            }
        }
    }
}

void MainWindow::createMenu(const QString &rootTitle, QPushButton *parent) {
    // 创建主菜单
    QMenu *mainMenu = new QMenu(rootTitle, parent);
    // 创建第一层子菜单
    QMenu *monitors = new QMenu("监视器", mainMenu);
    QMenu *relays = new QMenu("/DOM810 继电器模块", mainMenu);
    QMenu *keyphasor = new QMenu("/KPM834 键相模块", mainMenu);
    // 创建第二层子菜单：/HAM824 振动板卡
    QMenu *proximitor_menu = new QMenu("/HAM824 振动板卡", monitors);
    QMenu *rpm_menu = new QMenu("/OPM844 转速板卡", monitors);
    // 创建第三层子菜单：/HAM824 单板卡、三冗余板卡
    QAction *proximitor_1 = proximitor_menu->addAction("/HAM824 单板卡");
    proximitor_1->setData(kCardVibSingle);
    //QAction *proximitor_2 = proximitor_menu->addAction("/HAM824 三冗余板卡");
    //proximitor_2->setData(kCardVibTMRPrimary);
    QAction *rpm_1 = rpm_menu->addAction("/OPM844 单板卡");
    rpm_1->setData(kCardSpeedSingle);
    // 创建第二层子菜单：/KPM834 键相模块
    QAction *keyphasor_1 = keyphasor->addAction("/KPM834 单板卡");
    keyphasor_1->setData(kCardKeyphaseSingle);
    //QAction *keyphasor_2 = keyphasor->addAction("/KPM834 两板卡");
    //keyphasor_2->setData(kCardKeyphaseDouble);
    // 创建第二层子菜单：/DOM810 继电器模块
    QAction *relays_1 = relays->addAction("/DOM810 单板卡");
    relays_1->setData(kCardRelaySingle);
//    QAction *relays_2 = relays->addAction("/DOM810 单板卡-非OK");
//    relays_2->setData(kCardRelaySingleNOK);
//    QAction *relays_3 = relays->addAction("/DOM810 三冗余板卡");
//    relays_3->setData(kCardRelayTMRPrimary);
    // 将子菜单加入上一级菜单
    monitors->addMenu(proximitor_menu); // 将第二层加入第一层
    monitors->addMenu(rpm_menu); // 第二层另一个子菜单
    mainMenu->addMenu(monitors); // 将第一层加入主菜单
    mainMenu->addMenu(relays);
    mainMenu->addMenu(keyphasor);
    QAction *reset = mainMenu->addAction("重置模块");
    QAction *upgrade = mainMenu->addAction("升级固件");
    QAction *version = mainMenu->addAction("查看版本");
    QAction *config_sub_card = mainMenu->addAction("更新配置");
    QAction *get_sub_log = mainMenu->addAction("获取日志");
    QAction *get_sub_card_voltage = mainMenu->addAction("获取电压范围");

    // 绑定 **鼠标事件过滤器**，确保只响应右键
    // 设置右键菜单策略
    parent->setContextMenuPolicy(Qt::CustomContextMenu);
    // 使用 `customContextMenuRequested` 事件，确保只有右键点击时弹出菜单
    connect(parent, &QPushButton::customContextMenuRequested, this, [ = ](const QPoint &pos) {
        qDebug() << "右键菜单触发1：" << pos;
        // 弹出菜单并捕获右键点击
        mainMenu->exec(QCursor::pos());
        mainMenu->close();
    });
    // 连接所有菜单项
    QObject::connect(proximitor_1, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    //QObject::connect(proximitor_2, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    QObject::connect(rpm_1, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    QObject::connect(relays_1, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    //QObject::connect(relays_2, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    //QObject::connect(relays_3, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    QObject::connect(keyphasor_1, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    //QObject::connect(keyphasor_2, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    QObject::connect(reset, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    QObject::connect(upgrade, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    QObject::connect(version, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    QObject::connect(config_sub_card, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    QObject::connect(get_sub_log, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);
    QObject::connect(get_sub_card_voltage, &QAction::triggered, this, &MainWindow::onMenuActionTriggered);

}

void MainWindow::createMenuSet(const QString &rootTitle, QPushButton *parent) {
    // 创建主菜单
    qDebug() << "createMenu" << parent->objectName()   ;
    QMenu *mainMenu = new QMenu(rootTitle, parent);
    QAction *option = mainMenu->addAction("通道配置…");
    QAction *set_points = mainMenu->addAction("触发配置…");
    QAction *point_names = mainMenu->addAction("测点名称");
}

// 清除菜单中所有动作的属性
void MainWindow::clearMenuProperties(QMenu *menu) {
    // 遍历菜单的所有动作
    if (!menu) {
        qWarning() << "菜单为空，无法清除属性！";
        return;
    }
    // 遍历菜单的所有动作
    for (QAction *action : menu->actions()) {
        if (!action) {
            continue;
        }
        // 检查是否有子菜单
        if (QMenu *subMenu = action->menu()) {
            clearMenuProperties(subMenu); // 递归处理子菜单
        }
        // 清除动作的属性
        action->setProperty("customProperty", QVariant());
        qDebug() << "清除了属性，动作:" << action->text();
    }
}

void MainWindow::onMenuActionTriggered() {
    qDebug() << "onMenuActionTriggered()"   ;
    QAction *action = qobject_cast<QAction *>(sender());
    if (action) {
        // 获取触发动作的父菜单
        QMenu *menu = qobject_cast<QMenu *>(action->parent());
        // 遍历所有父菜单，直到找到按钮
        while (menu) {
            QPushButton *button = qobject_cast<QPushButton *>(menu->parent());
            if (button) {
                qDebug() << "子菜单项被点击，所属按钮：" << button->objectName() << action->text();
                QString slot_type = action->text().mid(1, 6);
                QString rack_type = action->text().right(action->text().length() - 8);
                qDebug() << "rack_type" << action->data();
                card_type = static_cast<CardType>(action->data().toInt());
                int button_id = button->objectName().right(button->objectName().length() - 15).toInt();
                qDebug() << slot_type << rack_type << button_id << map_slot_config[button_id].slot_type << map_slot_config[button_id + 2].slot_type   ;
                map_slot_config[button_id].slot_label->setStyleSheet("QLabel { color :#2980b9; font: bold 16px}");
                QString chan_display = "";
                if (slot_type == "DOM810") {
                    chan_display = "继电器";
                } else if (slot_type == "KPM834") {
                    chan_display = "键相";
                } else if (slot_type == "HAM824") {
                    chan_display = "振动";
                } else if (slot_type == "OPM844") {
                    chan_display = "转速";
                }
                if (card_type == kCardRelayTMRPrimary &&
                        (ConfigMgr::Instance()->card_type_[button_id - 1] != kCardNone ||
                         ConfigMgr::Instance()->card_type_[button_id] != kCardNone ||
                         ConfigMgr::Instance()->card_type_[button_id + 1] != kCardNone)) {
                    QMessageBox::information(this, QStringLiteral("提示"), "不要重叠三冗余板卡配置，请在创建新配置之前移除现有的配置！");
                    return;
                } else if (card_type == kCardRelayTMRPrimary && ConfigMgr::Instance()->card_type_[button_id - 1] == kCardNone \
                           && ConfigMgr::Instance()->card_type_[button_id] == kCardNone &&
                           ConfigMgr::Instance()->card_type_[button_id + 1] == kCardNone) {
                    map_slot_config[button_id].slot_type = slot_type;
                    map_slot_config[button_id].slot_btn->setText(chan_display);
                    map_slot_config[button_id + 1].slot_type = slot_type;
                    map_slot_config[button_id + 1].slot_btn->setText(chan_display);
                    map_slot_config[button_id + 2].slot_type = slot_type;
                    map_slot_config[button_id + 2].slot_btn->setText(chan_display);

                    ConfigMgr::Instance()->card_type_[button_id - 1] = kCardRelayTMRPrimary;
                    ConfigMgr::Instance()->card_type_[button_id] = kCardRelayTMRBackup;
                    ConfigMgr::Instance()->card_type_[button_id + 1] = kCardRelayTMRBackup;

                }
                if (rack_type == "两板卡" &&
                        (ConfigMgr::Instance()->card_type_[button_id - 1] != kCardNone ||
                         ConfigMgr::Instance()->card_type_[button_id] != kCardNone)) {
                    QMessageBox::information(this, QStringLiteral("提示"), "不要重叠两板卡配置，请在创建新配置之前移除现有的配置！");
                    return;
                } else if (rack_type == "两板卡" && ConfigMgr::Instance()->card_type_[button_id - 1] == kCardNone) {
                    map_slot_config[button_id].slot_type = slot_type;
                    map_slot_config[button_id].slot_btn->setText(chan_display);
                    map_slot_config[button_id + 1].slot_type = slot_type;
                    map_slot_config[button_id + 1].slot_btn->setText(chan_display);
                }
                 if ((card_type == kCardVibSingle || card_type == kCardSpeedSingle ||
                            card_type == kCardKeyphaseSingle || card_type == kCardRelaySingle ||
                            card_type == kCardRelaySingleNOK) && ConfigMgr::Instance()->card_type_[button_id - 1] == kCardNone) {
                    map_slot_config[button_id].slot_type = slot_type;
                    button->setText(chan_display);
                    ConfigMgr::Instance()->card_type_[button_id - 1] = card_type;
                }else if ((card_type == kCardVibSingle || card_type == kCardSpeedSingle ||
                           card_type == kCardKeyphaseSingle || card_type == kCardRelaySingle ||
                           card_type == kCardRelaySingleNOK) && ConfigMgr::Instance()->card_type_[button_id - 1] != kCardNone) {
                     QMessageBox::information(this, QStringLiteral("提示"), "不要重叠单板卡配置，请在创建新配置之前移除现有的配置！");
                     return;
                }
                if (action->text() == "重置模块") {
                    if (ConfigMgr::Instance()->card_type_[button_id - 1] == kCardRelayTMRPrimary) {
                        map_slot_config[button_id].slot_type = "";
                        map_slot_config[button_id].slot_btn->setText("");
                        map_slot_config[button_id + 1].slot_type = "";
                        map_slot_config[button_id + 1].slot_btn->setText("");
                        map_slot_config[button_id + 2].slot_type = "";
                        map_slot_config[button_id + 2].slot_btn->setText("");
                        std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(button_id);
                        if(base_ptr != nullptr){
                            ConfigMgr::Instance()->RemoveCard(base_ptr);
                            ConfigMgr::Instance()->card_type_[button_id - 1] = kCardNone;
                        }
                        std::shared_ptr<CardBase> base_ptr_backup = ConfigMgr::Instance()->GetSlotPtr(button_id + 1);
                        if(base_ptr_backup != nullptr){
                            ConfigMgr::Instance()->RemoveCard(base_ptr_backup);
                            ConfigMgr::Instance()->card_type_[button_id] = kCardNone;
                        }
                        std::shared_ptr<CardBase> base_ptr_backup2 = ConfigMgr::Instance()->GetSlotPtr(button_id + 2);
                        if(base_ptr_backup2 != nullptr){
                            ConfigMgr::Instance()->RemoveCard(base_ptr_backup2);
                            ConfigMgr::Instance()->card_type_[button_id + 1] = kCardNone;
                        }

                    } else if (ConfigMgr::Instance()->card_type_[button_id - 1] == kCardRelayTMRBackup) {
                        map_slot_config[button_id - 1].slot_type = "";
                        map_slot_config[button_id - 1].slot_btn->setText("");
                        map_slot_config[button_id].slot_type = "";
                        map_slot_config[button_id].slot_btn->setText("");
                        map_slot_config[button_id + 1].slot_type = "";
                        map_slot_config[button_id + 1].slot_btn->setText("");

                    }else if (ConfigMgr::Instance()->card_type_[button_id - 1] == kCardVibSingle ||
                              ConfigMgr::Instance()->card_type_[button_id - 1] == kCardSpeedSingle ||
                              ConfigMgr::Instance()->card_type_[button_id - 1] == kCardKeyphaseSingle) {
                        ConfigMgr::Instance()->card_type_[button_id - 1] = kCardNone;
                        map_slot_config[button_id].slot_btn->setText("");
                        std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(button_id);
                        if(base_ptr != nullptr)
                            ConfigMgr::Instance()->RemoveCard(base_ptr);
                    }else if (ConfigMgr::Instance()->card_type_[button_id - 1] == kCardRelaySingle ||
                              ConfigMgr::Instance()->card_type_[button_id - 1] == kCardRelaySingleNOK ||
                              ConfigMgr::Instance()->card_type_[button_id - 1] == kCardRelayTMRPrimary) {
                        ConfigMgr::Instance()->card_type_[button_id - 1] = kCardNone;
                        map_slot_config[button_id].slot_btn->setText("");
                        std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(button_id);
                        if(base_ptr != nullptr)
                            ConfigMgr::Instance()->RemoveCard(base_ptr);
                    }
                } else if (action->text() == "升级固件") {
                    sendUpgradePackage(button_id);
                } else if (action->text() == "查看版本") {
                    getVersion(button_id);
                }else if (action->text() == "更新配置") {
                    ConfigSubCard(button_id);
                }else if (action->text() == "获取日志") {
                    GetSubLog(button_id);
                }else if (action->text() == "获取电压范围") {
                    GetVoltageRangeValue(button_id);
                }
                break; // 找到按钮后，跳出循环
            }
            // 如果没有找到按钮，继续向上查找
            menu = qobject_cast<QMenu *>(menu->parent());
        }
    }
}

void MainWindow::OnButtonGroup(QAbstractButton *slot_btn) {
    if (slot_btn != NULL && ui->pushButton_chan->isChecked()) {
        QString object_name =  slot_btn->objectName();
        qDebug() << object_name   ;
        int button_id = object_name.right(object_name.length() - 15).toInt();
        SlotConfig slot_config = map_slot_config[button_id];
        map_slot_config[button_id].slot_label->setStyleSheet("QLabel { color :#2980b9; font: bold 16px}");
        if(current_slot != -1)
            map_slot_config[current_slot].slot_label->setStyleSheet("");
        current_slot = button_id;
        std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(button_id);
        if(base_ptr == nullptr){
            ConfigMgr::Instance()->card_type_[button_id - 1] = card_type;
            if (slot_config.slot_type == "KPM834") { // 键相模块
                KeyPhase *key_phase = new KeyPhase(button_id,card_type);
                key_phase->setWindowModality(Qt::ApplicationModal);
                key_phase->show();
            } else if (slot_config.slot_type == "DOM810") { // 继电器模块
                switch (card_type) {
                    case kCardRelaySingle:{
                        SingleRelay *single_relay = new SingleRelay(button_id,card_type);
                        single_relay->setWindowModality(Qt::ApplicationModal);
                        single_relay->show();
                    }break;
                }

            } else if (slot_config.slot_type == "HAM824") { // 振动模块
                Seismic_monitor *seismic_monitor = new Seismic_monitor(button_id,card_type);
                seismic_monitor->setWindowModality(Qt::ApplicationModal);
                seismic_monitor->show();
            } else if (slot_config.slot_type == "OPM844") { // 转速模块
                Tachometer *tachometer = new Tachometer(button_id,card_type);
                tachometer->setWindowModality(Qt::ApplicationModal);
                tachometer->show();
            }
            return;
        }
        switch(base_ptr->card_type_){
            case kCardVibSingle:{
                Seismic_monitor *seismic_monitor = new Seismic_monitor(button_id,card_type);
                seismic_monitor->setWindowModality(Qt::ApplicationModal);
                seismic_monitor->show();
                break;
            }
            case kCardKeyphaseSingle:{
                KeyPhase *key_phase = new KeyPhase(button_id,card_type);
                key_phase->setWindowModality(Qt::ApplicationModal);
                key_phase->show();
                break;
            }
            case kCardSpeedSingle:{
                Tachometer *tachometer = new Tachometer(button_id,card_type);
                tachometer->setWindowModality(Qt::ApplicationModal);
                tachometer->show();
                break;
            }
            case kCardRelaySingle:{
                SingleRelay *single_relay = new SingleRelay(button_id,card_type);
                single_relay->setWindowModality(Qt::ApplicationModal);
                single_relay->show();
                break;
            }
        }
    }
    if (slot_btn != NULL && ui->pushButton_alarm->isChecked()) {
        QString object_name =  slot_btn->objectName();
        int button_id = object_name.right(object_name.length() - 15).toInt();
        std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(button_id);
        if(base_ptr == nullptr)
            return;
        switch(base_ptr->card_type_){
            case kCardVibSingle:{
                QString object_name =  slot_btn->objectName();
                int button_id = object_name.right(object_name.length() - 15).toInt();
                DC_Outputs *dc_output = new DC_Outputs(button_id,ConfigMgr::Instance()->card_type_[button_id - 1]);
                dc_output->setWindowModality(Qt::ApplicationModal);
                dc_output->show();
                // Setpoint *setpoint = new Setpoint(button_id,ConfigMgr::Instance()->card_type_[button_id - 1]);
                // setpoint->setWindowModality(Qt::ApplicationModal);
                // setpoint->show();
                break;
            }
            case kCardSpeedSingle:{
                QString object_name =  slot_btn->objectName();
                int button_id = object_name.right(object_name.length() - 15).toInt();
                Setpoint_Tachometer *setpoint_tachometer = new Setpoint_Tachometer(button_id,ConfigMgr::Instance()->card_type_[button_id - 1]);
                setpoint_tachometer->setWindowModality(Qt::ApplicationModal);
                setpoint_tachometer->show();
                break;
            }
        }
    }
    if(slot_btn != NULL && ui->pushButton_point_name->isChecked()){
        QString object_name =  slot_btn->objectName();
        int button_id = object_name.right(object_name.length() - 15).toInt();
        std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(button_id);
        if(base_ptr == nullptr)
            return;
        PointName *point_name = new PointName(button_id,ConfigMgr::Instance()->card_type_[button_id - 1]);
        point_name->setWindowModality(Qt::ApplicationModal);
        point_name->show();
    }
}

void MainWindow::on_pushButton_slot_clicked() {
    if (ui->pushButton_chan->isChecked()) {
        ui->pushButton_chan->setChecked(false);
    }
    if (ui->pushButton_alarm->isChecked()) {
        ui->pushButton_alarm->setChecked(false);
    }
    if (ui->pushButton_point_name->isChecked()) {
        ui->pushButton_point_name->setChecked(false);
    }
}

void MainWindow::on_pushButton_chan_clicked() {
    if (ui->pushButton_slot->isChecked()) {
        ui->pushButton_slot->setChecked(false);
    }
    if (ui->pushButton_alarm->isChecked()) {
        ui->pushButton_alarm->setChecked(false);
    }
    if (ui->pushButton_point_name->isChecked()) {
        ui->pushButton_point_name->setChecked(false);
    }
}

void MainWindow::on_pushButton_alarm_clicked() {
    if (ui->pushButton_slot->isChecked()) {
        ui->pushButton_slot->setChecked(false);
    }
    if (ui->pushButton_chan->isChecked()) {
        ui->pushButton_chan->setChecked(false);
    }
    if (ui->pushButton_point_name->isChecked()) {
        ui->pushButton_point_name->setChecked(false);
    }
}

void MainWindow::on_pushButton_point_name_clicked() {
    if (ui->pushButton_slot->isChecked()) {
        ui->pushButton_slot->setChecked(false);
    }
    if (ui->pushButton_chan->isChecked()) {
        ui->pushButton_chan->setChecked(false);
    }
    if (ui->pushButton_alarm->isChecked()) {
        ui->pushButton_alarm->setChecked(false);
    }
}

void MainWindow::onMenuAction_relay() {
    qDebug() << " onMenuAction_relay "   ;
    RelaySetting *relay_setting = new RelaySetting();
    relay_setting->setWindowModality(Qt::ApplicationModal);
    relay_setting->show();
}
uint8_t calculate_crc(const QByteArray &data) {
    uint8_t crc = 0;
    for (int i = 0; i < data.size(); ++i) {
        crc += static_cast<uint8_t>(data[i]);  // 累加每个字节
    }
    return crc;
}
void MainWindow::on_pushButton_save_clicked() {

    QString file_name = "";
    if(tsi_config_file == ""){
        QString strTips =QString("请输入保存的文件名称");
        bool ok = false;
        QString defaultInput = "tsi_config_file";
        file_name = QInputDialog::getText(this, tr("输入名称对话框"), strTips, QLineEdit::Normal, defaultInput, &ok);
        if(!ok) return;

        if( file_name == ""){
            QMessageBox::information(this, QStringLiteral("提示"), QStringLiteral("请输入正确的文件名称！"));
            return ;
        }
        QString filepath = QFileDialog::getExistingDirectory(this, tr("选择文件夹"), tr(""));
        if(filepath == "")
            return;
        file_name = filepath + "\\"+file_name +".json";
        ConfigMgr::Instance()->Save(file_name);
        tsi_config_file = file_name;
    }else {
        ConfigMgr::Instance()->Save(tsi_config_file);
    }

    return;

}

void MainWindow::on_pushButton_open_clicked() {


    tsi_config_file = QFileDialog::getOpenFileName(this, tr("选择文件"), tr(""), tr("*.json"));
    QFileInfo fileinfo;
    fileinfo = QFileInfo(tsi_config_file);
    QString file_suffix = fileinfo.suffix();
    QString FileName = fileinfo.fileName();
    if (FileName.isEmpty()) {
        return;
    }
    QFile file(tsi_config_file);
    if (!file.open(QIODevice::ReadOnly)) {
        qWarning() << "Failed to open update file.";
        return;
    }
    QList<QAbstractButton *> buttonList = btnGroup_slot->buttons();
    for (int i = 1; i < buttonList.count(); i++) {
        buttonList[i]->setText("");
    }
    for (int i = 0; i < SLOT_NUM; i++) {
        std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(i + 1);
        if(base_ptr != nullptr){
            ConfigMgr::Instance()->RemoveCard(base_ptr);
        }
    }
    ConfigMgr::Instance()->Load(tsi_config_file);
    for (int i = 0; i < buttonList.count(); i++) {
        std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(i + 1);
        if(base_ptr != nullptr){
            switch (base_ptr->card_type_) {
                case kCardVibSingle :{
                    buttonList[i + 1]->setText("振动");
                    break;
                }
                case kCardKeyphaseSingle:{
                    buttonList[i + 1]->setText("键相");
                    break;
                }
                case kCardSpeedSingle:{
                    buttonList[i + 1]->setText("转速");
                    break;
                }
                case kCardRelaySingle:
                case kCardRelaySingleNOK:
                case kCardRelayTMRBackup:
                case kCardRelayTMRPrimary:{
                    buttonList[i + 1]->setText("继电器");
                    break;
                }
                default:
                    break;
            }
        }
    }
}


uint32_t myHtonl(uint32_t value) {
    return ((value >> 24) & 0x000000FF) | // 提取最高的8位
           ((value >> 8)  & 0x0000FF00) | // 提取中间的8位
           ((value << 8)  & 0x00FF0000) | // 提取次高的8位
           ((value << 24) & 0xFF000000);   // 提取最低的8位
}

void MainWindow::sendUpgradePackage(int slot) {
    QString filepath = QFileDialog::getOpenFileName(this, tr("选择文件"), tr(""), tr("*"));
    qDebug() << filepath  << slot   ;
    QFileInfo fileinfo;
    fileinfo = QFileInfo(filepath);
    QString file_suffix = fileinfo.suffix();
    QString FileName = fileinfo.fileName();
    if (FileName.isEmpty()) {
        return;
    }
    QFile file(filepath);
    if (!file.open(QIODevice::ReadOnly)) {
        qWarning() << "Failed to open update file.";
        return;
    }
    // 读取文件内容
    QByteArray fileData = file.readAll();
    int fileSize = fileData.size();
    if (fileSize > 10 * 1024 * 1024) {
        QMessageBox::information(this, QStringLiteral("提示"), "文件大小超过10M，请重新选择！");
        file.close();
        return;
    }
//    for (int var = 0; var < 10; ++var) {
//        qDebug() << "Byte" << var << ":" << static_cast<uint8_t>(fileData[var]);
//    }
//    for (int var = fileSize - 10; var < fileSize; ++var) {
//        qDebug() << "Byte" << var << ":" << static_cast<uint8_t>(fileData[var]);
//    }
    qDebug() << "fileSize" << fileSize  ;
    // 计算文件的 CRC 校验和
    qDebug() << "filheader.slot"  << slot  ;
    UpgradeCardReq upgrade_car_req = { {0xAA, 0x55, 0xAA}, kUpgradeCard, 1, fileSize, 0, 0, {} };
    if (slot == 0) {
        upgrade_car_req.card_id = 0xFF;
    } else {
        upgrade_car_req.card_id = slot & 0xFF;
    }
    upgrade_car_req.crc = calculate_crc(fileData);
    qDebug() << "filheader.crc" << upgrade_car_req.crc << "card_id" << upgrade_car_req.card_id << "header len" << upgrade_car_req.len;
    char *send_buf = NULL;
    send_buf = (char *)malloc(sizeof(UpgradeCardReq) + fileData.size() + 1);
    memset(send_buf, 0, sizeof(UpgradeCardReq) + fileData.size() + 1);
    memcpy(send_buf, &upgrade_car_req, sizeof(UpgradeCardReq));
    memcpy(send_buf + sizeof(UpgradeCardReq), fileData.data(), fileData.size());
    int length =  sizeof(UpgradeCardReq) + fileData.size();
    const int MAX_CHUNK_SIZE = 50 * 1024;  // 64 KB
    qint64 bytesSent = 0;
    qint64 totalBytes = length;
    qDebug() << "totalBytes" << totalBytes   ;
    while (bytesSent < totalBytes) {
        qint64 chunkSize = 0;
        if (MAX_CHUNK_SIZE < totalBytes - bytesSent) {
            chunkSize = MAX_CHUNK_SIZE;
        } else {
            chunkSize = totalBytes - bytesSent;
        }
        qint64 bytesWritten = m_tcpClient->sendData(send_buf + bytesSent, chunkSize);
        qDebug() << "bytesWritten" << bytesWritten << "bytesSent" << bytesSent   ;
        if (bytesWritten == -1) {
            break;
        }
        bytesSent += bytesWritten;
    }
    qDebug() << "bytesSent" << bytesSent   ;
    m_tcpClient->waitForRead();
    progressBar->reset();
    progressBar->setVisible(true);
    QString upgrade_text = QStringLiteral("正在上传板卡 [ %1 ] ……  %p%").arg(slot);
    progressBar->setTextVisible(true);
    progressBar->setFormat(upgrade_text);
    file.close();
    if (send_buf != NULL) {
        free(send_buf);
    }
}

void MainWindow::getVersion(int slot) {
    slot_no = slot;
    qDebug() << "slot"  << slot  ;
    GetVersionReq get_version_req =  { {0xAA, 0x55, 0xAA}, kGetVersionInfo, 1, 0 };
    if (slot == 0) {
        get_version_req.card_id = 0xFF;
    } else {
        get_version_req.card_id = slot & 0xFF;
    }
    char send_buf[20] = {0};
    memcpy(send_buf, (char *)&get_version_req, sizeof(GetVersionReq));
    int length = sizeof(GetVersionReq);
    qint64 bytesWritten = m_tcpClient->sendData(send_buf, length);
    m_tcpClient->waitForRead();
    qDebug() << "bytesWritten: " << bytesWritten;
}
void MainWindow::ConfigSubCard(int slot){
    slot_no = slot;
    qDebug() << "slot"  << slot  ;
    ConfigSubCardReq config_sub_card_req =  { {0xAA, 0x55, 0xAA}, kConfigSubCard, 1, 0 };
    if (slot == 0) {
        config_sub_card_req.card_id = 0xFF;
    } else {
        config_sub_card_req.card_id = slot & 0xFF;
    }
    char send_buf[20] = {0};
    memcpy(send_buf, (char *)&config_sub_card_req, sizeof(ConfigSubCardReq));
    int length = sizeof(ConfigSubCardReq);
    qint64 bytesWritten = m_tcpClient->sendData(send_buf, length);
    m_tcpClient->waitForRead();
    qDebug() << "bytesWritten: " << bytesWritten;
}
void MainWindow::GetSubLog(int slot){
    slot_no = slot;
    qDebug() << "slot"  << slot  ;
    GetSubCardLogReq get_sub_card_log_req =  { {0xAA, 0x55, 0xAA}, kGetLogInfo, 1, 0 };
    if (slot == 0) {
        get_sub_card_log_req.card_id = 0xFF;
    } else {
        get_sub_card_log_req.card_id = slot & 0xFF;
    }
    char send_buf[20] = {0};
    memcpy(send_buf, (char *)&get_sub_card_log_req, sizeof(GetSubCardLogReq));
    int length = sizeof(GetSubCardLogReq);
    qint64 bytesWritten = m_tcpClient->sendData(send_buf, length);
    m_tcpClient->waitForRead();
    qDebug() << "bytesWritten: " << bytesWritten;
}
void MainWindow::GetVoltageRangeValue(int slot){
    slot_no = slot;
    qDebug() << "slot"  << slot  ;
    GetSubCardVoltageRangeReq get_sub_card_log_req =  { {0xAA, 0x55, 0xAA}, kGetVoltageRangeValue, 1, 0 };
    SlotConfig slot_config = map_slot_config[slot];
    if (slot == 0 || slot_config.slot_type == "DOM810") {
        QMessageBox::information(this, QStringLiteral("提示"), QStringLiteral("请选择正确的板卡！"));
        return;
    }
    get_sub_card_log_req.card_id = slot & 0xFF;

    char send_buf[20] = {0};
    memcpy(send_buf, (char *)&get_sub_card_log_req, sizeof(GetSubCardVoltageRangeReq));
    int length = sizeof(GetSubCardVoltageRangeReq);
    qint64 bytesWritten = m_tcpClient->sendData(send_buf, length);
    m_tcpClient->waitForRead();
    qDebug() << "bytesWritten: " << bytesWritten;
}
void MainWindow::readData(const QByteArray &data) {
    qDebug() << "Received from server:" << data;

    uint8_t cmd = data[3];
    if (cmd == kGetVersionInfo) {
        VersionRsp version_rsp;
        memcpy(&version_rsp, data.data(), sizeof(VersionRsp));
        QString strVerion = QString("第 %1 板卡\nFPGA 版本：%2\n软件版本：%3\nFPGA版本日期：%4").arg(slot_no).arg(version_rsp.fpga).arg(version_rsp.sw).arg(version_rsp.fpga_date);
        QMessageBox::information(this, QStringLiteral("提示"), strVerion);
    } else if (cmd == kUpgradeCard) {
        UpgradeRsp resp;
        memcpy(&resp, data.data(), sizeof(UpgradeRsp));
        if (resp.code == 0) {
            statusBar()->showMessage("上传成功！", 3000);
        }else {
            statusBar()->showMessage("上传失败！", 3000);
        }
    } else if (cmd == kUpgradeProgress) {
        UpgradeRsp upgrade_resp;
        memcpy(&upgrade_resp, data.data(), sizeof(UpgradeRsp));
        progressBar->setValue(upgrade_resp.code);
        if (upgrade_resp.code == 100) {
            progressBar->setVisible(false);
            statusBar()->showMessage("升级完成！", 3000); // 显示3秒
        }
        //qDebug() << "Server response: " << upgrade_resp.code;
    } else if(cmd == kDownloadConfigFile){
        //qDebug() << "header.len" << header.len;
        char *config_file = NULL;
        DownloadConfigRsp download_config;
        memcpy(&download_config,data,sizeof(DownloadConfigRsp));
        config_file = (char*)malloc(download_config.len + 1);
        memset(config_file,0,download_config.len + 1);
        memcpy(config_file, data.data() + sizeof(DownloadConfigRsp), download_config.len);
        QString filename_ = QCoreApplication::applicationDirPath() + "\\config\\tsi_config_file_download.json";
        QFile file(filename_);
        file.open(QIODevice::WriteOnly);
        file.write(config_file,download_config.len);
        file.close();
        if(config_file != NULL)
            free(config_file);
        statusBar()->showMessage("下载配置成功！", 3000);
    }else if(cmd == kConfigSubCard){
        ConfigSubCardRsp config_sub_card;
        memcpy(&config_sub_card, data.data(), sizeof(ConfigSubCardRsp));
        if(config_sub_card.code == 0){
            statusBar()->showMessage("配置成功！", 3000);
        }else if(config_sub_card.code == 1){
            statusBar()->showMessage("没有配置文件！", 3000);
        }
    }else if(cmd == kGetLogInfo){
        char *log_file = NULL;
        GetSubCardLogRsp sub_card_log_rsp;
        memcpy(&sub_card_log_rsp,data,sizeof(GetSubCardLogRsp));
        log_file = (char*)malloc(sub_card_log_rsp.len + 1);
        memset(log_file,0,sub_card_log_rsp.len + 1);
        memcpy(log_file, data.data() + sizeof(GetSubCardLogRsp), sub_card_log_rsp.len);
        QDateTime now_time = QDateTime::currentDateTime();
        QString file_name = QString("log_%1_%2.tar.gz").arg(sub_card_log_rsp.card_id).arg(now_time.toString("yyyy-MM-dd_HHmmss"));
        QString log_path = QCoreApplication::applicationDirPath() + "\\log\\" + file_name;
        QFile file(log_path);
        file.open(QIODevice::WriteOnly);
        file.write(log_file,sub_card_log_rsp.len);
        file.close();
        if(log_file != NULL)
            free(log_file);
    }else if(cmd == kTimingCmd){
        SetTimingRsp set_time_rsp;
        memcpy(&set_time_rsp, data.data(), sizeof(SetTimingRsp));
        if(set_time_rsp.code == 0){
            statusBar()->showMessage("校时成功！", 3000);
        }else if(set_time_rsp.code == 1){
            statusBar()->showMessage("校时失败！", 3000);
        }
    }else if(cmd == kUploadConfigFile){
        UploadConfigRsp upload_config_rsp;
        memcpy(&upload_config_rsp, data.data(), sizeof(UploadConfigRsp));
        if(upload_config_rsp.code == 0){
            statusBar()->showMessage("上传成功!", 2000);
        }else if(upload_config_rsp.code == 1){
            statusBar()->showMessage("上传失败！", 2000);
        }
    }else if(cmd == kConfigProgress){
        ConfigSubCardProgress config_sub_card_progress;
        memcpy(&config_sub_card_progress, data.data(), sizeof(ConfigSubCardProgress));
        QString status ;
        if(config_sub_card_progress.code == 0 && config_sub_card_progress.stage == 1){
            status = QString("板卡 %1 配置成功！").arg(config_sub_card_progress.subcard_id);
            map_slot_config[config_sub_card_progress.subcard_id].slot_label->setStyleSheet("");
            statusBar()->showMessage(status, 2000);
        }
        if(config_sub_card_progress.code == 1){
            status = QString("板卡 %1 配置失败！").arg(config_sub_card_progress.subcard_id);
            map_slot_config[config_sub_card_progress.subcard_id].slot_label->setStyleSheet("QLabel { color :#FF0000; font: bold 16px}");
            statusBar()->showMessage(status, 2000);
        }
    }else if(cmd == kConfigDeviceID){
        DeviceIDConfigRsp device_config_rsp;
        memcpy(&device_config_rsp, data.data(), sizeof(DeviceIDConfigRsp));
        if(device_config_rsp.code == 0){
            statusBar()->showMessage("配置成功!", 2000);
        }else if(device_config_rsp.code == 1){
            statusBar()->showMessage("配置失败！", 2000);
        }
        if(device_config_rsp.sub_cmd == 0){
            QString str = QString("设备ID： %1").arg(device_config_rsp.device_id);
            QMessageBox::information(this, QStringLiteral("提示"), str);
        }
    }
}

void MainWindow::on_pushButton_download_clicked()
{
    DownloadConfigReq download_config_req = { {0xAA, 0x55, 0xAA}, kDownloadConfigFile, 1 };
    int length = sizeof(download_config_req);
    qint64 bytesWritten = m_tcpClient->sendData((char*)&download_config_req, length);
    m_tcpClient->waitForRead();
    qDebug() << "bytesWritten: " << bytesWritten;
}

void MainWindow::onConnect(){
    Connect *connect_config = new Connect();
    connect_config->setWindowModality(Qt::ApplicationModal);
    connect_config->show();
}
void MainWindow::onDisconnect(){
    m_tcpClient->disconnectFromServer();
}

void MainWindow::onEthConfig(){
    EthConfig *eth_config = new EthConfig();
    eth_config->setWindowModality(Qt::ApplicationModal);
    eth_config->show();
}
void MainWindow::onMACConfig(){
    MacConfig *mac_config = new MacConfig();
    mac_config->setWindowModality(Qt::ApplicationModal);
    mac_config->show();
}
void MainWindow::onMqttConfig(){
    MqttConfig *mqtt_config = new MqttConfig();
    mqtt_config->setWindowModality(Qt::ApplicationModal);
    mqtt_config->show();
}
void MainWindow::onGetDeviceID(){
    DeviceIDConfigReq config_device_id = { {0xAA, 0x55, 0xAA}, kConfigDeviceID, 1,0,{}};
    int length = sizeof(DeviceIDConfigReq);
    qint64 bytesWritten = m_tcpClient->sendData((char*)&config_device_id, length);
    m_tcpClient->waitForRead();
    qDebug() << "bytesWritten: " << bytesWritten;
}
void MainWindow::onConfigDeviceID(){
    QString strTips =QString("请输入0到99之间的数值");

    bool ok = false;
    int value = QInputDialog::getInt(this, tr("输入整数对话框"), strTips, 0, 0, 99, 1, &ok);
    if(!ok) return;

    if(value < 1){
        QMessageBox::information(this, QStringLiteral("提示"), QStringLiteral("请输入正确的数字！"));
        return ;
    }
    DeviceIDConfigReq config_device_id = { {0xAA, 0x55, 0xAA}, kConfigDeviceID, 1,1,{}};
    config_device_id.device_id = value;
    int length = sizeof(DeviceIDConfigReq);
    qint64 bytesWritten = m_tcpClient->sendData((char*)&config_device_id, length);
    m_tcpClient->waitForRead();
    qDebug() << "bytesWritten: " << bytesWritten;
}
void MainWindow::onSetTime(){
    SetTimingReq set_time_req = { {0xAA, 0x55, 0xAA}, kTimingCmd, 1,0 };
    int length = sizeof(SetTimingReq);
    set_time_req.ts = QDateTime::currentSecsSinceEpoch();
    qint64 bytesWritten = m_tcpClient->sendData((char*)&set_time_req, length);
    m_tcpClient->waitForRead();
    qDebug() << "bytesWritten: " << bytesWritten;
}
void MainWindow::UploadConfigFile(uint8_t sub_cmd){
    QMessageBox *box = new QMessageBox(QMessageBox::Question, "提示", "确认上传配置文件？", QMessageBox::Yes | QMessageBox::No, this);
    box->button(QMessageBox::Yes)->setText("确认");
    box->button(QMessageBox::No)->setText("取消");
    int res = box->exec();
    if(QMessageBox::No == res){
        return;
    }
    // 读取文件内容
    if(tsi_config_file == ""){
        QMessageBox::information(this, QStringLiteral("提示"), "请先打开配置文件！");
        return;
    }
    QFile file(tsi_config_file);
    if (!file.open(QIODevice::ReadOnly)) {
        qWarning() << "Failed to open config file.";
        return;
    }
    QByteArray fileData = file.readAll();
    int fileSize = fileData.size();
    if (fileSize > 10 * 1024 * 1024) {
        QMessageBox::information(this, QStringLiteral("提示"), "文件大小超过10M，请重新选择！");
        file.close();
        return;
    }
    qDebug() << "fileSize" << fileSize  ;
    // 创建 PackageHead 结构体
    UploadConfigReq upload_config_req = { {0xAA, 0x55, 0xAA}, kUploadConfigFile,1, fileSize, sub_cmd, 0, {} };
    // 计算文件的 CRC 校验和
    upload_config_req.crc = calculate_crc(fileData);
    upload_config_req.len = fileSize;
    char *send_buf = NULL;
    send_buf = (char *)malloc(sizeof(UploadConfigReq) + fileData.size() + 1);
    memset(send_buf, 0, sizeof(UploadConfigReq) + fileData.size() + 1);
    memcpy(send_buf, &upload_config_req, sizeof(UploadConfigReq));
    memcpy(send_buf + sizeof(UploadConfigReq), fileData.data(), fileData.size());
    int length = sizeof(UploadConfigReq) + fileData.size();
    const int MAX_CHUNK_SIZE = 50 * 1024;  // 50 KB
    qint64 bytesSent = 0;
    qint64 totalBytes = length;
    qDebug() << "totalBytes" << totalBytes   ;
    while (bytesSent < totalBytes) {
        qint64 chunkSize = 0;
        if (MAX_CHUNK_SIZE < totalBytes - bytesSent) {
            chunkSize = MAX_CHUNK_SIZE;
        } else {
            chunkSize = totalBytes - bytesSent;
        }
        qint64 bytesWritten = m_tcpClient->sendData(send_buf + bytesSent, chunkSize);
        qDebug() << "bytesWritten" << bytesWritten << "bytesSent" << bytesSent  << "chunkSize" << chunkSize ;
        if (bytesWritten == -1) {
            break;
        }
        bytesSent += bytesWritten;
    }
    qDebug() << "bytesSent" << bytesSent;
    m_tcpClient->waitForRead();
    file.close();
    if (send_buf != NULL) {
        free(send_buf);
    }
}
void MainWindow::on_pushButton_upload_clicked(){
    UploadConfigFile(0x0);
}


void MainWindow::on_pushButton_upload_config_clicked(){
    UploadConfigFile(0x1);
}