DSCAnalysisTool/src/ui/experimentsettingform.cpp

#include <QtDebug>
#include <QDateTime>

#include "experimentsettingform.h"
#include "ui_experimentsettingform.h"
#include "protocol.h"
#include "dataparser.h"
#include "serialport.h"
#include "global.h"
#include "filemanager.h"
#include "logger.h"

QString extractObjectName(const QString& fullObjectName) {
    return fullObjectName.mid(4);  // 去掉前 4 个字符（"ui->"）
}

#define SET_OBJECT_NAME(WIDGET) \
    WIDGET->setObjectName(extractObjectName(#WIDGET))

ExperimentSettingForm::ExperimentSettingForm(QWidget *parent) : QWidget(parent),
    ui(new Ui::ExperimentSettingForm)
{
    ui->setupUi(this);

    ui->sampleNameLineEdit->setText("new");
    ui->sampleWeightLineEdit->setText("0");
    ui->userLineEdit->setText("user");

    uiReset();

    ui->checkBox_phase_1->setTristate(false);
    ui->checkBox_phase_2->setTristate(false);
    ui->checkBox_phase_3->setTristate(false);
    ui->checkBox_phase_4->setTristate(false);
    ui->checkBox_phase_5->setTristate(false);
    ui->checkBox_phase_6->setTristate(false);

    connect(ui->checkBox_phase_2, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase2StateChanged);
    connect(ui->checkBox_phase_3, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase3StateChanged);
    connect(ui->checkBox_phase_4, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase4StateChanged);
    connect(ui->checkBox_phase_5, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase5StateChanged);
    connect(ui->checkBox_phase_6, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase6StateChanged);

    //    connect(ui->pushButton_connect_to_device,&QPushButton::clicked,
    //            this,&ExperimentSettingForm::slotConnectToDevice);

    connect(ui->pushButton_cancel, &QPushButton::clicked,
            this, &ExperimentSettingForm::slotCancel);
}

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

void ExperimentSettingForm::uiReset()
{
    // init data and status.

    // default value
    ui->phase_1_cutoff_temp->setText("0");
    ui->phase_2_cutoff_temp->setText("0");
    ui->phase_3_cutoff_temp->setText("0");
    ui->phase_4_cutoff_temp->setText("0");
    ui->phase_5_cutoff_temp->setText("0");
    ui->phase_6_cutoff_temp->setText("0");

    ui->phase_1_scan_rate->setText("0");
    ui->phase_2_scan_rate->setText("0");
    ui->phase_3_scan_rate->setText("0");
    ui->phase_4_scan_rate->setText("0");
    ui->phase_5_scan_rate->setText("0");
    ui->phase_6_scan_rate->setText("0");

    ui->phase_1_constant_temp->setText("0");
    ui->phase_2_constant_temp->setText("0");
    ui->phase_3_constant_temp->setText("0");
    ui->phase_4_constant_temp->setText("0");
    ui->phase_5_constant_temp->setText("0");
    ui->phase_6_constant_temp->setText("0");

    ui->comboBox_phase_1_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_2_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_3_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_4_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_5_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_6_atmosphere->setCurrentIndex(0);

    // default enable
    ui->checkBox_phase_1->setChecked(true);
    ui->checkBox_phase_1->setEnabled(false);

    ui->phase_2_cutoff_temp->setEnabled(false);
    ui->phase_3_cutoff_temp->setEnabled(false);
    ui->phase_4_cutoff_temp->setEnabled(false);
    ui->phase_5_cutoff_temp->setEnabled(false);
    ui->phase_6_cutoff_temp->setEnabled(false);

    ui->phase_2_scan_rate->setEnabled(false);
    ui->phase_3_scan_rate->setEnabled(false);
    ui->phase_4_scan_rate->setEnabled(false);
    ui->phase_5_scan_rate->setEnabled(false);
    ui->phase_6_scan_rate->setEnabled(false);

    ui->phase_2_constant_temp->setEnabled(false);
    ui->phase_3_constant_temp->setEnabled(false);
    ui->phase_4_constant_temp->setEnabled(false);
    ui->phase_5_constant_temp->setEnabled(false);
    ui->phase_6_constant_temp->setEnabled(false);

    ui->comboBox_phase_2_atmosphere->setEnabled(false);
    ui->comboBox_phase_3_atmosphere->setEnabled(false);
    ui->comboBox_phase_4_atmosphere->setEnabled(false);
    ui->comboBox_phase_5_atmosphere->setEnabled(false);
    ui->comboBox_phase_6_atmosphere->setEnabled(false);

    ui->radioButton_OIT_not->setChecked(true);

    ui->checkBox_phase_2->setTristate(false);
    ui->checkBox_phase_3->setTristate(false);
    ui->checkBox_phase_4->setTristate(false);
    ui->checkBox_phase_5->setTristate(false);
    ui->checkBox_phase_6->setTristate(false);

    //set objectName
    SET_OBJECT_NAME(ui->checkBox_phase_1);
    SET_OBJECT_NAME(ui->checkBox_phase_2);
    SET_OBJECT_NAME(ui->checkBox_phase_3);
    SET_OBJECT_NAME(ui->checkBox_phase_4);
    SET_OBJECT_NAME(ui->checkBox_phase_5);
    SET_OBJECT_NAME(ui->checkBox_phase_6);

    SET_OBJECT_NAME(ui->phase_1_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_2_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_3_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_4_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_5_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_6_cutoff_temp);

    SET_OBJECT_NAME(ui->phase_1_scan_rate);
    SET_OBJECT_NAME(ui->phase_2_scan_rate);
    SET_OBJECT_NAME(ui->phase_3_scan_rate);
    SET_OBJECT_NAME(ui->phase_4_scan_rate);
    SET_OBJECT_NAME(ui->phase_5_scan_rate);
    SET_OBJECT_NAME(ui->phase_6_scan_rate);

    SET_OBJECT_NAME(ui->phase_1_constant_temp);
    SET_OBJECT_NAME(ui->phase_2_constant_temp);
    SET_OBJECT_NAME(ui->phase_3_constant_temp);
    SET_OBJECT_NAME(ui->phase_4_constant_temp);
    SET_OBJECT_NAME(ui->phase_5_constant_temp);
    SET_OBJECT_NAME(ui->phase_6_constant_temp);

    SET_OBJECT_NAME(ui->comboBox_phase_1_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_2_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_3_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_4_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_5_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_6_atmosphere);

    SET_OBJECT_NAME(ui->radioButton_OIT_not);
    SET_OBJECT_NAME(ui->comboBox_initial_atmosphere);
}

void ExperimentSettingForm::uiSetPhaseEnable(const int index)
{
    switch (index) {
    case 1:
        ui->checkBox_phase_1->setTristate(true);
        ui->phase_1_cutoff_temp->setEnabled(true);
        ui->phase_1_scan_rate->setEnabled(true);
        ui->phase_1_constant_temp->setEnabled(true);
        ui->comboBox_phase_1_atmosphere->setEnabled(true);
        break;
    case 2:
        ui->checkBox_phase_2->setTristate(true);
        ui->phase_2_cutoff_temp->setEnabled(true);
        ui->phase_2_scan_rate->setEnabled(true);
        ui->phase_3_constant_temp->setEnabled(true);
        ui->comboBox_phase_1_atmosphere->setEnabled(true);
        break;
    case 3:
        ui->checkBox_phase_1->setTristate(true);
        ui->phase_1_cutoff_temp->setEnabled(true);
        ui->phase_1_scan_rate->setEnabled(true);
        ui->phase_1_constant_temp->setEnabled(true);
        ui->comboBox_phase_1_atmosphere->setEnabled(true);
        break;
    case 4:
        ui->checkBox_phase_1->setTristate(true);
        ui->phase_1_cutoff_temp->setEnabled(true);
        ui->phase_1_scan_rate->setEnabled(true);
        ui->phase_1_constant_temp->setEnabled(true);
        ui->comboBox_phase_1_atmosphere->setEnabled(true);
        break;
    case 5:
        ui->checkBox_phase_1->setTristate(true);
        ui->phase_1_cutoff_temp->setEnabled(true);
        ui->phase_1_scan_rate->setEnabled(true);
        ui->phase_1_constant_temp->setEnabled(true);
        ui->comboBox_phase_1_atmosphere->setEnabled(true);
        break;
    case 6:
        ui->checkBox_phase_1->setTristate(true);
        ui->phase_1_cutoff_temp->setEnabled(true);
        ui->phase_1_scan_rate->setEnabled(true);
        ui->phase_1_constant_temp->setEnabled(true);
        ui->comboBox_phase_1_atmosphere->setEnabled(true);
        break;
    default:
        break;
    }
}

GasType ExperimentSettingForm::conver2GasType(const int index)
{
    switch (index) {
    case 0: return GasType::NC; break;    // 假设 GAS_AIR 是 gas_type 的枚举值
    case 1: return GasType::N2; break;
    case 2: return GasType::O2; break;
    default: return GasType::NC; break; // 处理未知情况
    }
    return GasType::NC;
}

bool ExperimentSettingForm::phaseCufoffTempAndTempFlowCheck(const int phaseIndex,
                                                            const float prePhaseCufoffTemp,
                                                            const float currentPhaseCufoffTemp,
                                                            const float tempFlow)
{
    if(tempFlow < 0){
        phaseScanRateErrorMesgBox(phaseIndex);
        return false;
    }

    if(prePhaseCufoffTemp != currentPhaseCufoffTemp
            && tempFlow == 0){
        phaseScanRateErrorMesgBox(phaseIndex);
        return false;
    }

    return true;
}

void ExperimentSettingForm::slotPhase2StateChanged(int state)
{
    qDebug() << "slotPhase2StateChanged:" << state;

    if (state == Qt::PartiallyChecked)
    {
        ui->phase_2_cutoff_temp->setEnabled(true);
        ui->phase_2_scan_rate->setEnabled(true);
        ui->phase_2_constant_temp->setEnabled(true);
        ui->comboBox_phase_2_atmosphere->setEnabled(true);
    }
    else
    {
        // unchecked
        if (ui->checkBox_phase_3->isChecked())
        {
            ui->checkBox_phase_2->setChecked(true);
        }
        else
        {
            ui->phase_2_cutoff_temp->setEnabled(false);
            ui->phase_2_scan_rate->setEnabled(false);
            ui->phase_2_constant_temp->setEnabled(false);
            ui->comboBox_phase_2_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotPhase3StateChanged(int state)
{
    if (state == Qt::PartiallyChecked)
    {
        if (ui->checkBox_phase_2->isChecked())
        {
            ui->phase_3_cutoff_temp->setEnabled(true);
            ui->phase_3_scan_rate->setEnabled(true);
            ui->phase_3_constant_temp->setEnabled(true);
            ui->comboBox_phase_3_atmosphere->setEnabled(true);
        }
        else
        {
            ui->checkBox_phase_3->setChecked(false);
        }
    }
    else
    {
        if (ui->checkBox_phase_4->isChecked())
        {
            ui->checkBox_phase_3->setChecked(true);
        }
        else
        {
            ui->phase_3_cutoff_temp->setEnabled(false);
            ui->phase_3_scan_rate->setEnabled(false);
            ui->phase_3_constant_temp->setEnabled(false);
            ui->comboBox_phase_3_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotPhase4StateChanged(int state)
{
    if (state == Qt::PartiallyChecked)
    {
        if (ui->checkBox_phase_3->isChecked())
        {
            ui->phase_4_cutoff_temp->setEnabled(true);
            ui->phase_4_scan_rate->setEnabled(true);
            ui->phase_4_constant_temp->setEnabled(true);
            ui->comboBox_phase_4_atmosphere->setEnabled(true);
        }
        else
        {
            ui->checkBox_phase_4->setChecked(false);
        }
    }
    else
    {
        if (ui->checkBox_phase_5->isChecked())
        {
            ui->checkBox_phase_4->setChecked(true);
        }
        else
        {
            ui->phase_4_cutoff_temp->setEnabled(false);
            ui->phase_4_scan_rate->setEnabled(false);
            ui->phase_4_constant_temp->setEnabled(false);
            ui->comboBox_phase_4_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotPhase5StateChanged(int state)
{
    if (state == Qt::PartiallyChecked)
    {
        if (ui->checkBox_phase_4->isChecked())
        {
            ui->phase_5_cutoff_temp->setEnabled(true);
            ui->phase_5_scan_rate->setEnabled(true);
            ui->phase_5_constant_temp->setEnabled(true);
            ui->comboBox_phase_5_atmosphere->setEnabled(true);
        }
        else
        {
            ui->checkBox_phase_5->setChecked(false);
        }
    }
    else
    {
        if (ui->checkBox_phase_6->isChecked())
        {
            ui->checkBox_phase_5->setChecked(true);
        }
        else
        {
            ui->phase_5_cutoff_temp->setEnabled(false);
            ui->phase_5_scan_rate->setEnabled(false);
            ui->phase_5_constant_temp->setEnabled(false);
            ui->comboBox_phase_5_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotPhase6StateChanged(int state)
{
    qDebug() << "slotPhase2StateChanged:" << state;

    if (state == Qt::PartiallyChecked)
    {
        if (ui->checkBox_phase_5->isChecked())
        {
            ui->phase_6_cutoff_temp->setEnabled(true);
            ui->phase_6_scan_rate->setEnabled(true);
            ui->phase_6_constant_temp->setEnabled(true);
            ui->comboBox_phase_6_atmosphere->setEnabled(true);
        }
        else
        {
            ui->checkBox_phase_6->setChecked(false);
        }
    }
    else
    {
        ui->phase_6_cutoff_temp->setEnabled(false);
        ui->phase_6_scan_rate->setEnabled(false);
        ui->phase_6_constant_temp->setEnabled(false);
        ui->comboBox_phase_6_atmosphere->setEnabled(false);
    }
}

void ExperimentSettingForm::on_pushButton_deliverData_clicked()
{
    float phase1CutoffTemp = 0.0;
    float phase2CutoffTemp = 0.0;
    float phase3CutoffTemp = 0.0;
    float phase4CutoffTemp = 0.0;
    float phase5CutoffTemp = 0.0;
    float phase6CutoffTemp = 0.0;

    QVector<Phase> phaseVtr;
    {
        Phase phase;
        phase.onoff = ui->checkBox_phase_1->checkState()?1:0;
        phase.cutoff_temp = ui->phase_1_cutoff_temp->text().toFloat();
        phase.temp_flow = ui->phase_1_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_1_constant_temp->text().toInt();

        phase.gas = conver2GasType(ui->comboBox_phase_1_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        phase1CutoffTemp = phase.cutoff_temp;
        //
        if(phase.temp_flow <= 0){
            phaseScanRateErrorMesgBox(1);
            return;
        }

    }

    {
        Phase phase;
        phase.onoff = ui->checkBox_phase_2->checkState()?1:0;
        phase.cutoff_temp = ui->phase_2_cutoff_temp->text().toFloat();
        phase.temp_flow = ui->phase_2_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_2_constant_temp->text().toInt();
        phase.gas = conver2GasType(ui->comboBox_phase_2_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if(phase.onoff){
            logde<<"phase 2 enable.";
            phase2CutoffTemp = phase.cutoff_temp;
            if(phase2CutoffTemp < phase1CutoffTemp){
                phaseCufoffTempErrorMesgBox(2);
                return;
            }

            //
#if 0
            if(phase.temp_flow < 0){
                phaseScanRateErrorMesgBox(2);
                return;
            }

            if(phase2CutoffTemp != phase1CutoffTemp
                    && phase.temp_flow == 0){
                phaseScanRateErrorMesgBox(2);
                return;
            }
#endif
            if(!phaseCufoffTempAndTempFlowCheck(2,
                                                phase1CutoffTemp,
                                                phase2CutoffTemp,
                                                phase.temp_flow)){
                return;
            }

        }
    }

    {
        Phase phase;
        phase.onoff = ui->checkBox_phase_3->checkState()?1:0;
        phase.cutoff_temp = ui->phase_3_cutoff_temp->text().toFloat();
        phase.temp_flow = ui->phase_3_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_3_constant_temp->text().toInt();
        phase.gas = conver2GasType(ui->comboBox_phase_3_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if(phase.onoff){
            logde<<"phase 3 enable.";
            phase3CutoffTemp = phase.cutoff_temp;
            if(phase3CutoffTemp < phase2CutoffTemp){
                phaseCufoffTempErrorMesgBox(3);
                return;
            }
#if 0
            if(phase.temp_flow <= 0){
                phaseScanRateErrorMesgBox(3);
                return;
            }
#endif
            if(!phaseCufoffTempAndTempFlowCheck(3,
                                                phase2CutoffTemp,
                                                phase3CutoffTemp,
                                                phase.temp_flow)){
                return;
            }
        }
    }

    {
        Phase phase;
        phase.onoff = ui->checkBox_phase_4->checkState()?1:0;
        phase.cutoff_temp = ui->phase_4_cutoff_temp->text().toFloat();
        phase.temp_flow = ui->phase_4_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_4_constant_temp->text().toInt();
        phase.gas = conver2GasType(ui->comboBox_phase_4_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if(phase.onoff){
            logde<<"phase 4 enable.";
            phase4CutoffTemp = phase.cutoff_temp;
            if(phase4CutoffTemp < phase3CutoffTemp){
                phaseCufoffTempErrorMesgBox(4);
                return;
            }
#if 0
            if(phase.temp_flow <= 0){
                phaseScanRateErrorMesgBox(4);
                return;
            }
#endif
            if(!phaseCufoffTempAndTempFlowCheck(4,
                                                phase3CutoffTemp,
                                                phase4CutoffTemp,
                                                phase.temp_flow)){
                return;
            }
        }
    }

    {
        Phase phase;
        phase.onoff = ui->checkBox_phase_5->checkState()?1:0;
        phase.cutoff_temp = ui->phase_5_cutoff_temp->text().toFloat();
        phase.temp_flow = ui->phase_5_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_5_constant_temp->text().toInt();
        phase.gas = conver2GasType(ui->comboBox_phase_5_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if(phase.onoff){
            logde<<"phase 5 enable.";
            phase5CutoffTemp = phase.cutoff_temp;
            if(phase5CutoffTemp < phase4CutoffTemp){
                phaseCufoffTempErrorMesgBox(5);
                return;
            }
#if 0
            if(phase.temp_flow <= 0){
                phaseScanRateErrorMesgBox(5);
                return;
            }
#endif
            if(!phaseCufoffTempAndTempFlowCheck(5,
                                                phase4CutoffTemp,
                                                phase5CutoffTemp,
                                                phase.temp_flow)){
                return;
            }
        }
    }

    {
        Phase phase;
        phase.onoff = ui->checkBox_phase_6->checkState()?1:0;
        phase.cutoff_temp = ui->phase_6_cutoff_temp->text().toFloat();
        phase.temp_flow = ui->phase_6_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_6_constant_temp->text().toInt();
        phase.gas = conver2GasType(ui->comboBox_phase_6_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if(phase.onoff){
            logde<<"phase 6 enable.";
            phase6CutoffTemp = phase.cutoff_temp;
            if(phase6CutoffTemp < phase5CutoffTemp){
                phaseCufoffTempErrorMesgBox(6);
                return;
            }
#if 0
            if(phase.temp_flow <= 0){
                phaseScanRateErrorMesgBox(6);
                return;
            }
#endif
            if(!phaseCufoffTempAndTempFlowCheck(6,
                                                phase5CutoffTemp,
                                                phase6CutoffTemp,
                                                phase.temp_flow)){
                return;
            }
        }
    }
    //
    Global::ExperimentInfo& ei = Global::_experimentInfo;
    ei.sampleName = ui->sampleNameLineEdit->text();
    ei.sampleWeight = ui->sampleWeightLineEdit->text();
    ei.date = ui->dateTimeLineEdit->text();
    ei.experimentor = ui->userLineEdit->text();

#if 0
    ei.phaseVtr = phaseVtr;
    if(ui->radioButton_OIT->isChecked()){
        ei.testType = Global::TestType::OIT;
    } else if(ui->radioButton_OIT_not->isChecked()){
        ei.testType = Global::TestType::NoneOIT;
    }

    ei.initialAtmosPhere = (GasType)(ui->comboBox_phase_1_atmosphere->currentIndex());
#endif

    // initial data.
    QByteArray initialBa;
    if(ui->radioButton_OIT->isChecked()){
        initialBa.append((char)0);

        Global::_experimentOITFlag = true;

        logde<<"Global::_experimentOITFlag = true;";
    }else{
        initialBa.append((char)1);

        Global::_experimentOITFlag = false;

        logde<<"Global::_experimentOITFlag = false;";
    }

    char index = ui->comboBox_initial_atmosphere->currentIndex();
    initialBa.append(index);

    //
    QByteArray ba = DataParser::setExperimentInfo(phaseVtr,initialBa);

    qDebug() << "ba size:" << ba.size();

    emit sigDeliverData(ba);
    hide();
}

void ExperimentSettingForm::slotCancel()
{
    hide();
}

void ExperimentSettingForm::phaseCufoffTempErrorMesgBox(const int phaseNum)
{
    QString title = QString("阶段%1截止温度错误").arg(QString::number(phaseNum));
    QString text = QString("阶段%1截止温度不能小于上一阶段截止温度!  ").arg(QString::number(phaseNum));
    QMessageBox::question(this, title, text,
                          QMessageBox::Yes);
}

void ExperimentSettingForm::phaseScanRateErrorMesgBox(const int phaseNum)
{
    QString title = QString("阶段%1扫描速率错误").arg(QString::number(phaseNum));
    QString text = QString("阶段%1扫描速率必须大于0!  ").arg(QString::number(phaseNum));
    QMessageBox::question(this, title, text,
                          QMessageBox::Yes);
}
void ExperimentSettingForm::slotPhaseCheck()
{
    if (sender() == ui->checkBox_phase_2)
    {
        if (ui->checkBox_phase_2->isChecked())
        {
            ui->phase_2_cutoff_temp->setEnabled(true);
            ui->phase_2_scan_rate->setEnabled(true);
            ui->phase_2_constant_temp->setEnabled(true);
            ui->comboBox_phase_2_atmosphere->setEnabled(true);
        }
        else
        {
            ui->phase_2_cutoff_temp->setEnabled(false);
            ui->phase_2_scan_rate->setEnabled(false);
            ui->phase_2_constant_temp->setEnabled(false);
            ui->comboBox_phase_2_atmosphere->setEnabled(false);
        }
    }
    else if (sender() == ui->checkBox_phase_3)
    {
        if (ui->checkBox_phase_3->isChecked())
        {
            ui->phase_3_cutoff_temp->setEnabled(true);
            ui->phase_3_scan_rate->setEnabled(true);
            ui->phase_3_constant_temp->setEnabled(true);
            ui->comboBox_phase_3_atmosphere->setEnabled(true);
        }
        else
        {
            ui->phase_3_cutoff_temp->setEnabled(false);
            ui->phase_3_scan_rate->setEnabled(false);
            ui->phase_3_constant_temp->setEnabled(false);
            ui->comboBox_phase_3_atmosphere->setEnabled(false);
        }
    }
    else if (sender() == ui->checkBox_phase_4)
    {
        if (ui->checkBox_phase_4->isChecked())
        {
            ui->phase_4_cutoff_temp->setEnabled(true);
            ui->phase_4_scan_rate->setEnabled(true);
            ui->phase_4_constant_temp->setEnabled(true);
            ui->comboBox_phase_4_atmosphere->setEnabled(true);
        }
        else
        {
            ui->phase_4_cutoff_temp->setEnabled(false);
            ui->phase_4_scan_rate->setEnabled(false);
            ui->phase_4_constant_temp->setEnabled(false);
            ui->comboBox_phase_4_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotRecvPhaseInfo(const QByteArray &ba)
{
    logde<<"----------------------- recv";
    QString hexData = ba.toHex(' '); // ' ' 作为分隔符，可选参数
    qDebug() << "slotRecvPhaseInfo hex:" << hexData;

    QByteArray localba = ba;
    SerialPortProtocol *spp = (SerialPortProtocol *)localba.data();

    u8 *data = spp->data_buf;

    int phaseSize = spp->len / PHASE_BYTE_SIZE;

    QVector<Phase> phaseVtr;
    for (int i = 0; i < phaseSize; i++)
    {
#if 0
        Phase *phase = (Phase *)(data + i * PHASE_BYTE_SIZE);
        phaseVtr.push_back(*phase);
#endif

#if 0
        u8* localData = data + i * PHASE_BYTE_SIZE;
        int index = 0;

        Phase phase;
        phase.onoff         = *(localData + index);
        index += 1;

        phase.cutoff_temp   = (float)*(localData + index);
        index += 4;

        phase.temp_flow     = (float)*(localData + index);
        index += 4;

        phase.constant_temp_time_min = (u16)*(localData + index);
        index += 2;

        //        phase.gas = (int)*(localData + index);
        int gasType= (u8)*(localData + index);

        switch(gasType){
        case GasType::NC:
            phase.gas = GasType::NC;
            break;
        case GasType::N2:
            phase.gas = GasType::N2;
            break;
        case GasType::O2:
            phase.gas = GasType::O2;
            break;
        default:
            break;
        }

        phaseVtr.push_back(phase);
#endif
        uint8_t* localData = data + i * PHASE_BYTE_SIZE;
        int index = 0;

        Phase phase;
        // 解析 onoff
        //        phase.onoff = *(localData + index);
        memcpy(&phase.onoff, localData + index, sizeof(uint8_t));
        index += sizeof(uint8_t);

        // 解析 cutoff_temp
        memcpy(&phase.cutoff_temp, localData + index, sizeof(float));
        index += sizeof(float);

        // 解析 temp_flow
        memcpy(&phase.temp_flow, localData + index, sizeof(float));
        index += sizeof(float);

        // 解析 constant_temp_time_min
        memcpy(&phase.constant_temp_time_min, localData + index, sizeof(uint16_t));
        index += sizeof(uint16_t);

        // 解析 gas
        uint8_t gasType = *(localData + index);
        switch (gasType) {
        case NC:
            phase.gas = NC;
            break;
        case N2:
            phase.gas = N2;
            break;
        case O2:
            phase.gas = O2;
            break;
        default:
            phase.gas = NC; // 默认值，表示未知类型
            break;
        }
        phaseVtr.push_back(phase);
    }

    Global::_experimentInfo.phaseVtr = phaseVtr;

    //ui update
    //    logde<<"phaseVtr size:"<<phaseVtr.size();

    uiReset();

    for(int i = 0; i< phaseVtr.size();){
        const Phase &phase = phaseVtr[i];
        if(phase.onoff == 0){
            break;
        }

        i++;
        //        qDebug()<<"index :"<<i;

        QString checkBoxName = QString("checkBox_phase_%1").arg(i);
        QCheckBox *checkBox_phase = qobject_cast<QCheckBox*>(this->findChild<QObject*>(checkBoxName));
        if (checkBox_phase) {
            checkBox_phase->setChecked(true);
            //            qDebug()<<"found...";
        }else{
            //            qDebug()<<"not found...";
        }

        QString cutOffTempLineEditName = QString("phase_%1_cutoff_temp").arg(i);
        QLineEdit *cutOffTempLineEdit = qobject_cast<QLineEdit*>(this->findChild<QObject*>(cutOffTempLineEditName));
        if(cutOffTempLineEdit){
            cutOffTempLineEdit->setText(QString::number(phase.cutoff_temp,'f',3));
            cutOffTempLineEdit->setEnabled(true);
        }

        QString scanRateLineEditName = QString("phase_%1_scan_rate").arg(i);
        QLineEdit *scanRateLineEdit =
                qobject_cast<QLineEdit*>(this->findChild<QObject*>(scanRateLineEditName));
        if(scanRateLineEdit){
            scanRateLineEdit->setText(QString::number(phase.temp_flow,'f',3));
            scanRateLineEdit->setEnabled(true);
        }
        QString constantTempLineEditName = QString("phase_%1_constant_temp").arg(i);
        QLineEdit *constantTempLineEdit =
                qobject_cast<QLineEdit*>(this->findChild<QObject*>(constantTempLineEditName));
        if(constantTempLineEdit){
            constantTempLineEdit->setText(QString::number(phase.constant_temp_time_min));
            constantTempLineEdit->setEnabled(true);
        }
        QString atmoshpereComboBoxName = QString("comboBox_phase_%1_atmosphere").arg(i);
        QComboBox *atmoshpereComboBox =
                qobject_cast<QComboBox*>(this->findChild<QObject*>(atmoshpereComboBoxName));
        if(atmoshpereComboBox){
            atmoshpereComboBox->setCurrentIndex(phase.gas % 256);
            atmoshpereComboBox->setEnabled(true);
        }
    }
    //
    //    radioButton_OIT_not
    //    radioButton_OIT
    //    comboBox_initial_atmosphere

    u8 *oitValue = (data + 72);
    logde<<"oit value:"<<(int)*oitValue;

    if(*oitValue){
        ui->radioButton_OIT->setChecked(false);
        ui->radioButton_OIT_not->setChecked(true);
#if 0
        QString oitRadioButtonName("radioButton_OIT");
        QRadioButton *oitRadioButton =
                qobject_cast<QRadioButton*>(this->findChild<QObject*>(oitRadioButtonName));
        if(oitRadioButton){
            oitRadioButton->setChecked(true);
        }
#endif
    }else{
        ui->radioButton_OIT->setChecked(true);
        ui->radioButton_OIT_not->setChecked(false);
        Global::_experimentOITFlag = true;

        logde<<"Global::_experimentOITFlag = true;";
#if 0
        QString oitNotRadioButtonName("radioButton_OIT_not");
        QRadioButton *oitNotRadioButton =
                qobject_cast<QRadioButton*>(this->findChild<QObject*>(oitNotRadioButtonName));
        if(oitNotRadioButton){
            oitNotRadioButton->setChecked(true);
        }
#endif
    }

    u8 *initAtmosphereValue = (data + 73);
    logde<<"initAtmosphereValue:"<< (int)(*initAtmosphereValue);
    ui->comboBox_initial_atmosphere->setCurrentIndex((int)*initAtmosphereValue);

#if 0
    QString initialAtmosphereComboBoxObjectName("comboBox_initial_atmosphere");
    QComboBox *initialAtmosphereComboBox =
            qobject_cast<QComboBox*>(this->findChild<QObject*>(initialAtmosphereComboBoxObjectName));
    if(initialAtmosphereComboBox){
        initialAtmosphereComboBox->setCurrentIndex(*initAtmosphereValue);
    }
#endif


}

void ExperimentSettingForm::showEvent(QShowEvent *event)
{
    QDateTime currentDateTime = QDateTime::currentDateTime();
    QString internationalFormat = currentDateTime.toString("yyyy/MM/dd hh:mm:ss");

    ui->dateTimeLineEdit->setText(internationalFormat);
}