#include "InkJetPrinter.h"
#include "ui_inkjetprinter.h"
#include "QDebug"
#include "LogInfo.h"
#include "mainwindow.h"
#include "DlgVolteParaNo73.h"
#include "DlgVoltePara25Dots.h"
#include "./Network/NetworkManager.h"
#include "ZkEdit.h"
#include "myinclude.h"
#include <QFile>
#include <QPushButton>
#include <iostream>
#include <string>
#include <cmath>

#define MAX_VOL		300
#define MIN_VOL		0
void PID_init();
#define ONLYCNTCLEAR
extern MyInputMethod *myInputMethod;
static bool firstTime = true;
static unsigned int PulseCnt = 0; //时间间隔内的脉冲累计数
InkJetPrinter::InkJetPrinter(QWidget *parent) :
    QTabWidget(parent),
    ui(new Ui::InkJetPrinter)
{
    // 隐藏系统任务栏，隐藏后，如果需要激活任务栏，则需要呼出QtUI中的任意弹出式、非全屏窗口，然后使用鼠标将光标移动至屏幕最左侧或最顶部则可以呼出任务栏
    int ret = system("xfconf-query -c xfce4-panel -p /panels/panel-1/autohide-behavior -s 2");
    qInfo() << "Hide system panel ret:" << ret;

//    system("ifconfig eth1 down");
    ui->setupUi(this);
    SysPara *para = new SysPara();
    bindSysPara(para);
    ui->tabMainWindow->bindSysPara(para);
    sysPara->status.InkOrSOLVEmptyCnt=0;

    t1.start();//calandar_and_dat_t
    fileTransceiv = new FileTranseceiver(5001);
    QObject::connect(fileTransceiv,SIGNAL(fileRecieved(QString)),this,SLOT(recievedFile2Save(QString)));
    fileTransceiv->start();

    //edit@12-30
    tcpTransceiv = new FileTranseceiver(5002);
    tcpTransceiv->start();


    connect(ui->tabMainWindow,SIGNAL(closeSerial()),this,SLOT(closedSerial()));
    qDebug()<<"main thread id:"<< QString("0x%1").arg(reinterpret_cast<quintptr>(QThread::currentThreadId()), 0, 16);

    m_serialThreadFPGA = new QThread;
    serialFPGA = new Serial("/dev/ttyAS5");

    connect(m_serialThreadFPGA,&QThread::started,serialFPGA,&Serial::startInitSlot);

    serialFPGA->moveToThread(m_serialThreadFPGA);
    connect(serialFPGA,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendFPGADate(int,int,unsigned char*,int,int)));
    connect(serialFPGA,SIGNAL(resendFPGAData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendFPGADate(int,int,unsigned char*,int,int)));
    connect(sysPara->devOp,SIGNAL(sendSerialDataToFPGA(int,int,unsigned char*,int,int)),serialFPGA,SLOT(sendSerialData(int,int,unsigned char*,int,int)),Qt::QueuedConnection);
    connect(serialFPGA,SIGNAL(getFPGAVersion(uint)),this,SLOT(saveFPGAVersionNum(uint)));
    
    connect(serialFPGA,SIGNAL(stopSendData(bool)),this,SLOT(stopSendFPGAData(bool)));
    connect(serialFPGA,SIGNAL(getFPGAPhaseDetectHighTm(unsigned char*)),this,SLOT(saveFPGAPhaseDetectHighTm(unsigned char*)));
    connect(serialFPGA,SIGNAL(getFPGAStatus(unsigned char*)),this,SLOT(saveFPGAStatus(unsigned char*)));
    connect(serialFPGA,SIGNAL(getFPGACalandarAndDat(unsigned char*)),this,SLOT(saveFPGACalandarAndDat(unsigned char*)));
    connect(serialFPGA,SIGNAL(getFPGACnt3CurrValue(unsigned char*)),this,SLOT(saveFPGACnt3CurrValue(unsigned char*)));
    connect(serialFPGA,SIGNAL(getFPGAXXXDay(unsigned char*)),this,SLOT(saveFPGAXXXDay(unsigned char*)));
    connect(serialFPGA,SIGNAL(queueSizeFPGA(int)),ui->tabMainWindow,SLOT(showFPGAqueuesize(int)));
    connect(serialFPGA,SIGNAL(queueFPGASizeSIG(int)),ui->tabMainWindow,SLOT(showqueueFPGAsize(int)));
    connect(serialFPGA, &Serial::FPGABuildDat, this, [this](int buildTime){
        sysPara->status.build_dat.builTime = quint16(buildTime);
        qDebug() << "FPGA build time: " << buildTime;
    });

    m_serialThreadSTM32 = new QThread();
    serialSTM32 = new Serial("/dev/ttyAS2");

    connect(m_serialThreadSTM32,&QThread::started,serialSTM32,&Serial::startInitSlot);

    serialSTM32->moveToThread(m_serialThreadSTM32);
    connect(serialSTM32,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendSTM32Date(int,int,unsigned char*,int,int)));
    connect(sysPara->devOp,SIGNAL(sendSerialDataToSTM32(int,int,unsigned char*,int,int)),serialSTM32,SLOT(sendSerialData(int,int,unsigned char*,int,int)));
    connect(serialSTM32,SIGNAL(getSTM32Status(unsigned char*)),this,SLOT(saveSTM32Status(unsigned char*)));
    connect(serialSTM32,SIGNAL(getGearPumpVal(unsigned char*)),this,SLOT(saveGearPumpVal(unsigned char*)));
    connect(serialSTM32,SIGNAL(getPulseCnt(unsigned char*)),this,SLOT(savePulseCntVal(unsigned char*)));
    connect(serialSTM32,SIGNAL(getSTM32Version(unsigned char*)),this,SLOT(saveSTM32Version(unsigned char*)));
    connect(serialSTM32,SIGNAL(getSTM32Time(unsigned char*)),this,SLOT(saveSTM32Time(unsigned char*)));
    connect(serialSTM32,SIGNAL(stopSendData(bool)),this,SLOT(stopSendSTM32Data(bool)));
    connect(serialSTM32,SIGNAL(powerOffReady()),ui->tabMainWindow,SLOT(powerOffConfirmed()));
    
    connect(serialSTM32,SIGNAL(queueSizeSTM32(int)),ui->tabMainWindow,SLOT(showSTM32queuesize(int)));
    connect(ui->tabSystemManage,SIGNAL(upgradeSTM32(QString)),serialSTM32,SLOT(upgradeSTM32File(QString)));
    connect(ui->tabSystemManage,SIGNAL(enableClick(bool)),this,SLOT(enableInkJetTabClick(bool)));
    connect(serialSTM32,SIGNAL(progress(int,int)),ui->tabSystemManage,SLOT(progressBarControl(int,int)));

    connect(serialSTM32, &Serial::STM32Connected, this, [this](bool ok, QString errStr){
        if(!ok || !sysPara || !sysPara->devOp) {
            return;
        }

        QTimer::singleShot(1000, this, [this](){
            sysPara->devOp->highVoltageCtrl(0);
            LogInfo::setRunStatusText("High voltage forced off at app boot");
        });
        
    }, Qt::QueuedConnection);

    connect(ui->tabSystemManage,SIGNAL(sigToCloseSerialFPGA()),this,SLOT(closeSerialFPGA()));
    connect(ui->tabSystemManage,SIGNAL(sigToCloseSerialSTM32()),this,SLOT(closeSerialSTM32()));
    connect(ui->tabSystemManage,SIGNAL(restartSerial()),this,SLOT(restartSerialPort()));
    flagOfSerialThreadStratEn = true;

    connect(this,SIGNAL(showReclaimTankstatus(unsigned char)),ui->tabPrintSetting,SLOT(showReclaimTankstatusslot(unsigned char)));
    connect(this,SIGNAL(showMotorIsen(int,int)),ui->tabPrintSetting,SLOT(showMotorIsenVal(int,int)));
    connect(ui->tabPrintSetting,SIGNAL(HiddenFunction(bool)),ui->tabMainWindow->getTexteditOption(),SLOT(SetHiddenValue(bool)));
    ui->tabMainWindow->SetEditMode(sysPara->para.EditMode);
    ui->tabOtherInfo->bindSysPara(para);
    ui->tabPrintSetting->bindSysPara(para);
    ui->tabSystemSetting->bindSysPara(para);
    ui->tabOtherInfo->bindSysPara(para);
    ui->tabTriggerMode->bindSysPara(para);
    ui->tabSystemManage->bindSysPara(para);
    ui->tabPicEdit->bindSysPara(para);
    ui->tabNetworkManager->bindSysPara(para);

//---------------------------------------------------------------------------
// byons电压调整部分

    voltePara25DotsDlg = nullptr;
    no73VolteParaDlg = nullptr;
    if (sysPara && sysPara->devOp) {
        #ifdef ENB_VOLTAGE_ADJUST_NO72
        voltePara25DotsDlg = new DlgVoltePara25Dots(sysPara->devOp, this);
        voltePara25DotsDlg->setWindowFlags(Qt::Widget);
        voltePara25DotsDlg->setAttribute(Qt::WA_DeleteOnClose, false);
        voltePara25DotsDlg->bindSysPara(sysPara);
        voltePara25DotsDlg->onBtnLoadClicked();
        insertTab(1, voltePara25DotsDlg, tr("电压调整No72"));
        #endif

        #ifdef ENB_VOLTAGE_ADJUST_NO73
        no73VolteParaDlg = new DlgVolteParaNo73(sysPara->devOp, this);
        no73VolteParaDlg->setWindowFlags(Qt::Widget);
        no73VolteParaDlg->setAttribute(Qt::WA_DeleteOnClose, false);
        no73VolteParaDlg->bindSysPara(sysPara);
        no73VolteParaDlg->onBtnLoadClicked();
        insertTab(1, no73VolteParaDlg, tr("电压调整No73"));
        #endif
    }

//end voltage---------------------------------------------------------------------------

    ui->tabSystemManage->loadKeyBoardType();

    //以下两个信号要在(ui->tabMainWindow->updateSysParaToUI();)之前绑定,否则获取不到文本框的更新值
    connect (ui->tabTriggerMode,SIGNAL(autoUpdateFontWidthByTriggerCtrl(const unsigned int)),ui->tabPrintSetting,SLOT(autoUpdateFontWidth(const unsigned int)));
    connect (ui->tabMainWindow,SIGNAL(autoUpdateFontWidthByMainWindow(const unsigned int)),ui->tabPrintSetting,SLOT(autoUpdateFontWidth(const unsigned int)));
    connect(ui->tabMainWindow,SIGNAL(readFPGAVersionReady()),ui->tabPrintSetting,SLOT(getFpgaVersionSetDisable()));
    ui->tabMainWindow->updateSysParaToUI();

    ui->tabPrintSetting->updateSysParaToUI();
    ui->tabSystemSetting->updateSysParaToUI();
    ui->tabOtherInfo->updateSysParaToUI();
    ui->tabTriggerMode->updateSysParaToUI();

    dlgShowMsg =new DlgShowMsg;
    dlgShowMsg->hide();

#ifdef __RFID_CARD
    initRFIDManager();
#endif
    timer = new QTimer();
    connect(timer, SIGNAL(timeout()), this, SLOT(timerHandler()));
    timer->start(10);

    qDebug()<<"timer status:"<<timer->isActive();

    viscosity_timer = new QTimer();
    connect(viscosity_timer, SIGNAL(timeout()), this, SLOT(viscosity_timerHandler()));

    if(sysPara->para.gearPumpEnable)
    {
        pushButtonStartFlag = true;
    }

    connect(this,SIGNAL(currentChanged(int)),this,SLOT(onInkJetPrinterCurrentChanged(int)));
    connect(this,SIGNAL(setReclaimTankCurrentPos(int)),ui->tabMainWindow,SLOT(onReclainTankPositionChanged(int)));

    connect(this,SIGNAL(reclaimTankCloseDone()),ui->tabMainWindow,SLOT(checkForPowerOff()));
    connect(this,SIGNAL(reclaimTankBlock()),this,SLOT(onReclaimTankBlock()));
    connect(ui->tabPrintSetting,SIGNAL(authChanged(int)),this,SLOT(onAuthChanged(int)));
    connect (this,SIGNAL(sendPicScene(PicScene*)),ui->tabPrintSetting,SLOT(updateUIForSpecialCondition(PicScene*)));

    connect(ui->tabPrintSetting,SIGNAL(authChanged(int)),ui->tabOtherInfo,SLOT(onAuthChanged(int)));
    //test
    connect(ui->tabMainWindow,SIGNAL(InkjetCleanUP()),ui->tabSystemSetting,SLOT(on_pushButtonCleanUP_pressed()));
    connect(ui->tabMainWindow,SIGNAL(clearPressureFault()),this,SLOT(resetPressureCnt()));
    connect(ui->tabSystemSetting,SIGNAL(pressureAdjust()),this,SLOT(pressureAdjustForsystemseeting()));

#ifdef COUNTER1_BY_GROUP /* 分段计米 */
    connect(this,SIGNAL(updateCnt1GroupDisp(bool)),
            ui->tabPrintSetting,SLOT(onUpdateCnt1GroupDisp(bool)));
#endif
    initCntGroup();

    msgtest = new QMessageBox(this);
    connect(msgtest, SIGNAL(finished(int)), this, SLOT(OnFinished(int)));
    msgBox1 = new QMessageBox(this);
    connect(msgBox1, SIGNAL(finished(int)), this, SLOT(OnBoxFinished(int)));

    connect(ui->tabPrintSetting->dlgInputAddr,SIGNAL(printErrorStatus(QString,unsigned int)),this,SLOT(onPrintErrorStatus(QString,unsigned int)));//
    connect(ui->tabSystemSetting,SIGNAL(changeEditMode(int)),this,SLOT(onchangeEditMode(int)));
    connect(ui->tabSystemSetting,SIGNAL(setRunStatus(QString )),ui->tabMainWindow,SLOT(setRunStatus(QString)));

    connect(ui->tabPrintSetting->dlgInputAddr,SIGNAL(changeMac(QString)),ui->tabMainWindow,SLOT(UpdateUIVersion()));
    connect(ui->tabSystemManage,SIGNAL(enableReclaimButton(bool)),ui->tabMainWindow,SLOT(onEnableReclaimCtrlButton(bool)));
    connect(ui->tabSystemManage,SIGNAL(configChanged(void)),this,SLOT(onConfigChanged(void)));
    connect(ui->tabPrintSetting, SIGNAL(change_OutputPulse()), ui->tabTriggerMode, SLOT(OutputPulse()));
    connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabPrintSetting,SLOT( PrintupdateSysParaToUI() ));
    connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabSystemSetting,SLOT( SystemupdateSysParaToUI() ));
    connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabOtherInfo,SLOT( OtherupdateSysParaToUI() ));
    connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabTriggerMode,SLOT( TriggerupdateSysParaToUI() ));
    connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabMainWindow->getTexteditOption(),SLOT( updateSysParaToZero() ));
    connect (ui->tabMainWindow,SIGNAL(setMainTabNow(int)),this,SLOT(setCurrentIndex(int)));
    //if(sysPara->para.EditMode==PICFILE){
    connect(ui->tabPrintSetting,SIGNAL(authChanged(int)),ui->tabPicEdit,SLOT(updateAuthorization(int)));// 字库编辑使能
    connect (ui->tabPicEdit,SIGNAL(setMainTabNow(int)),this,SLOT(setCurrentIndex(int)));
    connect (ui->tabPicEdit ,SIGNAL(openCurrentFile (QString ,bool )),ui->tabMainWindow,SLOT(openPicFIleOpen(QString ,bool )));
    connect (ui->tabMainWindow,SIGNAL(openCurrFile(QString)),ui->tabPicEdit,SLOT( EditCurrFile(QString)));
    connect (ui->tabPicEdit ,SIGNAL(setMainTabEdit (int)),ui->tabMainWindow,SLOT(SetMainTabEdit(int)));
    //}
    //connect (ui->tabPrintSetting,SIGNAL(setMainTabNow(int)),this,SLOT(setCurrentIndex(int)));

    connect (ui->tabMainWindow,SIGNAL(openCurrFile(QString)),this,SLOT(onChangeTab(QString)));

    connect(ui->tabPrintSetting,SIGNAL(checkPrintIntervalSignal()),ui->tabMainWindow,SLOT(checkPrintingInterval()));
    connect(ui->tabTriggerMode,SIGNAL(checkPrintIntervalSignal()),ui->tabMainWindow,SLOT(checkPrintingInterval()));

    connect (ui->tabMainWindow,SIGNAL(CloseJd()),this,SLOT(close_jd_timer()));
    connect (ui->tabMainWindow,SIGNAL(pushButtonStartPressed(bool)),this,SLOT(handlePushButtonStartPressed(bool)));
    connect (ui->tabMainWindow,SIGNAL(repeatInitedPid()),this,SLOT(handleInitedPID()));
    connect (ui->tabMainWindow,SIGNAL(setCNT1Select(bool)),ui->tabPrintSetting,SLOT(setCNT1BackColor(bool)));
    connect (ui->tabMainWindow,SIGNAL(setCNT2Select(bool)),ui->tabPrintSetting,SLOT(setCNT2BackColor(bool)));
    connect (ui->tabMainWindow,SIGNAL(setCNT3Select(bool)),ui->tabPrintSetting,SLOT(setCNT3BackColor(bool)));
    connect(ui->tabMainWindow,SIGNAL(setDisableAll()),this,SLOT(disableTabClick()));

    connect(ui->tabPrintSetting,SIGNAL(engineerMode(bool)),ui->tabSystemManage,SLOT(engieerModeAcceptSystemManage(bool)));
    connect(ui->tabPrintSetting, SIGNAL(engineerMode(bool)), ui->tabSystemSetting, SLOT(setFreqFixVisible(bool)));

    sysPara->status.rWarnViscoReady=0;

    // hlp: 260608: 以授权为标准，不过度开放权限
    onAuthChanged(AUTH_NONE);
//    onAuthChanged(AUTH_NONE | AUTH_SUPER_USER2 |AUTH_DISPLAY_SYSTEM_SETTING| 0xffff);


    sysPara->status.WorkTimeOut=0;
    ui->tabMainWindow->changeEditMode(0);
    emit onchangeEditMode(0);   // 20140912
    sysPara->devOp->printCtrl( PRINT_CTRL_STOP);
#ifdef MYTEST
    onAuthChanged(AUTH_NONE | AUTH_SUPER_USER2 |AUTH_DISPLAY_SYSTEM_SETTING| 0xffff);
#else
    ui->tabMainWindow->on_pushButtonReclaimTankClose_pressed();
#endif
    sysPara->status.viscosityFaultCnt=0;
    setCurrentIndex(0);
    sysPara->status.updateSoftEN=0;
    sysPara->status.adjHightVolInitEN=0;
    sysPara->status.FileChangeRestCntFlag=0;
    sysPara->status.HVFaultCloseEn=0;
    sysPara->devOp->printCtrl( PRINT_CTRL_STOP);
    sysPara->devOp->writeFpgaCalandar(1);
    //qDebug()<<sysPara->para.calandar_and_dat.year;
    sysPara->status.cnt1GroupRunningIndex=0;
    //sysPara->status.cnt1RepeatCurrent=0;
    sysPara->status.cnt1GroupCurrentLoop=0;

    //JSON data
    connect(ui->tabNetworkManager, SIGNAL(updateJSONData()), ui->tabMainWindow, SLOT(JSON_UpdateDATA()), Qt::QueuedConnection);
    connect(ui->tabNetworkManager,SIGNAL(net_stopPrint()),ui->tabMainWindow,SLOT(on_pushButtonStopPrint_pressed()), Qt::QueuedConnection);
    connect(ui->tabMainWindow,SIGNAL(getJSONData()),ui->tabNetworkManager,SLOT(on_GetJsonpushButton_clicked()), Qt::QueuedConnection);
    connect(ui->tabNetworkManager,SIGNAL(OpenNewFile()),ui->tabMainWindow->getTexteditOption(),SLOT(onOpenNewFile()), Qt::QueuedConnection);
    //JSON data
#ifdef MODBUS

    modbus = NULL;
    memset((uint8_t *)&sysPara->modbusParas, 0, sizeof(sysPara->modbusParas));
    sysPara->modbusStatus.receiveEnbleFlag = 1;
    snprintf((char *)sysPara->modbusParas.selectFileName, sizeof(sysPara->modbusParas.selectFileName), "%s",QFileInfo(sysPara->para.lastOpenedFileName).fileName().toLatin1().constData());
    modbus = new ModbusTcp(&sysPara->modbusParas, &sysPara->modbusStatus);
    m_thread = new QThread();
    modbus->moveToThread(m_thread);
    connect(m_thread, SIGNAL(started()),modbus,SLOT(pvPollingThread()));
    connect(modbus, SIGNAL(updateQRcode()), ui->tabMainWindow, SLOT(modbusUpdateQRCode()), Qt::QueuedConnection);
    connect(modbus, SIGNAL(openFile(QString,bool)), ui->tabMainWindow->getTexteditOption(), SLOT(onFileOpen(QString,bool)), Qt::QueuedConnection);
    connect(modbus, SIGNAL(startPrint()), ui->tabMainWindow, SLOT(on_pushButtonStartPrint_pressed()), Qt::QueuedConnection);
    connect(modbus, SIGNAL(pausePrint()), ui->tabMainWindow, SLOT(on_pushButtonPausePrint_pressed()), Qt::QueuedConnection);//暂时屏蔽排除问题
    connect(modbus,SIGNAL(stopPrint()),ui->tabMainWindow,SLOT(on_pushButtonStopPrint_pressed()), Qt::QueuedConnection);
    connect(modbus,SIGNAL(writeCalendar()),this,SLOT(onModbusWriteCalendar()), Qt::QueuedConnection);
    connect(modbus,SIGNAL(writeCalendar1()),this,SLOT(onModbusWriteCalendar1CurrValue()), Qt::QueuedConnection);
    connect(modbus,SIGNAL(writeCalendar1EndValue()),this,SLOT(onModbusWriteCalendar1EndValue()), Qt::QueuedConnection);
    connect(modbus,SIGNAL(writeCalendar2EndValue()),this,SLOT(onModbusWriteCalendar2EndValue()), Qt::QueuedConnection);
    connect(modbus,SIGNAL(writeCalendar2RepeatValue()),this,SLOT(onModbusWriteCalendar2RepeatValue()), Qt::QueuedConnection);
    connect(modbus,SIGNAL(writeCalendar2InitValue()),this,SLOT(onModbusWriteCalendar2InitValue()), Qt::QueuedConnection);
    connect(modbus,SIGNAL(CNTResetNow()),ui->tabMainWindow,SLOT(onModbusCNTResetNowPressed()), Qt::QueuedConnection);
    connect(modbus,SIGNAL(faultResume()),ui->tabMainWindow,SLOT(onLabelFaultRusumePressed()), Qt::QueuedConnection);
    connect(modbus,SIGNAL(mbLineAndCharSpace(int, int)),ui->tabMainWindow->getTexteditOption(),SLOT(onMbSetLineAndChar(int, int)), Qt::QueuedConnection);
    connect(this,SIGNAL(updataPara2UI()),ui->tabPrintSetting,SLOT( PrintupdateSysParaToUI() ), Qt::QueuedConnection);
    connect(this, SIGNAL(openFile(QString,bool)), ui->tabMainWindow->getTexteditOption(), SLOT(onFileOpen(QString,bool)), Qt::QueuedConnection);
    connect(this, SIGNAL(startPrint()), ui->tabMainWindow, SLOT(on_pushButtonStartPrint_pressed()), Qt::QueuedConnection);
#endif

    ui->tabMainWindow->enableReclaimCtrlButton(false);




    //edit@12-14
    connect(this,SIGNAL(currentChanged(int)),ui->tabMainWindow,SLOT(onInkJetPrinterCurrentChanged(int)), Qt::QueuedConnection);
    //pidControllerInit();
    PID_init();

    removeTab(indexOf(ui->tabDacAdjust));
    removeTab(indexOf(ui->tabFpgaDebug));
    ui->tabWidget->removeTab(ui->tabWidget->indexOf(ui->tab_3));

    ui->vol0SpinBox->setMinimum(0);
    ui->vol1SpinBox->setMinimum(0);
    ui->vol2SpinBox->setMinimum(0);
    ui->vol3SpinBox->setMinimum(0);
    ui->vol4SpinBox->setMinimum(0);
    ui->vol5SpinBox->setMinimum(0);
    ui->vol6SpinBox->setMinimum(0);
    ui->vol7SpinBox->setMinimum(0);
    ui->vol8SpinBox->setMinimum(0);
    ui->vol9SpinBox->setMinimum(0);
    ui->vol10SpinBox->setMinimum(0);
    ui->vol11SpinBox->setMinimum(0);
    ui->vol12SpinBox->setMinimum(0);
    ui->vol13SpinBox->setMinimum(0);
    ui->vol14SpinBox->setMinimum(0);
    ui->vol15SpinBox->setMinimum(0);
    ui->vol16SpinBox->setMinimum(0);
    ui->vol17SpinBox->setMinimum(0);
    ui->vol18SpinBox->setMinimum(0);
    ui->vol19SpinBox->setMinimum(0);
    ui->vol20SpinBox->setMinimum(0);
    ui->vol21SpinBox->setMinimum(0);
    ui->vol22SpinBox->setMinimum(0);
    ui->vol23SpinBox->setMinimum(0);
    ui->vol24SpinBox->setMinimum(0);
    ui->vol25SpinBox->setMinimum(0);
    ui->vol26SpinBox->setMinimum(0);
    ui->vol27SpinBox->setMinimum(0);
    ui->vol28SpinBox->setMinimum(0);
    ui->vol29SpinBox->setMinimum(0);
    ui->vol30SpinBox->setMinimum(0);
    ui->vol31SpinBox->setMinimum(0);
    ui->vol32SpinBox->setMinimum(0);
    ui->vol33SpinBox->setMinimum(0);
    ui->vol34SpinBox->setMinimum(0);
    ui->vol35SpinBox->setMinimum(0);
    ui->vol36SpinBox->setMinimum(0);
    ui->vol37SpinBox->setMinimum(0);
    ui->vol38SpinBox->setMinimum(0);
    ui->vol39SpinBox->setMinimum(0);

    ui->vol0SpinBox->setMaximum(MAX_VOL);
    ui->vol1SpinBox->setMaximum(MAX_VOL);
    ui->vol2SpinBox->setMaximum(MAX_VOL);
    ui->vol3SpinBox->setMaximum(MAX_VOL);
    ui->vol4SpinBox->setMaximum(MAX_VOL);
    ui->vol5SpinBox->setMaximum(MAX_VOL);
    ui->vol6SpinBox->setMaximum(MAX_VOL);
    ui->vol7SpinBox->setMaximum(MAX_VOL);
    ui->vol8SpinBox->setMaximum(MAX_VOL);
    ui->vol9SpinBox->setMaximum(MAX_VOL);
    ui->vol10SpinBox->setMaximum(MAX_VOL);
    ui->vol11SpinBox->setMaximum(MAX_VOL);
    ui->vol12SpinBox->setMaximum(MAX_VOL);
    ui->vol13SpinBox->setMaximum(MAX_VOL);
    ui->vol14SpinBox->setMaximum(MAX_VOL);
    ui->vol15SpinBox->setMaximum(MAX_VOL);
    ui->vol16SpinBox->setMaximum(MAX_VOL);
    ui->vol17SpinBox->setMaximum(MAX_VOL);
    ui->vol18SpinBox->setMaximum(MAX_VOL);
    ui->vol19SpinBox->setMaximum(MAX_VOL);
    ui->vol20SpinBox->setMaximum(MAX_VOL);
    ui->vol21SpinBox->setMaximum(MAX_VOL);
    ui->vol22SpinBox->setMaximum(MAX_VOL);
    ui->vol23SpinBox->setMaximum(MAX_VOL);
    ui->vol24SpinBox->setMaximum(MAX_VOL);
    ui->vol25SpinBox->setMaximum(MAX_VOL);
    ui->vol26SpinBox->setMaximum(MAX_VOL);
    ui->vol27SpinBox->setMaximum(MAX_VOL);
    ui->vol28SpinBox->setMaximum(MAX_VOL);
    ui->vol29SpinBox->setMaximum(MAX_VOL);
    ui->vol30SpinBox->setMaximum(MAX_VOL);
    ui->vol31SpinBox->setMaximum(MAX_VOL);
    ui->vol32SpinBox->setMaximum(MAX_VOL);
    ui->vol33SpinBox->setMaximum(MAX_VOL);
    ui->vol34SpinBox->setMaximum(MAX_VOL);
    ui->vol35SpinBox->setMaximum(MAX_VOL);
    ui->vol36SpinBox->setMaximum(MAX_VOL);
    ui->vol37SpinBox->setMaximum(MAX_VOL);
    ui->vol38SpinBox->setMaximum(MAX_VOL);
    ui->vol39SpinBox->setMaximum(MAX_VOL);

    ui->fvol0SpinBox->setMinimum(0);
    ui->fvol1SpinBox->setMinimum(0);
    ui->fvol2SpinBox->setMinimum(0);
    ui->fvol3SpinBox->setMinimum(0);
    ui->fvol4SpinBox->setMinimum(0);
    ui->fvol5SpinBox->setMinimum(0);
    ui->fvol6SpinBox->setMinimum(0);
    ui->fvol7SpinBox->setMinimum(0);
    ui->fvol8SpinBox->setMinimum(0);
    ui->fvol9SpinBox->setMinimum(0);
    ui->fvol10SpinBox->setMinimum(0);
    ui->fvol11SpinBox->setMinimum(0);
    ui->fvol12SpinBox->setMinimum(0);
    ui->fvol13SpinBox->setMinimum(0);
    ui->fvol14SpinBox->setMinimum(0);
    ui->fvol15SpinBox->setMinimum(0);
    ui->fvol16SpinBox->setMinimum(0);
    ui->fvol17SpinBox->setMinimum(0);
    ui->fvol18SpinBox->setMinimum(0);
    ui->fvol19SpinBox->setMinimum(0);
    ui->fvol20SpinBox->setMinimum(0);
    ui->fvol21SpinBox->setMinimum(0);
    ui->fvol22SpinBox->setMinimum(0);
    ui->fvol23SpinBox->setMinimum(0);
    ui->fvol24SpinBox->setMinimum(0);
    ui->fvol25SpinBox->setMinimum(0);
    ui->fvol26SpinBox->setMinimum(0);
    ui->fvol27SpinBox->setMinimum(0);
    ui->fvol28SpinBox->setMinimum(0);
    ui->fvol29SpinBox->setMinimum(0);
    ui->fvol30SpinBox->setMinimum(0);
    ui->fvol31SpinBox->setMinimum(0);
    ui->fvol32SpinBox->setMinimum(0);
    ui->fvol33SpinBox->setMinimum(0);
    ui->fvol34SpinBox->setMinimum(0);
    ui->fvol35SpinBox->setMinimum(0);
    ui->fvol36SpinBox->setMinimum(0);
    ui->fvol37SpinBox->setMinimum(0);
    ui->fvol38SpinBox->setMinimum(0);
    ui->fvol39SpinBox->setMinimum(0);

    ui->fvol0SpinBox->setMaximum(MAX_VOL);
    ui->fvol1SpinBox->setMaximum(MAX_VOL);
    ui->fvol2SpinBox->setMaximum(MAX_VOL);
    ui->fvol3SpinBox->setMaximum(MAX_VOL);
    ui->fvol4SpinBox->setMaximum(MAX_VOL);
    ui->fvol5SpinBox->setMaximum(MAX_VOL);
    ui->fvol6SpinBox->setMaximum(MAX_VOL);
    ui->fvol7SpinBox->setMaximum(MAX_VOL);
    ui->fvol8SpinBox->setMaximum(MAX_VOL);
    ui->fvol9SpinBox->setMaximum(MAX_VOL);
    ui->fvol10SpinBox->setMaximum(MAX_VOL);
    ui->fvol11SpinBox->setMaximum(MAX_VOL);
    ui->fvol12SpinBox->setMaximum(MAX_VOL);
    ui->fvol13SpinBox->setMaximum(MAX_VOL);
    ui->fvol14SpinBox->setMaximum(MAX_VOL);
    ui->fvol15SpinBox->setMaximum(MAX_VOL);
    ui->fvol16SpinBox->setMaximum(MAX_VOL);
    ui->fvol17SpinBox->setMaximum(MAX_VOL);
    ui->fvol18SpinBox->setMaximum(MAX_VOL);
    ui->fvol19SpinBox->setMaximum(MAX_VOL);
    ui->fvol20SpinBox->setMaximum(MAX_VOL);
    ui->fvol21SpinBox->setMaximum(MAX_VOL);
    ui->fvol22SpinBox->setMaximum(MAX_VOL);
    ui->fvol23SpinBox->setMaximum(MAX_VOL);
    ui->fvol24SpinBox->setMaximum(MAX_VOL);
    ui->fvol25SpinBox->setMaximum(MAX_VOL);
    ui->fvol26SpinBox->setMaximum(MAX_VOL);
    ui->fvol27SpinBox->setMaximum(MAX_VOL);
    ui->fvol28SpinBox->setMaximum(MAX_VOL);
    ui->fvol29SpinBox->setMaximum(MAX_VOL);
    ui->fvol30SpinBox->setMaximum(MAX_VOL);
    ui->fvol31SpinBox->setMaximum(MAX_VOL);
    ui->fvol32SpinBox->setMaximum(MAX_VOL);
    ui->fvol33SpinBox->setMaximum(MAX_VOL);
    ui->fvol34SpinBox->setMaximum(MAX_VOL);
    ui->fvol35SpinBox->setMaximum(MAX_VOL);
    ui->fvol36SpinBox->setMaximum(MAX_VOL);
    ui->fvol37SpinBox->setMaximum(MAX_VOL);
    ui->fvol38SpinBox->setMaximum(MAX_VOL);
    ui->fvol39SpinBox->setMaximum(MAX_VOL);

    ui->cVol0SpinBox->setMinimum(0);
    ui->cVol1SpinBox->setMinimum(0);
    ui->cVol2SpinBox->setMinimum(0);
    ui->cVol3SpinBox->setMinimum(0);
    ui->cVol4SpinBox->setMinimum(0);
    ui->cVol5SpinBox->setMinimum(0);
    ui->cVol6SpinBox->setMinimum(0);
    ui->cVol7SpinBox->setMinimum(0);
    ui->cVol8SpinBox->setMinimum(0);
    ui->cVol9SpinBox->setMinimum(0);
    ui->cVol10SpinBox->setMinimum(0);
    ui->cVol11SpinBox->setMinimum(0);
    ui->cVol12SpinBox->setMinimum(0);
    ui->cVol13SpinBox->setMinimum(0);
    ui->cVol14SpinBox->setMinimum(0);
    ui->cVol15SpinBox->setMinimum(0);
    ui->cVol16SpinBox->setMinimum(0);
    ui->cVol17SpinBox->setMinimum(0);
    ui->cVol18SpinBox->setMinimum(0);
    ui->cVol19SpinBox->setMinimum(0);
    ui->cVol20SpinBox->setMinimum(0);
    ui->cVol21SpinBox->setMinimum(0);
    ui->cVol22SpinBox->setMinimum(0);
    ui->cVol23SpinBox->setMinimum(0);
    ui->cVol24SpinBox->setMinimum(0);
    ui->cVol25SpinBox->setMinimum(0);
    ui->cVol26SpinBox->setMinimum(0);
    ui->cVol27SpinBox->setMinimum(0);
    ui->cVol28SpinBox->setMinimum(0);
    ui->cVol29SpinBox->setMinimum(0);
    ui->cVol30SpinBox->setMinimum(0);
    ui->cVol31SpinBox->setMinimum(0);
    ui->cVol32SpinBox->setMinimum(0);
    ui->cVol33SpinBox->setMinimum(0);
    ui->cVol34SpinBox->setMinimum(0);
    ui->cVol35SpinBox->setMinimum(0);
    ui->cVol36SpinBox->setMinimum(0);
    ui->cVol37SpinBox->setMinimum(0);
    ui->cVol38SpinBox->setMinimum(0);
    ui->cVol39SpinBox->setMinimum(0);

    ui->cVol0SpinBox->setMaximum(MAX_VOL);
    ui->cVol1SpinBox->setMaximum(MAX_VOL);
    ui->cVol2SpinBox->setMaximum(MAX_VOL);
    ui->cVol3SpinBox->setMaximum(MAX_VOL);
    ui->cVol4SpinBox->setMaximum(MAX_VOL);
    ui->cVol5SpinBox->setMaximum(MAX_VOL);
    ui->cVol6SpinBox->setMaximum(MAX_VOL);
    ui->cVol7SpinBox->setMaximum(MAX_VOL);
    ui->cVol8SpinBox->setMaximum(MAX_VOL);
    ui->cVol9SpinBox->setMaximum(MAX_VOL);
    ui->cVol10SpinBox->setMaximum(MAX_VOL);
    ui->cVol11SpinBox->setMaximum(MAX_VOL);
    ui->cVol12SpinBox->setMaximum(MAX_VOL);
    ui->cVol13SpinBox->setMaximum(MAX_VOL);
    ui->cVol14SpinBox->setMaximum(MAX_VOL);
    ui->cVol15SpinBox->setMaximum(MAX_VOL);
    ui->cVol16SpinBox->setMaximum(MAX_VOL);
    ui->cVol17SpinBox->setMaximum(MAX_VOL);
    ui->cVol18SpinBox->setMaximum(MAX_VOL);
    ui->cVol19SpinBox->setMaximum(MAX_VOL);
    ui->cVol20SpinBox->setMaximum(MAX_VOL);
    ui->cVol21SpinBox->setMaximum(MAX_VOL);
    ui->cVol22SpinBox->setMaximum(MAX_VOL);
    ui->cVol23SpinBox->setMaximum(MAX_VOL);
    ui->cVol24SpinBox->setMaximum(MAX_VOL);
    ui->cVol25SpinBox->setMaximum(MAX_VOL);
    ui->cVol26SpinBox->setMaximum(MAX_VOL);
    ui->cVol27SpinBox->setMaximum(MAX_VOL);
    ui->cVol28SpinBox->setMaximum(MAX_VOL);
    ui->cVol29SpinBox->setMaximum(MAX_VOL);
    ui->cVol30SpinBox->setMaximum(MAX_VOL);
    ui->cVol31SpinBox->setMaximum(MAX_VOL);
    ui->cVol32SpinBox->setMaximum(MAX_VOL);
    ui->cVol33SpinBox->setMaximum(MAX_VOL);
    ui->cVol34SpinBox->setMaximum(MAX_VOL);
    ui->cVol35SpinBox->setMaximum(MAX_VOL);
    ui->cVol36SpinBox->setMaximum(MAX_VOL);
    ui->cVol37SpinBox->setMaximum(MAX_VOL);
    ui->cVol38SpinBox->setMaximum(MAX_VOL);
    ui->cVol39SpinBox->setMaximum(MAX_VOL);

    loadVoltageValue();
    connect(ui->savePushButton,SIGNAL(clicked()), this,SLOT( DacAdjustStore()));
    sysPara->status.statWarn = sysPara->status.statWarn | WARN_STATUS_INK_WARN; //先置墨水标示为1
    sleep(3);
    qApp->installEventFilter(this);
}


void InkJetPrinter::loadVoltageValue()
{
    ui->vol0SpinBox->setValue(sysPara->para.printed_adj_dac[0]);
    ui->vol1SpinBox->setValue(sysPara->para.printed_adj_dac[1]);
    ui->vol2SpinBox->setValue(sysPara->para.printed_adj_dac[2]);
    ui->vol3SpinBox->setValue(sysPara->para.printed_adj_dac[3]);
    ui->vol4SpinBox->setValue(sysPara->para.printed_adj_dac[4]);
    ui->vol5SpinBox->setValue(sysPara->para.printed_adj_dac[5]);
    ui->vol6SpinBox->setValue(sysPara->para.printed_adj_dac[6]);
    ui->vol7SpinBox->setValue(sysPara->para.printed_adj_dac[7]);
    ui->vol8SpinBox->setValue(sysPara->para.printed_adj_dac[8]);
    ui->vol9SpinBox->setValue(sysPara->para.printed_adj_dac[9]);
    
    ui->vol10SpinBox->setValue(sysPara->para.printed_adj_dac[10]);
    ui->vol11SpinBox->setValue(sysPara->para.printed_adj_dac[11]);
    ui->vol12SpinBox->setValue(sysPara->para.printed_adj_dac[12]);
    ui->vol13SpinBox->setValue(sysPara->para.printed_adj_dac[13]);
    ui->vol14SpinBox->setValue(sysPara->para.printed_adj_dac[14]);
    ui->vol15SpinBox->setValue(sysPara->para.printed_adj_dac[15]);
    ui->vol16SpinBox->setValue(sysPara->para.printed_adj_dac[16]);
    ui->vol17SpinBox->setValue(sysPara->para.printed_adj_dac[17]);
    ui->vol18SpinBox->setValue(sysPara->para.printed_adj_dac[18]);
    ui->vol19SpinBox->setValue(sysPara->para.printed_adj_dac[19]);

    ui->vol20SpinBox->setValue(sysPara->para.printed_adj_dac[20]);
    ui->vol21SpinBox->setValue(sysPara->para.printed_adj_dac[21]);
    ui->vol22SpinBox->setValue(sysPara->para.printed_adj_dac[22]);
    ui->vol23SpinBox->setValue(sysPara->para.printed_adj_dac[23]);
    ui->vol24SpinBox->setValue(sysPara->para.printed_adj_dac[24]);
    ui->vol25SpinBox->setValue(sysPara->para.printed_adj_dac[25]);
    ui->vol26SpinBox->setValue(sysPara->para.printed_adj_dac[26]);
    ui->vol27SpinBox->setValue(sysPara->para.printed_adj_dac[27]);
    ui->vol28SpinBox->setValue(sysPara->para.printed_adj_dac[28]);
    ui->vol29SpinBox->setValue(sysPara->para.printed_adj_dac[29]);

    ui->vol30SpinBox->setValue(sysPara->para.printed_adj_dac[30]);
    ui->vol31SpinBox->setValue(sysPara->para.printed_adj_dac[31]);
    ui->vol32SpinBox->setValue(sysPara->para.printed_adj_dac[32]);
    ui->vol33SpinBox->setValue(sysPara->para.printed_adj_dac[33]);
    ui->vol34SpinBox->setValue(sysPara->para.printed_adj_dac[34]);
    ui->vol35SpinBox->setValue(sysPara->para.printed_adj_dac[35]);
    ui->vol36SpinBox->setValue(sysPara->para.printed_adj_dac[36]);
    ui->vol37SpinBox->setValue(sysPara->para.printed_adj_dac[37]);
    ui->vol38SpinBox->setValue(sysPara->para.printed_adj_dac[38]);
    ui->vol39SpinBox->setValue(sysPara->para.printed_adj_dac[39]);

    ui->cVol0SpinBox->setValue(sysPara->para.printed_continue_col_dac[0]);
    ui->cVol1SpinBox->setValue(sysPara->para.printed_continue_col_dac[1]);
    ui->cVol2SpinBox->setValue(sysPara->para.printed_continue_col_dac[2]);
    ui->cVol3SpinBox->setValue(sysPara->para.printed_continue_col_dac[3]);
    ui->cVol4SpinBox->setValue(sysPara->para.printed_continue_col_dac[4]);
    ui->cVol5SpinBox->setValue(sysPara->para.printed_continue_col_dac[5]);
    ui->cVol6SpinBox->setValue(sysPara->para.printed_continue_col_dac[6]);
    ui->cVol7SpinBox->setValue(sysPara->para.printed_continue_col_dac[7]);
    ui->cVol8SpinBox->setValue(sysPara->para.printed_continue_col_dac[8]);
    ui->cVol9SpinBox->setValue(sysPara->para.printed_continue_col_dac[9]);
    
    ui->cVol10SpinBox->setValue(sysPara->para.printed_continue_col_dac[10]);
    ui->cVol11SpinBox->setValue(sysPara->para.printed_continue_col_dac[11]);
    ui->cVol12SpinBox->setValue(sysPara->para.printed_continue_col_dac[12]);
    ui->cVol13SpinBox->setValue(sysPara->para.printed_continue_col_dac[13]);
    ui->cVol14SpinBox->setValue(sysPara->para.printed_continue_col_dac[14]);
    ui->cVol15SpinBox->setValue(sysPara->para.printed_continue_col_dac[15]);
    ui->cVol16SpinBox->setValue(sysPara->para.printed_continue_col_dac[16]);
    ui->cVol17SpinBox->setValue(sysPara->para.printed_continue_col_dac[17]);
    ui->cVol18SpinBox->setValue(sysPara->para.printed_continue_col_dac[18]);
    ui->cVol19SpinBox->setValue(sysPara->para.printed_continue_col_dac[19]);

    ui->cVol20SpinBox->setValue(sysPara->para.printed_continue_col_dac[20]);
    ui->cVol21SpinBox->setValue(sysPara->para.printed_continue_col_dac[21]);
    ui->cVol22SpinBox->setValue(sysPara->para.printed_continue_col_dac[22]);
    ui->cVol23SpinBox->setValue(sysPara->para.printed_continue_col_dac[23]);
    ui->cVol24SpinBox->setValue(sysPara->para.printed_continue_col_dac[24]);
    ui->cVol25SpinBox->setValue(sysPara->para.printed_continue_col_dac[25]);
    ui->cVol26SpinBox->setValue(sysPara->para.printed_continue_col_dac[26]);
    ui->cVol27SpinBox->setValue(sysPara->para.printed_continue_col_dac[27]);
    ui->cVol28SpinBox->setValue(sysPara->para.printed_continue_col_dac[28]);
    ui->cVol29SpinBox->setValue(sysPara->para.printed_continue_col_dac[29]);

    ui->cVol30SpinBox->setValue(sysPara->para.printed_continue_col_dac[30]);
    ui->cVol31SpinBox->setValue(sysPara->para.printed_continue_col_dac[31]);
    ui->cVol32SpinBox->setValue(sysPara->para.printed_continue_col_dac[32]);
    ui->cVol33SpinBox->setValue(sysPara->para.printed_continue_col_dac[33]);
    ui->cVol34SpinBox->setValue(sysPara->para.printed_continue_col_dac[34]);
    ui->cVol35SpinBox->setValue(sysPara->para.printed_continue_col_dac[35]);
    ui->cVol36SpinBox->setValue(sysPara->para.printed_continue_col_dac[36]);
    ui->cVol37SpinBox->setValue(sysPara->para.printed_continue_col_dac[37]);
    ui->cVol38SpinBox->setValue(sysPara->para.printed_continue_col_dac[38]);
    ui->cVol39SpinBox->setValue(sysPara->para.printed_continue_col_dac[39]);

    ui->fvol0SpinBox->setValue(sysPara->para.printed_full_col_dac[0]);
    ui->fvol1SpinBox->setValue(sysPara->para.printed_full_col_dac[1]);
    ui->fvol2SpinBox->setValue(sysPara->para.printed_full_col_dac[2]);
    ui->fvol3SpinBox->setValue(sysPara->para.printed_full_col_dac[3]);
    ui->fvol4SpinBox->setValue(sysPara->para.printed_full_col_dac[4]);
    ui->fvol5SpinBox->setValue(sysPara->para.printed_full_col_dac[5]);
    ui->fvol6SpinBox->setValue(sysPara->para.printed_full_col_dac[6]);
    ui->fvol7SpinBox->setValue(sysPara->para.printed_full_col_dac[7]);
    ui->fvol8SpinBox->setValue(sysPara->para.printed_full_col_dac[8]);
    ui->fvol9SpinBox->setValue(sysPara->para.printed_full_col_dac[9]);
    
    ui->fvol10SpinBox->setValue(sysPara->para.printed_full_col_dac[10]);
    ui->fvol11SpinBox->setValue(sysPara->para.printed_full_col_dac[11]);
    ui->fvol12SpinBox->setValue(sysPara->para.printed_full_col_dac[12]);
    ui->fvol13SpinBox->setValue(sysPara->para.printed_full_col_dac[13]);
    ui->fvol14SpinBox->setValue(sysPara->para.printed_full_col_dac[14]);
    ui->fvol15SpinBox->setValue(sysPara->para.printed_full_col_dac[15]);
    ui->fvol16SpinBox->setValue(sysPara->para.printed_full_col_dac[16]);
    ui->fvol17SpinBox->setValue(sysPara->para.printed_full_col_dac[17]);
    ui->fvol18SpinBox->setValue(sysPara->para.printed_full_col_dac[18]);
    ui->fvol19SpinBox->setValue(sysPara->para.printed_full_col_dac[19]);

    ui->fvol20SpinBox->setValue(sysPara->para.printed_full_col_dac[20]);
    ui->fvol21SpinBox->setValue(sysPara->para.printed_full_col_dac[21]);
    ui->fvol22SpinBox->setValue(sysPara->para.printed_full_col_dac[22]);
    ui->fvol23SpinBox->setValue(sysPara->para.printed_full_col_dac[23]);
    ui->fvol24SpinBox->setValue(sysPara->para.printed_full_col_dac[24]);
    ui->fvol25SpinBox->setValue(sysPara->para.printed_full_col_dac[25]);
    ui->fvol26SpinBox->setValue(sysPara->para.printed_full_col_dac[26]);
    ui->fvol27SpinBox->setValue(sysPara->para.printed_full_col_dac[27]);
    ui->fvol28SpinBox->setValue(sysPara->para.printed_full_col_dac[28]);
    ui->fvol29SpinBox->setValue(sysPara->para.printed_full_col_dac[29]);

    ui->fvol30SpinBox->setValue(sysPara->para.printed_full_col_dac[30]);
    ui->fvol31SpinBox->setValue(sysPara->para.printed_full_col_dac[31]);
    ui->fvol32SpinBox->setValue(sysPara->para.printed_full_col_dac[32]);
    ui->fvol33SpinBox->setValue(sysPara->para.printed_full_col_dac[33]);
    ui->fvol34SpinBox->setValue(sysPara->para.printed_full_col_dac[34]);
    ui->fvol35SpinBox->setValue(sysPara->para.printed_full_col_dac[35]);
    ui->fvol36SpinBox->setValue(sysPara->para.printed_full_col_dac[36]);
    ui->fvol37SpinBox->setValue(sysPara->para.printed_full_col_dac[37]);
    ui->fvol38SpinBox->setValue(sysPara->para.printed_full_col_dac[38]);
    ui->fvol39SpinBox->setValue(sysPara->para.printed_full_col_dac[39]);
    if(sysPara->para.dacScale < 40 || sysPara->para.dacScale>150)
        sysPara->para.dacScale = 100;
}

void InkJetPrinter::initCntGroup()
{
    connect(this, &InkJetPrinter::sig_updateDisp,
            SectionalManager::instance(), &SectionalManager::sig_updateCntGroupDisp);
}

float PID_realize(float speed);

struct _pid{
    float SetSpeed;//定义设定值
    float ActualSpeed;//定义实际值
    float err;//定义偏差值
    float err_last;//定义上一个偏差值
    float Kp,Ki,Kd;//定义比例、积分、微分系数
    float voltage;//定义电压值(控制执行器的变量)
    float integral;//定义积分值
    float integral_max; //积分限幅（根据实际调整）
}pid;


void PID_init(){
    pid.SetSpeed=0.0;
    pid.ActualSpeed=0.0;
    pid.err=0.0;
    pid.err_last=0.0;
    pid.voltage=0.0;
    pid.integral=0.0;
    pid.Kp=0.21; //0.25
    pid.Ki=0.006; //0.015
    pid.Kd=0.0;
}

static float u = 1.0;
float PID_realize(float speed, float act){
    unsigned char index = 1;
    pid.SetSpeed=speed;
    pid.ActualSpeed = act;
    pid.err=pid.SetSpeed-pid.ActualSpeed;
    if(u < 900)
    {
        pid.integral+=pid.err;
    }

    pid.voltage=pid.Kp*pid.err + index*pid.Ki*pid.integral + pid.Kd*(pid.err-pid.err_last);
    pid.err_last=pid.err;
    pid.ActualSpeed =pid.voltage*1.0;
    return pid.ActualSpeed;
}

float PID_realize2(float speed, float act){
    // 增量式 PID：Δu = Kp*(e[k]-e[k-1]) + Ki*e[k]
    pid.Kp = 0.15f;
    pid.Ki = 0.02f;
    pid.Kd = 0.0f;
    pid.SetSpeed    = speed;
    pid.ActualSpeed = act;
    pid.err         = pid.SetSpeed - pid.ActualSpeed;

    float delta_u = pid.Kp * (pid.err - pid.err_last)
            + pid.Ki * pid.err;

    // 自适应非对称限幅：
    // 压力严重偏高（err < -30）：允许快速减速，限制慢速加速
    // 压力严重偏低（err > 50）：允许正常加速，限制减速（避免过度降速）
    // 接近目标：小步长，平稳调节
    if(pid.err < -30.0f) {
        if(delta_u >  1.0f) delta_u =  1.0f;
        if(delta_u < -6.0f) delta_u = -6.0f;
    } else if(pid.err > 50.0f) {
        if(delta_u >  3.0f) delta_u =  3.0f;
        if(delta_u < -2.0f) delta_u = -2.0f;
    } else {
        if(delta_u >  3.0f) delta_u =  3.0f;
        if(delta_u < -3.0f) delta_u = -3.0f;
    }

    pid.err_last = pid.err;
    return delta_u;
}

void InkJetPrinter::pressureAdj()
{
    // 关机压力控制首次进入时从停泵状态重新开始，禁止继承正常运行或手动控制转速
    if(sysPara->status.powerOffAppending && !m_powerOffPressureControlActive)
    {
        u = 0.0f;
        sysPara->para.gearPumpValue = 0;
        m_pumpState = DPUMP_STOPPED;
        m_stateChangeCount = 0;
        m_adjSkip = 0;
        m_lastActualPressure = 0;
        m_startingStepCount = 0;
        m_bufValidCount = 0;
        for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
        m_bufIdx = 0;
        sysPara->devOp->WriteMoterPump();
        m_powerOffPressureControlActive = true;
    }
    else if(!sysPara->status.powerOffAppending)
    {
        m_powerOffPressureControlActive = false;
    }

    // 故障停机处理
    if(sysPara->status.gearPumpRunStopFlag || sysPara->status.flagOfSpeedAlarm)
    {
        sysPara->para.gearPumpValue = 0;
        u = 0.0f;
        m_pumpState = DPUMP_STOPPED;
        m_stateChangeCount = 0;
        m_adjSkip = 0;
        m_lastActualPressure = 0;
        m_bufValidCount = 0;
        for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
        m_bufIdx = 0;
        sysPara->devOp->WriteMoterPump();
        return;
    }

    // 泵未使能时的PID控制（保持原有逻辑）
    if(!sysPara->para.gearPumpEnable)
    {
        if(u > 0 || ((sysPara->para.pressure - sysPara->status.PRESSURE) > 0))
            u = PID_realize((float)sysPara->para.pressure, (float)sysPara->status.PRESSURE);
        sysPara->para.gearPumpValue = (u > 0) ? (unsigned short)u : 0;
        if(sysPara->para.gearPumpValue > 800)
            sysPara->para.gearPumpValue = 800;
        sysPara->devOp->WriteMoterPump();
        return;
    }

    // 隔膜泵控制参数
    const int STOP_TO_START_THRESHOLD = 5;   // 停止→启动：压力低于目标15（扩大滞环）
    const int RUN_TO_STOP_THRESHOLD = 5;     // 运行→停止：压力高于目标10（扩大滞环）
    const int MIN_STATE_INTERVAL = 8;         // 最小状态切换间隔：8个100ms = 800ms

    int actual = sysPara->status.PRESSURE;
    int target = (int)sysPara->para.pressure;
    if(sysPara->status.powerOffAppending && target > 650)
        target = 650;  // 关机压力目标不超过650，不修改用户设定值
    int err = target - actual;  // 正值=压力偏低，负值=压力偏高

    // 更新滑动平均缓冲
    m_pressureBuf[m_bufIdx] = actual;
    m_bufIdx = (m_bufIdx + 1) % 10;
    int avgPressure = 0;
    for(int i = 0; i < 10; i++) avgPressure += m_pressureBuf[i];
    avgPressure /= 10;

    // 状态切换计数器递增
    m_stateChangeCount++;

    // 检查是否允许状态切换（距上次切换>=800ms）
    bool canSwitch = (m_stateChangeCount >= MIN_STATE_INTERVAL);

    // 关机压力上限：超过关机目标10立即停泵，不受状态和800ms切换间隔限制
    int hardStopThreshold = sysPara->status.powerOffAppending ? 10 : 80;
    if(actual > target + hardStopThreshold)
    {
        if(m_pumpState != DPUMP_STOPPED) {
            u = 0.0f;
            sysPara->para.gearPumpValue = 0;
        sysPara->devOp->WriteMoterPump();
            m_pumpState = DPUMP_STOPPED;
            m_stateChangeCount = 0;
            m_adjSkip = 0;
        }
        return;
    }

    // 状态机处理
    switch(m_pumpState) {
        case DPUMP_STOPPED:
            handleStoppedState(err, canSwitch);
            break;

        case DPUMP_STARTING:
            handleStartingState(err, actual, target);
            break;

        case DPUMP_RUNNING:
            handleRunningState(err, canSwitch);
            break;
    }
}

// 停止状态处理：压力低于目标较多时启动泵
void InkJetPrinter::handleStoppedState(int err, bool canSwitch)
{
    const int STOP_TO_START_THRESHOLD = 5;   // 压力低于目标15启动（扩大滞环）
    const float START_INIT_SPEED = 80.0f;     // 启动初始转速

    // 压力低于目标较多，且允许切换（距上次停止>=800ms），启动泵
    if(err > STOP_TO_START_THRESHOLD && canSwitch) {
        u = START_INIT_SPEED;
        m_startingStepCount = 0;
        m_adjSkip = 0;
        sysPara->para.gearPumpValue = (unsigned short)(int)u;
        sysPara->devOp->WriteMoterPump();
        m_pumpState = DPUMP_STARTING;
        m_stateChangeCount = 0;  // 重置计数器
    }
}

// 启动爬升状态处理：从低转速逐步提升到工作转速
void InkJetPrinter::handleStartingState(int err, int actual, int target)
    {
    const int STARTING_TO_RUNNING_RANGE = 30;  // 进入目标±50范围转到运行状态
    const float MAX_WORKING_SPEED = 350.0f;    // 最大工作转速
    const float START_SPEED_STEP_LARGE = 40.0f;
    const float START_SPEED_STEP_MED = 30.0f;
    const float START_SPEED_STEP_SMALL = 20.0f;

    m_adjSkip++;

    // 每800ms调整一次（8个100ms周期）
    if(m_adjSkip < 8) {
            sysPara->para.gearPumpValue = (unsigned short)(int)u;
            sysPara->devOp->WriteMoterPump();
            return;
        }
        m_adjSkip = 0;

    // 判断是否进入运行状态
    int absErr = (err >= 0) ? err : -err;
    bool nearTarget = (absErr <= STARTING_TO_RUNNING_RANGE);
    bool reachedMaxSpeed = (u >= MAX_WORKING_SPEED - 10);

    if(nearTarget || reachedMaxSpeed) {
        // 转到运行微调状态
        m_pumpState = DPUMP_RUNNING;
        m_lastActualPressure = actual;
        m_stateChangeCount = 0;  // 重置计数器
        return;
        }

    // 继续爬升：根据误差自适应增速
            float step;
    if(err > 100)      step = START_SPEED_STEP_LARGE;
    else if(err > 50)  step = START_SPEED_STEP_MED;
    else               step = START_SPEED_STEP_SMALL;

            u += step;
    if(u > MAX_WORKING_SPEED) u = MAX_WORKING_SPEED;

    sysPara->para.gearPumpValue = (unsigned short)(int)u;
    sysPara->devOp->WriteMoterPump();
    m_startingStepCount++;
}

// 运行微调状态处理：使用增量式控制算法
void InkJetPrinter::handleRunningState(int err, bool canSwitch)
        {
    const int RUN_TO_STOP_THRESHOLD = 5;      // 压力高于目标10准备停泵（扩大滞环）
    const int EMERGENCY_STOP_THRESHOLD = 10;   // 压力高于目标20立即停泵（不受800ms限制）

    // 紧急停泵：压力严重超标，立即停泵（不受800ms限制）
    if(err < -EMERGENCY_STOP_THRESHOLD) {
        u = 0.0f;
        sysPara->para.gearPumpValue = 0;
        sysPara->devOp->WriteMoterPump();
        m_pumpState = DPUMP_STOPPED;
        m_stateChangeCount = 0;
        m_adjSkip = 0;
        return;
    }

    // 常规停泵：压力略高于目标，等待800ms后停泵
    if(err < -RUN_TO_STOP_THRESHOLD && canSwitch) {
        u = 0.0f;
        sysPara->para.gearPumpValue = 0;
        sysPara->devOp->WriteMoterPump();
        m_pumpState = DPUMP_STOPPED;
        m_stateChangeCount = 0;
        m_adjSkip = 0;
        return;
        }

    // === 增量式微调控制（每200ms调整一次）===
    m_adjSkip++;
    if(m_adjSkip < 2) {
        sysPara->para.gearPumpValue = (unsigned short)(int)u;
        sysPara->devOp->WriteMoterPump();
        return;
    }
    m_adjSkip = 0;

    int actual = sysPara->status.PRESSURE;
    float error = (float)err;
    float absErr = (error >= 0) ? error : -error;

    // 死区：误差≤0.5不调整
    if(absErr < 0.5f) {
        m_lastActualPressure = actual;
            sysPara->para.gearPumpValue = (unsigned short)(int)u;
            sysPara->devOp->WriteMoterPump();
            return;
        }

    // 计算压力变化率（微分项）
    int pressureChange = actual - m_lastActualPressure;
    m_lastActualPressure = actual;

    // 增量式控制公式
    float delta_u;

    // 近目标刹车策略：误差≤5且正在接近目标，只刹车不加速
    if(absErr <= 5.0f &&
       ((error > 0.0f && pressureChange > 0) ||   // 压力低且在上升
        (error < 0.0f && pressureChange < 0)))    // 压力高且在下降
    {
        delta_u = -0.20f * (float)pressureChange;  // 只刹车
    }
    else {
        // 标准增量式控制：比例项 + 微分项
        delta_u = 0.05f * error - 0.20f * (float)pressureChange;
    }

    // 分级限幅（根据误差大小限制调节幅度）
    float maxDelta;
    if(absErr > 30.0f)      maxDelta = 1.0f;
    else if(absErr > 10.0f) maxDelta = 0.6f;
    else                    maxDelta = 0.3f;

    if(delta_u > maxDelta)  delta_u = maxDelta;
    if(delta_u < -maxDelta) delta_u = -maxDelta;

    // 更新控制量
        u += delta_u;

    // 限制范围
    const float MIN_RUNNING_SPEED = 30.0f;  // 最低运行转速（低于此值泵不转）
    const float MAX_WORKING_SPEED = 350.0f;

    if(u < MIN_RUNNING_SPEED) u = MIN_RUNNING_SPEED;
    if(u > MAX_WORKING_SPEED) u = MAX_WORKING_SPEED;

    sysPara->para.gearPumpValue = (unsigned short)(int)u;
        sysPara->devOp->WriteMoterPump();
}



void InkJetPrinter::DacAdjustStore()
{
    sysPara->para.printed_adj_dac[0] = ui->vol0SpinBox->value();
    sysPara->para.printed_adj_dac[1] = ui->vol1SpinBox->value();
    sysPara->para.printed_adj_dac[2] = ui->vol2SpinBox->value();
    sysPara->para.printed_adj_dac[3] = ui->vol3SpinBox->value();
    sysPara->para.printed_adj_dac[4] = ui->vol4SpinBox->value();
    sysPara->para.printed_adj_dac[5] = ui->vol5SpinBox->value();
    sysPara->para.printed_adj_dac[6] = ui->vol6SpinBox->value();
    sysPara->para.printed_adj_dac[7] = ui->vol7SpinBox->value();
    sysPara->para.printed_adj_dac[8] = ui->vol8SpinBox->value();
    sysPara->para.printed_adj_dac[9] = ui->vol9SpinBox->value();
    sysPara->para.printed_adj_dac[10] = ui->vol10SpinBox->value();
    sysPara->para.printed_adj_dac[11] = ui->vol11SpinBox->value();
    sysPara->para.printed_adj_dac[12] = ui->vol12SpinBox->value();
    sysPara->para.printed_adj_dac[13] = ui->vol13SpinBox->value();
    sysPara->para.printed_adj_dac[14] = ui->vol14SpinBox->value();
    sysPara->para.printed_adj_dac[15] = ui->vol15SpinBox->value();
    sysPara->para.printed_adj_dac[16] = ui->vol16SpinBox->value();
    sysPara->para.printed_adj_dac[17] = ui->vol17SpinBox->value();
    sysPara->para.printed_adj_dac[18] = ui->vol18SpinBox->value();
    sysPara->para.printed_adj_dac[19] = ui->vol19SpinBox->value();

    sysPara->para.printed_adj_dac[20] = ui->vol20SpinBox->value();
    sysPara->para.printed_adj_dac[21] = ui->vol21SpinBox->value();
    sysPara->para.printed_adj_dac[22] = ui->vol22SpinBox->value();
    sysPara->para.printed_adj_dac[23] = ui->vol23SpinBox->value();
    sysPara->para.printed_adj_dac[24] = ui->vol24SpinBox->value();
    sysPara->para.printed_adj_dac[25] = ui->vol25SpinBox->value();
    sysPara->para.printed_adj_dac[26] = ui->vol26SpinBox->value();
    sysPara->para.printed_adj_dac[27] = ui->vol27SpinBox->value();
    sysPara->para.printed_adj_dac[28] = ui->vol28SpinBox->value();
    sysPara->para.printed_adj_dac[29] = ui->vol29SpinBox->value();

    sysPara->para.printed_adj_dac[30] = ui->vol30SpinBox->value();
    sysPara->para.printed_adj_dac[31] = ui->vol31SpinBox->value();
    sysPara->para.printed_adj_dac[32] = ui->vol32SpinBox->value();
    sysPara->para.printed_adj_dac[33] = ui->vol33SpinBox->value();
    sysPara->para.printed_adj_dac[34] = ui->vol34SpinBox->value();
    sysPara->para.printed_adj_dac[35] = ui->vol35SpinBox->value();
    sysPara->para.printed_adj_dac[36] = ui->vol36SpinBox->value();
    sysPara->para.printed_adj_dac[37] = ui->vol37SpinBox->value();
    sysPara->para.printed_adj_dac[38] = ui->vol38SpinBox->value();
    sysPara->para.printed_adj_dac[39] = ui->vol39SpinBox->value();

    sysPara->para.printed_continue_col_dac[0] = ui->cVol0SpinBox->value();
    sysPara->para.printed_continue_col_dac[1] = ui->cVol1SpinBox->value();
    sysPara->para.printed_continue_col_dac[2] = ui->cVol2SpinBox->value();
    sysPara->para.printed_continue_col_dac[3] = ui->cVol3SpinBox->value();
    sysPara->para.printed_continue_col_dac[4] = ui->cVol4SpinBox->value();
    sysPara->para.printed_continue_col_dac[5] = ui->cVol5SpinBox->value();
    sysPara->para.printed_continue_col_dac[6] = ui->cVol6SpinBox->value();
    sysPara->para.printed_continue_col_dac[7] = ui->cVol7SpinBox->value();
    sysPara->para.printed_continue_col_dac[8] = ui->cVol8SpinBox->value();
    sysPara->para.printed_continue_col_dac[9] = ui->cVol9SpinBox->value();
    sysPara->para.printed_continue_col_dac[10] = ui->cVol10SpinBox->value();
    sysPara->para.printed_continue_col_dac[11] = ui->cVol11SpinBox->value();
    sysPara->para.printed_continue_col_dac[12] = ui->cVol12SpinBox->value();
    sysPara->para.printed_continue_col_dac[13] = ui->cVol13SpinBox->value();
    sysPara->para.printed_continue_col_dac[14] = ui->cVol14SpinBox->value();
    sysPara->para.printed_continue_col_dac[15] = ui->cVol15SpinBox->value();
    sysPara->para.printed_continue_col_dac[16] = ui->cVol16SpinBox->value();
    sysPara->para.printed_continue_col_dac[17] = ui->cVol17SpinBox->value();
    sysPara->para.printed_continue_col_dac[18] = ui->cVol18SpinBox->value();
    sysPara->para.printed_continue_col_dac[19] = ui->cVol19SpinBox->value();

    sysPara->para.printed_continue_col_dac[20] = ui->cVol20SpinBox->value();
    sysPara->para.printed_continue_col_dac[21] = ui->cVol21SpinBox->value();
    sysPara->para.printed_continue_col_dac[22] = ui->cVol22SpinBox->value();
    sysPara->para.printed_continue_col_dac[23] = ui->cVol23SpinBox->value();
    sysPara->para.printed_continue_col_dac[24] = ui->cVol24SpinBox->value();
    sysPara->para.printed_continue_col_dac[25] = ui->cVol25SpinBox->value();
    sysPara->para.printed_continue_col_dac[26] = ui->cVol26SpinBox->value();
    sysPara->para.printed_continue_col_dac[27] = ui->cVol27SpinBox->value();
    sysPara->para.printed_continue_col_dac[28] = ui->cVol28SpinBox->value();
    sysPara->para.printed_continue_col_dac[29] = ui->cVol29SpinBox->value();

    sysPara->para.printed_continue_col_dac[30] = ui->cVol30SpinBox->value();
    sysPara->para.printed_continue_col_dac[31] = ui->cVol31SpinBox->value();
    sysPara->para.printed_continue_col_dac[32] = ui->cVol32SpinBox->value();
    sysPara->para.printed_continue_col_dac[33] = ui->cVol33SpinBox->value();
    sysPara->para.printed_continue_col_dac[34] = ui->cVol34SpinBox->value();
    sysPara->para.printed_continue_col_dac[35] = ui->cVol35SpinBox->value();
    sysPara->para.printed_continue_col_dac[36] = ui->cVol36SpinBox->value();
    sysPara->para.printed_continue_col_dac[37] = ui->cVol37SpinBox->value();
    sysPara->para.printed_continue_col_dac[38] = ui->cVol38SpinBox->value();
    sysPara->para.printed_continue_col_dac[39] = ui->cVol39SpinBox->value();

    sysPara->para.printed_full_col_dac[0] = ui->fvol0SpinBox->value();
    sysPara->para.printed_full_col_dac[1] = ui->fvol1SpinBox->value();
    sysPara->para.printed_full_col_dac[2] = ui->fvol2SpinBox->value();
    sysPara->para.printed_full_col_dac[3] = ui->fvol3SpinBox->value();
    sysPara->para.printed_full_col_dac[4] = ui->fvol4SpinBox->value();
    sysPara->para.printed_full_col_dac[5] = ui->fvol5SpinBox->value();
    sysPara->para.printed_full_col_dac[6] = ui->fvol6SpinBox->value();
    sysPara->para.printed_full_col_dac[7] = ui->fvol7SpinBox->value();
    sysPara->para.printed_full_col_dac[8] = ui->fvol8SpinBox->value();
    sysPara->para.printed_full_col_dac[9] = ui->fvol9SpinBox->value();
    sysPara->para.printed_full_col_dac[10] = ui->fvol10SpinBox->value();
    sysPara->para.printed_full_col_dac[11] = ui->fvol11SpinBox->value();
    sysPara->para.printed_full_col_dac[12] = ui->fvol12SpinBox->value();
    sysPara->para.printed_full_col_dac[13] = ui->fvol13SpinBox->value();
    sysPara->para.printed_full_col_dac[14] = ui->fvol14SpinBox->value();
    sysPara->para.printed_full_col_dac[15] = ui->fvol15SpinBox->value();
    sysPara->para.printed_full_col_dac[16] = ui->fvol16SpinBox->value();
    sysPara->para.printed_full_col_dac[17] = ui->fvol17SpinBox->value();
    sysPara->para.printed_full_col_dac[18] = ui->fvol18SpinBox->value();
    sysPara->para.printed_full_col_dac[19] = ui->fvol19SpinBox->value();

    sysPara->para.printed_full_col_dac[20] = ui->fvol20SpinBox->value();
    sysPara->para.printed_full_col_dac[21] = ui->fvol21SpinBox->value();
    sysPara->para.printed_full_col_dac[22] = ui->fvol22SpinBox->value();
    sysPara->para.printed_full_col_dac[23] = ui->fvol23SpinBox->value();
    sysPara->para.printed_full_col_dac[24] = ui->fvol24SpinBox->value();
    sysPara->para.printed_full_col_dac[25] = ui->fvol25SpinBox->value();
    sysPara->para.printed_full_col_dac[26] = ui->fvol26SpinBox->value();
    sysPara->para.printed_full_col_dac[27] = ui->fvol27SpinBox->value();
    sysPara->para.printed_full_col_dac[28] = ui->fvol28SpinBox->value();
    sysPara->para.printed_full_col_dac[29] = ui->fvol29SpinBox->value();

    sysPara->para.printed_full_col_dac[30] = ui->fvol30SpinBox->value();
    sysPara->para.printed_full_col_dac[31] = ui->fvol31SpinBox->value();
    sysPara->para.printed_full_col_dac[32] = ui->fvol32SpinBox->value();
    sysPara->para.printed_full_col_dac[33] = ui->fvol33SpinBox->value();
    sysPara->para.printed_full_col_dac[34] = ui->fvol34SpinBox->value();
    sysPara->para.printed_full_col_dac[35] = ui->fvol35SpinBox->value();
    sysPara->para.printed_full_col_dac[36] = ui->fvol36SpinBox->value();
    sysPara->para.printed_full_col_dac[37] = ui->fvol37SpinBox->value();
    sysPara->para.printed_full_col_dac[38] = ui->fvol38SpinBox->value();
    sysPara->para.printed_full_col_dac[39] = ui->fvol39SpinBox->value();
    sysPara->devOp->writeFpgaPrintPara();
}


InkJetPrinter::~InkJetPrinter()
{
    if(m_serialThreadFPGA->isRunning()){
        m_serialThreadFPGA->quit();
        m_serialThreadFPGA->wait();
    }
    if(m_serialThreadSTM32->isRunning()){
        m_serialThreadSTM32->quit();
        m_serialThreadSTM32->wait();
    }
    if(m_thread->isRunning()){
        m_thread->quit();
        m_thread->wait();
    }
    if(serialFPGA)
        delete serialFPGA;
    if(serialSTM32)
        delete serialSTM32;
    delete ui;
    delete timer;
#ifdef MODBUS
    if (modbus) {
        delete modbus;
    }
#endif
    if (fileTransceiv) {
        fileTransceiv->deleteLater();
    }
    //edit@01-03
    if (tcpTransceiv) {
        tcpTransceiv->deleteLater();
    }
}

extern void MySleep(unsigned int msec);
extern unsigned char test_flag;
bool gearPumpRunNormalFlag = false;
unsigned char isPrintingFlag[1]={0};
void InkJetPrinter::timerHandler(void){
    static bool flag1 = 1;
    if(flag1){
        flag1 = 0;
        qDebug()<<"timer had started";
    }

    int pulse_100ms = 0;
    int pulse_200ms = 0;
    int pulse_50ms = 0;
    int pulse_20ms = 0;
    int pulse_1s = 0;
    int pulse_10s = 0;
    int pulse_100s = 0;
    int pulse_300ms = 0;
    int timer_3s = 0;

    static int pulse_3s = 0;
    static int pulse_4s = 0;
    static int pulse_5s = 0;
    static int reciclar_30s = 0;
    static int pulse_30s = 0;
    static int xxxm=0;

    static int tempFlag=0;
    static int save_weeknum = 0;
    static bool gearPumpRunFlag = false;
    static bool ControledSwitchFlag = false;
    static bool gearPumpStartFlag = false;
    static bool delay3s;
    bool InkSwintFlag = false,lastInkSwintFlag = false;
    static float gearPumpRunNormalValue = 0.0;
    if(sysPara){
        xxxm=1;

        sysPara->para.ReadFileErrorCnt=0; // 正常打开文件

        // /opt/FriendlyARM/mini2440/rootfs_qtopia_qt4/usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib
        if(sysPara->para.gearPumpEnable)
        {
            ui->tabMainWindow->enablePushButtonStart(true);
            if(!pushButtonStartFlag)
            {
                gearPumpRunNormalFlag = false;
            }
            if(!gearPumpRunFlag)
            {
                ui->tabMainWindow->enableReclaimCtrlButton(false);
            }
        }
        else
        {
            ui->tabMainWindow->enablePushButtonStart(false);
        }

        /*-----------------------形成脉冲-----------------------------*/
        sysPara->status.delay10ms ++;
        if(sysPara->status.delay10ms == 2){
            pulse_20ms = 1;
        }
        if(sysPara->status.delay10ms == 5){
            pulse_50ms = 1;
        }
        if(sysPara->status.delay10ms == 10){
            pulse_100ms = 1;
            sysPara->status.delay10ms = 0;
        }
        if(pulse_100ms){
            sysPara->status.delay100ms ++;
            if(sysPara->status.delay100ms == 10){
                pulse_1s = 1;
                sysPara->status.delay100ms = 0;
            }
            pulse_300ms = (sysPara->status.delay100ms%3) == 0;		//1秒3次，并非精确的300ms
            pulse_200ms = (sysPara->status.delay100ms%2) == 0;
        }
        if(pulse_300ms) tempFlag=1;
        if((sysPara->status.delay10ms%3) == 0) //读取状态后再检測
        {
            if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN) && !gearPumpRunFlag && !sysPara->status.isPumpValveControledByHand)//刚启动前3秒
            {
                if(sysPara->para.gearPumpEnable) {
                    // 隔膜泵初始化：确保从停止状态开始
                    if(sysPara->para.gearPumpValue != 0) {
                        sysPara->para.gearPumpValue = 0;
                        u = 0.0f;
                        sysPara->devOp->WriteMoterPump();
                    }
                    // 初始化隔膜泵状态机
                    m_pumpState = DPUMP_STOPPED;
                    m_stateChangeCount = 0;
                    m_adjSkip = 0;
                    m_lastActualPressure = 0;
                    m_bufValidCount = 0;
                    m_startingStepCount = 0;
                    gearPumpStartFlag = true;
                }
            }
        }

        if(pushButtonStartFlag && sysPara->status.selfCheckDone)
        {
            if((sysPara->status.PRESSURE > (sysPara->para.pressure -10)) && (sysPara->status.PRESSURE < (sysPara->para.pressure +10)))
            {
                if(pulse_1s)
                {

                    pulse_5s++;
                }
                if( pulse_5s == 5)
                {
                    pulse_5s = 0;
                    gearPumpRunNormalFlag = true;
                    gearPumpRunNormalValue = u;
                }
            }
        }
        if(sysPara->status.isPumpValveControledByHand)
        {
            gearPumpRunNormalFlag = false;
            ControledSwitchFlag = false;
            pulse_3s = 0;
        }
        // 检测手动→自动边沿，恢复压力控制时从停止状态安全重启
        if(m_lastByHand && !sysPara->status.isPumpValveControledByHand)
        {
            ControledSwitchFlag = true;
            u = 0.0f;
            sysPara->para.gearPumpValue = 0;
            sysPara->devOp->WriteMoterPump();
            m_pumpState = DPUMP_STOPPED;
            m_stateChangeCount = 0;
            m_adjSkip = 0;
            m_lastActualPressure = 0;
            m_startingStepCount = 0;
            m_bufValidCount = 0;
            for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
            m_bufIdx = 0;
        }
        m_lastByHand = sysPara->status.isPumpValveControledByHand;
        if(!(sysPara->status.statWarn & WARN_STATUS_INK_SWINT)){//墨线开关,压力抖动
            InkSwintFlag = true;
        }
        else
        {
            InkSwintFlag = false;
        }
        if(lastInkSwintFlag != InkSwintFlag)
        {
            lastInkSwintFlag = InkSwintFlag;
            gearPumpRunNormalFlag = false;
        }
        if(gearPumpRunNormalFlag && !sysPara->status.isPumpValveControledByHand && sysPara->para.gearPumpEnable)
        {
            // 隔膜泵泄漏检测：运行状态下，压力持续不上升或下降
            static int leakCheckCount = 0;
            static int lastPressureForLeak = 0;

            if(m_pumpState == DPUMP_RUNNING && pulse_1s)
            {
                int pressureChange = sysPara->status.PRESSURE - lastPressureForLeak;

                // 泵运行中（转速>40），压力不升反降，或上升太慢（<5/秒）
                if(u > 40.0f && pressureChange < 5) {
                    leakCheckCount++;
                    if(leakCheckCount >= 5) {  // 连续5秒
                        leakCheckCount = 0;
                        ui->tabMainWindow->setRunStatus(tr("压力异常，可能泄漏!"));
                        sysPara->status.gearPumpRunStopFlag = true;
                        gearPumpRunNormalFlag = false;
                        LogInfo::setRunStatusText(tr("运行中压力泄漏，停泵!"));
                    }
                } else {
                    leakCheckCount = 0;
                }

                lastPressureForLeak = sysPara->status.PRESSURE;
            }
        }
        if(sysPara->para.gearPumpEnable && (sysPara->status.gearPumpRunSpeed < 100) && test_flag){
            if(test_flag % 2)
                ui->tabMainWindow->on_pushButtonReclaimTankClose_pressed();
            test_flag = 0;
        }
        if(pulse_1s) {
            if(sysPara->status.selfCheckDone && sysPara->para.gearPumpEnable)
                checkPressureControl();
            if((QTime::currentTime()>=QTime(00,00,00))&&(QTime::currentTime()<=QTime(00,00,02))&&sysPara->para.Reciclar){
                if(ui->tabMainWindow->getCurrPrintStatus() != 1){
                    ui->tabMainWindow->_on_pushButtonPowerOff_pressed(false);
                    LogInfo::setRunStatusText(tr("测试时间结束，准备关机"));
                    ui->tabMainWindow->setRunStatus(tr("测试时间结束，准备关机"));
                }
            }
            if(sysPara->status.selfCheckDone && sysPara->para.Reciclar  && test_flag){
                reciclar_30s++;
                if(reciclar_30s > 30){
                    reciclar_30s = 0;
                    test_flag++;
                }
            }
            else if(reciclar_30s){
                reciclar_30s = 0;
            }
            QDate d = QDate::currentDate();

            if(save_weeknum == 0)
            {
                save_weeknum = d.weekNumber();
            }

            if(save_weeknum != d.weekNumber())
            {
                sysPara->devOp->writeFpgaCalandar(1);
                save_weeknum = d.weekNumber();
            }

            sysPara->status.delay1s ++;
            if(sysPara->status.delay1s == 3 && !delay3s){
                delay3s = true;
            }
            if(sysPara->status.delay1s % 3 == 0 && sysPara->status.delay1s != 0)
                timer_3s = 1;
            if(sysPara->status.delay1s == 10){
                pulse_10s = 1;
                sysPara->status.delay1s = 0;
            }

            pulse_4s++;
            if(gearPumpStartFlag)
            {
                pulse_3s ++;
                if(pulse_3s == 3)
                {
                    pulse_3s = 0;
                    gearPumpRunFlag = true;
                    ControledSwitchFlag = true;
                }
            }
            if( sysPara->status.reclainTankReachEnd) sysPara->para.openInkLineTime++;
        }

        if(pulse_1s && flagOfSerialThreadStratEn){
            if (!m_serialThreadFPGA->isRunning()) {
                qDebug()<<"start FPGA tread";
                m_serialThreadFPGA->start();
            }
            if (!m_serialThreadSTM32->isRunning()){
                qDebug()<<"start STM32 tread";
                m_serialThreadSTM32->start();
            }
            flagOfSerialThreadStratEn = false;
        }

        if(pulse_10s){
            if(!m_thread->isRunning())
                m_thread->start();
            sysPara->status.delay10s ++;
            if(sysPara->status.delay10s == 10){
                pulse_100s = 1;
                sysPara->status.delay10s = 0;

//                if(sysPara->status.flagOfPowerOnMode && (ui->tabMainWindow->getCurrPrintStatus() != 1))
                if(sysPara->status.flagOfPowerOnMode)
                {
                    qDebug()<<"waitPowerOffTime: "<<sysPara->status.waitPowerOffTime;
                    LogInfo::setRunStatusText(tr("waitPowerOffTime: %1").arg(sysPara->status.waitPowerOffTime));
                    if(sysPara->status.waitPowerOffTime)
                    {
                        sysPara->status.waitPowerOffTime--;
                        if(!sysPara->status.waitPowerOffTime)
                        {
                            ui->tabMainWindow->_on_pushButtonPowerOff_pressed(false);
                            LogInfo::setRunStatusText(tr("定时开机循环完成，准备关机"));
                            ui->tabMainWindow->setRunStatus(tr("准备关机"));
                        }
                    }
                }
            }

        }

        /*------------------------------------------------------*/
        if(pulse_100ms) {
            sysPara->devOp->stm32Rd(0x07,(unsigned char *)&PulseCnt,2);//读取脉冲个数低字节
            sysPara->devOp->readFgaStatus();
        }

        /**************桂澳增加超速提示*****************************/
        static int logCtrl = 0;
        if((sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER || sysPara->para.eleEyeTriggerSynPrintEn)
                && sysPara->status.lesslen_warn == 1){ //置1表示超速了
            if(logCtrl++ % 500 == 0){
                LogInfo::setRunStatusText(tr("速度过快,请检查是否漏喷!!!"));
                qDebug()<<"速度过快,请检查是否漏喷!!!";
            }

            /*if(msgBox1->isHidden()){ //桂澳的超速提示先保留
                msgBox1->setText(tr("速度过快,请检查是否漏喷!!!"));
                msgBox1->show();
                LogInfo::setRunStatusText(tr("速度过快,请检查是否漏喷!!!"));
                qDebug()<<"速度过快,请检查是否漏喷!!!";
            }*/
            sysPara->devOp->controlRedLight(true);
            sysPara->devOp->controlGreenLight(false);
        }
        else{
            if(!msgBox1->isHidden())
                sysPara->devOp->controlRedLight(false);
        }


        sysPara->status.gearPumpRunSpeed = (PulseCnt * 60 * 1000) / (500 * 2);
        if(!sysPara->para.gearPumpEnable)
            sysPara->status.PRESSURE *= 5;			//响应群众号召，数值放大五倍

        /*-------------------------------------------------------*/
        bool lostCommuFlag = 1;
        if(sysPara->status.fpgaVersionNum != 0)
            lostCommuFlag = 0;

        if(sysPara->status.delay10ms%5 == 0)
        {//复位发送打印数据
            if((ui->tabMainWindow->getCurrPrintStatus() == 1)&&sysPara->para.ResetSendData)
            {
                static bool oneTimeFlag = false;
                if(sysPara->status.productCnt== 0 && (oneTimeFlag==false))//计米复位发送打印数据
                {
                    oneTimeFlag = true;
                    ui->tabMainWindow->on_pushButtonStartPrint_pressed();
                    //复位重设起始值
                    if(sysPara->para.cnt1ResetToInitValue)
                    {
                        sysPara->para.cnt1CurrValue = sysPara->para.cnt1StartValue;
                        sysPara->status.cnt1CurrentValueInitDoneFlag = false;
                        sysPara->devOp->writeFpgaCalandar(0);
                    }
                }
                if(sysPara->status.productCnt != 0)
                {
                    oneTimeFlag = false;
                }
            }
            static  unsigned int lastProductCount=0;
            if(sysPara->status.productCnt != lastProductCount || sysPara->status.printDoneFlag)
            {
                sysPara->status.printDoneFlag = false;
                lastProductCount = sysPara->status.productCnt;
                sysPara->modbusStatus.printFinishFlag = 1;
                memcpy((void*)(&sysPara->modbusStatus.orderCode), (void*)(&sysPara->modbusParas.QRcode_buf), 2);//写返回序列号
                ui->tabMainWindow->UpdateDateTimeQRCode(QDateTime::currentDateTime().toString("hh:mm"));
            }
            if (modbus->getModbusStatus() == 1) {
                refreshModbusStatus();
            }
        }

        if(gearPumpRunFlag || sysPara->para.gearPumpEnable == 0 || sysPara->status.powerOffAppending)
        {
            if(!sysPara->status.selfCheckDone && sysPara->status.isPrinting){
                    sysPara->status.selfCheckDone = true;
                    ui->tabMainWindow->updatePrintDisplayLabel();
                sysPara->status.flagOfAbnormalStatus = true;

                static bool onceLog = true;
                if(onceLog) {
                    LogInfo::setRunStatusText(tr("打印过程中死机了!!!"));
                    qDebug()<<"打印过程中死机了!!!";
                    onceLog = false;

                    ui->tabMainWindow->updatePrintDisplayLabel();
                }

                ui->tabMainWindow->on_pushButtonStopPrint_pressed();

            }
            if(!sysPara->status.selfCheckDone)
            {
                /*开机自检*/
                autoControlValvePump();
                if(pulse_100ms){
                    pressureAdj();
                }
                /*-----------------------------------------------------*/
                if(!sysPara->status.selfCheckCnt) {
                    LogInfo::setRunStatusText(tr("开始自检,请等待60秒..............."));
                    ui->tabMainWindow->enableReclaimCtrlButton(false);
                    ui->tabMainWindow->enablePrintButton(false);
                    sysPara->devOp->mainInkCtrl();
                    sysPara->para.TrunOnPowerCnt++;// 20151218 开机次数加1
                    sysPara->saveParaToFile();     // 保存开机次数值

                    sysPara->status.lastProductCnt = sysPara->status.productCnt ;			//这会让产品计数显示出来

                    ui->tabMainWindow->updateTotalCnt(0);


                }
                if((++sysPara->status.selfCheckCnt % 100) == 0){
                    ui->tabMainWindow->setRunStatus(tr("开始自检,请等待%1秒...............").arg((MAX_SELF_CHECK_CNT - sysPara->status.selfCheckCnt)/100));
                }

                if(sysPara->status.selfCheckCnt >= MAX_SELF_CHECK_CNT)
                {
                    sysPara->status.selfCheckDone = 1;
                    // 自检完成后管道恢复正常阻力，必须重新从STOPPED状态开始
                    // 清零 u 和状态机，让系统根据实际压力重新启动
                    u = 0.0f;  // 关键：清零控制量，避免继承自检期间的大转速
                    sysPara->para.gearPumpValue = 0;
                    sysPara->devOp->WriteMoterPump();  // 立即停泵

                    m_pumpState = DPUMP_STOPPED;  // 强制进入STOPPED状态
                        m_stateChangeCount = 0;
                        m_adjSkip = 0;
                        m_lastActualPressure = 0;
                        m_bufValidCount = 0;
                    for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
                    m_bufIdx = 0;
                    LogInfo::setRunStatusText(tr("自检完成!!!"));
                    ui->tabMainWindow->setRunStatus(tr("自检完成!!!"));
                    qDebug()<<"自检完成!!!";
                    ui->tabPrintSetting->PrintSettingLog();
                    ui->tabMainWindow->enableReclaimCtrlButton(true);
                    sysPara->devOp->mainInkCtrl();
                    sysPara->status.canRunAirPushing = true;

                    if(sysPara->para.Reciclar)
                        test_flag = 1;
                }
                else {
                    if((sysPara->status.selfCheckCnt % 200) == 0)
                        // sysPara->devOp->controlReclaimTankOpen(false);
                        ui->tabMainWindow->enableReclaimCtrlButton(false);
                }

            }
            else{
                // 开机自检完成的前提下
                if (!sysPara->status.airPushing || ui->tabMainWindow->m_2sFlag) {
                    autoControlValvePump();
                }
                // 检测回收泵模式切换，切换时重置泄漏保护学习状态和软启动状态
                if(m_lastReclaimMode != sysPara->para.flagOfReclaimPumEnable)
                {
                    m_lastReclaimMode      = sysPara->para.flagOfReclaimPumEnable;
                    gearPumpRunNormalFlag  = false;   // 泄漏保护重新学习
                    gearPumpRunNormalValue = 0.0f;
                    // 重置隔膜泵状态机，适应新模式
                    u = 0.0f;
                    pid.integral = 0.0f;
                    pid.err_last = 0.0f;
                    sysPara->para.gearPumpValue = 0;
                    sysPara->devOp->WriteMoterPump();
                    if(!sysPara->para.flagOfReclaimPumEnable)
                        sysPara->devOp->controlReclaimPump(false, false);
                    m_pumpState = DPUMP_STOPPED;
                    m_stateChangeCount = 0;
                    m_adjSkip = 0;
                    m_lastActualPressure = 0;
                    m_bufValidCount = 0;
                    for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
                    m_bufIdx = 0;
                }
                if(pulse_100ms && sysPara->para.gearPumpEnable &&
                   (sysPara->status.powerOffAppending ||
                    (!sysPara->status.isPumpValveControledByHand && ControledSwitchFlag))) {
                    pressureAdj();

                }
            }
        }
        else{
            static bool flag = 1;
            if(delay3s){
                if(flag){
                    flag = 0;
                    LogInfo::setRunStatusText(tr("缺少墨水,喷码机不能正常工作!"));
                    qDebug()<<"缺少墨水,喷码机不能正常工作!";
                }
                ui->tabMainWindow->setRunStatus(tr("缺少墨水,喷码机不能正常工作!"));
            }
        }
        /*----------------------------控制温度--------------------------------------*/
        if(pulse_300ms){
            autoControlHeater();
            sysPara->devOp->readSyncCounterAtZero();
        }

        sysPara->status.lostCommuFlag = lostCommuFlag;		//务必放在后面
        static unsigned int lastProductCnt =0;
        static int lastalterMode=-1;
        if(sysPara->para.alterPrint.enable)
        {
            sysPara->para.AlterMode=sysPara->status.AlterMode;  // 电眼触发交替功能：新增这一行
            if( (sysPara->para.AlterMode!=lastalterMode)
                    || (lastProductCnt != sysPara->status.productCnt)
                    )
            {
                ui->tabMainWindow->alterDataPrint (sysPara->para.AlterMode);
            }
        }
        else sysPara->para.AlterMode=0;
        lastalterMode = sysPara->para.AlterMode;
        lastProductCnt = sysPara->status.productCnt;
        ui->tabMainWindow->CheckStatus(pulse_300ms);   //
        /*----------------------------------界面更新状态---------------------------------------*/
#ifdef __RFID_CARD
        static bool flag6 = true;
        unsigned int addr = ui->tabPrintSetting->dlgInputAddr->jd.addr;
        if(pulse_10s && flag6){ //初始化刷卡模块
            qDebug()<<"初始化刷卡模块";
            LogInfo::setRunStatusText(QString("jd.addr:%1").arg(addr));
            flag6 = false;
            if (manager_rfid)
                manager_rfid->initRFIDMoudle(addr, sysPara);
        }

        if(pulse_300ms){
            if (manager_rfid)
                manager_rfid->handleCheck(addr);
        }

#endif
        if(pulse_300ms){
            sysPara->devOp->readCalandarDat();			//务必读一下此数据
            if(sysPara->status.RandomNum>0)
                sysPara->devOp->Read_RanddomFromFpga();
#ifdef COUNTER1_BY_GROUP /* 分段计米 */
            cnt1GroupCheck();//分段计米
#endif
            cntGroupCheck();//分段计米

            QWidget *widget = this->currentWidget();
            static bool read_flag =  false;
            if(widget == ui->tabMainWindow && pulse_100ms) {
                ui->tabMainWindow->updateSysStatusToUI();
            }
            else if(widget == ui->tabTriggerMode){
                ui->tabTriggerMode->updateSysStatusToUI();
                if(sysPara->status.fpgaVersionNum != 0){
                    QString FpgaVersion;
                    if((sysPara->status.fpgaVersionNum>>12) == 8 || (sysPara->status.fpgaVersionNum>>12) == 6)
                        FpgaVersion = "72";
                    else if((sysPara->status.fpgaVersionNum>>12) == 2 || (sysPara->status.fpgaVersionNum>>12) == 1){
                        if(sysPara->para.flagOfFastMode)
                            FpgaVersion = "66";
                        else
                            FpgaVersion = "67";
                    }
                    FpgaVersion +=  QString("_F%1.%2.%3").arg(sysPara->status.fpgaVersionNum >> 12)
                            .arg((sysPara->status.fpgaVersionNum>>8) & 0x0f).arg(sysPara->status.fpgaVersionNum&0xff);
                    ui->tabTriggerMode->setBuildTime(QString(" No%1").arg(FpgaVersion));
                }

            }
            else if(widget == ui->tabPrintSetting)
            {
                ui->tabPrintSetting->updateSysStatusToUI();
                if(!read_flag)
                {
                    emit sendPicScene(ui->tabMainWindow->getPicScene());
                }
                read_flag = true;
            }
            else if(widget == ui->tabSystemSetting){

                ui->tabSystemSetting->updateSysStatusToUI();
            }
            else if(widget == ui->tabSystemManage){
                ui->tabSystemManage->updateSysStatusToUI();
            }
            else if(widget == ui->tabOtherInfo){
                ui->tabOtherInfo->updateSysStatusToUI();
            }
            else if(widget == ui->tabNetworkManager){
                if(!sysPara->status.bLanConfigManual)
                {
                    ui->tabNetworkManager->updateSysStatusToUI();
                }
            }
            if(widget  !=  ui->tabPrintSetting)
            {
                read_flag = false;
            }

            //  20140306
            static int last_lesslen_warn=0,lesslen_cnt=0;
            if(sysPara->status.lesslen_warn && (sysPara->para.printTriggerMode != PRINT_TRIGGER_TIME))
            {
                if(last_lesslen_warn==0)
                {
                    last_lesslen_warn =lesslen_cnt;
                    if(lesslen_cnt<60)lesslen_cnt +=6;
                    if(lesslen_cnt>40) sysPara->devOp->resumeFault();

                    if(sysPara->para.speedoverPaushPrint) {
                        ui->tabMainWindow->on_pushButtonPausePrint_pressed();// 2014-03-19
                        //                        emit OnSpeedOver(2);//QMessageBox::warning(NULL,tr("警告"),tr("喷印速度过快！无法喷印完全，自动暂停喷印!!!"));
                        ui->tabMainWindow->setRunStatus(tr("喷印速度过快！无法喷印完全，自动暂停喷印!!!"));

                    }
                    else {
                        //                        emit OnSpeedOver(1);//QMessageBox::warning(NULL,tr("警告"),tr("喷印速度过快！无法喷印完全!!!"));
                        ui->tabMainWindow->setRunStatus(tr("喷印速度过快！无法喷印完全!!!"));
                    }

                }
            }
            else  { last_lesslen_warn=0;lesslen_cnt=30;}

            if(last_lesslen_warn) last_lesslen_warn--;

        }

        if(pulse_100ms && sysPara->status.selfCheckDone){
            detectAndcontrolReclaimTank();			//控制回收槽
        }

        /*---------------------------------处理警告--------------------------------------------*/
        if(pulse_1s){
            if(sysPara->para.gearPumpEnable && sysPara->status.selfCheckDone && gearPumpRunNormalFlag)
            {
                if((sysPara->status.PRESSURE < (sysPara->para.pressure -8)) || (sysPara->status.PRESSURE > (sysPara->para.pressure +8)))
                {
                    LogInfo::setRunStatusText(tr("压力波动超过设定的5个值."));
                }
            }

            static bool logFlag1 = true;
            if(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN && logFlag1){
                logFlag1 = false;
                LogInfo::setRunStatusText(tr("溶剂液位报警! %1").arg(sysPara->RFIDPara.solventNumber));
                qDebug()<<"溶剂液位报警! "<<sysPara->RFIDPara.solventNumber;
            }

#ifdef __RFID_CARD
            /*****************墨水刷卡控制start**********************************************/
            /*墨水刷卡新的控制逻辑*/
            /* 1.任何时候,打印墨点数达到2.3billion之后,提示24小时内刷卡,否则禁止使用机器*/
            /*2.当墨水液位后,持续提示刷卡,24小时后如果还没有刷卡,禁止使用机器*/
            static bool logFlag4 = 1;
            static int warnNum1 = 0;
            if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN))
                warnNum1 = 0;
            if((sysPara->status.statWarn & WARN_STATUS_INK_WARN) || sysPara->para.RFIDInkWarn){
                if(!sysPara->para.RFIDInkWarn){
                    if(++warnNum1 >6){
                        sysPara->para.RFIDInkWarn = true;
                        QDateTime curDateTime = QDateTime::currentDateTime();
                        QString strCurDateTime = curDateTime.toString("yyMMddhhmmss");
                        if(sysPara->para.inkWarnDate == 0){
                            sysPara->para.inkWarnDate = strCurDateTime.mid(0,6).toInt();
                            sysPara->para.inkWarnTime = strCurDateTime.mid(6,6).toInt();
                        }
                        sysPara->saveParaToFile();
                    }
                    else{
                        LogInfo::setRunStatusText(tr("detect Ink warning cnt: %1").arg(warnNum1));
                        qDebug()<<"检测到墨水液位次数:"<<warnNum1;
                    }
                }
                else{
                    sysPara->status.flagOfNeedInkCard = true;
                    if(logFlag4){
                        logFlag4 = 0;
                        QString strDate = QString::number(sysPara->para.inkWarnDate);
                        QString strTime = QString::number(sysPara->para.inkWarnTime);
                        QString str1 = QString::number(strDate.mid(0,2).toInt()).rightJustified(2,'0');
                        QString str2 = QString::number(strDate.mid(2,2).toInt()).rightJustified(2,'0');
                        QString str3 = QString::number(strDate.mid(4,2).toInt()).rightJustified(2,'0');
                        QString str4 = QString::number(strTime.mid(0,2).toInt()).rightJustified(2,'0');
                        QString str5 = QString::number(strTime.mid(2,2).toInt()).rightJustified(2,'0');
                        QString str6 = QString::number(strTime.mid(4,2).toInt()).rightJustified(2,'0');
                        QString strDateTime = str1 + "-" + str2 + "-" + str3 + " " + str4 + ":" + str5 + ":" + str6;
                        LogInfo::setRunStatusText(tr("ink Warning at: %1").arg(strDateTime));
                        qDebug()<<"ink Warning at:"<<strDateTime;
                    }
                }
            }

            if(sysPara->RFIDPara.PrintInkDots >= MAX_INK_DOTS || sysPara->para.RFIDInkWarn){
                sysPara->status.flagOfNeedInkCard = true;
                if(sysPara->RFIDPara.InkRFIDCnt == 0){
                    msgtest->setText(tr("请使用原厂墨水,然后刷墨水卡,否则机器将在24小时后禁止使用!"));
                    msgtest->show();
                    ui->tabMainWindow->setRunStatus(tr("请使用原厂墨水,然后刷墨水卡,否则机器将在24小时后禁止使用!"));
                    LogInfo::setRunStatusText(tr("请使用原厂墨水,然后刷墨水卡,否则机器将在24小时后禁止使用!"));
                }
                int timeRemain = (MAX_INK_RFIDTIME - sysPara->RFIDPara.InkRFIDCnt)/60;
                if(timeRemain > 60){
                    if(sysPara->RFIDPara.PrintInkDots >= MAX_INK_DOTS)
                        ui->tabMainWindow->setRunStatus(tr("1.请使用原厂墨水,然后刷墨水卡,否则机器将在%1小时后禁止使用!").arg(timeRemain/60));
                    else
                        ui->tabMainWindow->setRunStatus(tr("2.请使用原厂墨水,然后刷墨水卡,否则机器将在%1小时后禁止使用!").arg(timeRemain/60));
                }
                else if(timeRemain > 0){
                    if(sysPara->RFIDPara.PrintInkDots >= MAX_INK_DOTS)
                        ui->tabMainWindow->setRunStatus(tr("1.请使用原厂墨水,然后刷墨水卡,否则机器将在%1分钟后禁止使用!").arg(timeRemain));
                    else
                        ui->tabMainWindow->setRunStatus(tr("2.请使用原厂墨水,然后刷墨水卡,否则机器将在%1分钟后禁止使用!").arg(timeRemain));
                }
                if(sysPara->RFIDPara.InkRFIDCnt % 300 == 0)
                    sysPara->saveRFIDPara();
                if(++sysPara->RFIDPara.InkRFIDCnt >= MAX_INK_RFIDTIME)
                    sysPara->status.flagOfInkMaxDot = true;
            }

            if(sysPara->status.flagOfInkMaxDot){
                if(sysPara->status.isPrinting)
                    ui->tabMainWindow->on_pushButtonStopPrint_pressed();
                static bool logFlag2= true;
                if(sysPara->RFIDPara.PrintInkDots >= MAX_INK_DOTS){
                    ui->tabMainWindow->setRunStatus(tr("1.请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
                    if(logFlag2){
                        logFlag2 = false;
                        msgtest->setText(tr("请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
                        msgtest->show();
                        LogInfo::setRunStatusText(tr("请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
                        qDebug()<<"打印墨点已达到2.3billion,请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!";
                    }
                }
                else{
                    ui->tabMainWindow->setRunStatus(tr("2.请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
                    if(logFlag2){
                        logFlag2 = false;
                        msgtest->setText(tr("请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
                        msgtest->show();
                        LogInfo::setRunStatusText(tr("请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
                        qDebug()<<"请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!";
                    }
                }
            }
            /*****************墨水刷卡控制end**********************************************/

            /*****************溶剂刷卡控制start**********************************************/
            /*溶剂刷卡新的控制逻辑*/
            /* 1.任何时候，混合阀打开次数达到360次，提示2小时关机，必须刷卡才能恢复*/
            /*2.溶剂液位报警后，提示刷卡，允许有10次的混合阀打开次数，必须刷卡才能恢复*/
            if(sysPara->RFIDPara.solventNumber >= MAX_SOLV_OPENNUM){ //混合阀打开次数达到360次
                sysPara->status.flagOfNeedSolventCard = true;
                if(sysPara->RFIDPara.SOLVRFIDCnt == 0){
                    msgtest->setText(tr("请使用原厂溶剂,然后刷溶剂卡,否则机器将在2小时后禁止使用!"));
                    msgtest->show();
                    LogInfo::setRunStatusText(tr("请使用原厂溶剂,然后刷溶剂卡,否则机器将在2小时后禁止使用!"));
                }
                int timeRemain = (MAX_SOLV_RFIDTIME - sysPara->RFIDPara.SOLVRFIDCnt)/60;
                if(timeRemain > 0)
                    ui->tabMainWindow->setRunStatus(tr("请使用原厂溶剂,然后刷溶剂卡,否则机器将在%1分钟后禁止使用!").arg(timeRemain));
                if(sysPara->RFIDPara.SOLVRFIDCnt % 300 == 0)
                    sysPara->saveRFIDPara();
                if(++sysPara->RFIDPara.SOLVRFIDCnt >= MAX_SOLV_RFIDTIME)
                    sysPara->status.flagOfSolventMaxNum = true;
            }

            static bool logFlag5 = 1;
            static int warnNum2 = 0;
            if(!(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN))
                warnNum2 = 0;
            if((sysPara->status.statWarn & WARN_STATUS_SOLV_WARN) || sysPara->para.RFIDSolventWarn){
                if(!sysPara->para.RFIDSolventWarn){
                    if(++warnNum2 > 6){
                        sysPara->para.RFIDSolventWarn = true;
                        sysPara->para.RFIDSolventWarnMixCnt = 0;
                        LogInfo::setRunStatusText(tr("请添加原厂溶剂,然后刷溶剂卡!"));
                        qDebug()<<"请添加原厂溶剂,然后刷溶剂卡,否则将会在打开10次混合阀之后禁用喷码机!";
                        QDateTime curDateTime = QDateTime::currentDateTime();
                        QString strCurDateTime = curDateTime.toString("yyMMddhhmmss");
                        if(sysPara->para.solventWarnDate == 0){
                            sysPara->para.solventWarnDate = strCurDateTime.mid(0,6).toInt();
                            sysPara->para.solventWarnTime = strCurDateTime.mid(6,6).toInt();
                        }
                        sysPara->saveParaToFile();
                    }
                    else{
                        LogInfo::setRunStatusText(tr("detect solvent warning cnt: %1").arg(warnNum2));
                        qDebug()<<"检测到溶剂液位次数:"<<warnNum2;
                    }
                }
                else{
                    sysPara->status.flagOfNeedSolventCard = true;
                    ui->tabMainWindow->setRunStatus(tr("请添加原厂溶剂,然后刷溶剂卡!"));
                    if(logFlag5){
                        logFlag5 = 0;
                        QString strDate = QString::number(sysPara->para.solventWarnDate);
                        QString strTime = QString::number(sysPara->para.solventWarnTime);
                        QString str1 = QString::number(strDate.mid(0,2).toInt()).rightJustified(2,'0');
                        QString str2 = QString::number(strDate.mid(2,2).toInt()).rightJustified(2,'0');
                        QString str3 = QString::number(strDate.mid(4,2).toInt()).rightJustified(2,'0');
                        QString str4 = QString::number(strTime.mid(0,2).toInt()).rightJustified(2,'0');
                        QString str5 = QString::number(strTime.mid(2,2).toInt()).rightJustified(2,'0');
                        QString str6 = QString::number(strTime.mid(4,2).toInt()).rightJustified(2,'0');
                        QString strDateTime = str1 + "-" + str2 + "-" + str3 + " " + str4 + ":" + str5 + ":" + str6;
                        LogInfo::setRunStatusText(tr("solvent Warning at: %1").arg(strDateTime));
                        qDebug()<<"solvent Warning at:"<<strDateTime;
                    }
                }
            }
            if(sysPara->para.RFIDSolventWarnMixCnt >= 10)
                sysPara->status.flagOfSolventMaxNum = true;

            if(sysPara->status.flagOfSolventMaxNum){
                if(sysPara->status.isPrinting)
                    ui->tabMainWindow->on_pushButtonStopPrint_pressed();
                static bool logFlag3 = true;
                if(sysPara->para.RFIDSolventWarnMixCnt>=10){
                    ui->tabMainWindow->setRunStatus(tr("请刷溶剂卡以恢复机器的正常功能"));
                    if(logFlag3){
                        logFlag3 = false;
                        msgtest->setText(tr("请刷溶剂卡以恢复机器的正常功能!"));
                        msgtest->show();
                        LogInfo::setRunStatusText(tr("请刷溶剂卡以恢复机器的正常功能"));
                        qDebug()<<"溶剂液位报警后已经打开混合阀10次,请刷卡以恢复机器的正常功能";
                    }
                }
                else{
                    ui->tabMainWindow->setRunStatus(tr("请刷溶剂卡以恢复机器的正常功能"));
                    if(logFlag3){
                        logFlag3 = false;
                        msgtest->setText(tr("请刷溶剂卡以恢复机器的正常功能!"));
                        msgtest->show();
                        LogInfo::setRunStatusText(tr("请刷溶剂卡以恢复机器的正常功能"));
                        qDebug()<<"已经打开混合阀360次,请刷卡以恢复机器的正常功能";
                    }
                }
            }
            /*****************溶剂刷卡控制end**********************************************/
#endif

            static bool resumeFlag = false;
            if(lostCommuFlag  || ui->tabMainWindow->updatePhaseIndicatorLight() || (sysPara->status.statWarn & (WARN_STATUS_POWER_MON|WARN_STATUS_INK_WARN|WARN_STATUS_SUMP_WARN
                                                                                                                |WARN_STATUS_SOLV_WARN|WARN_STATUS_POWER_MON)) || (sysPara->status.gearPumpRunStopFlag && pushButtonStartFlag) ||sysPara->status.lastHighVoltageFault)
            {		//updatePhaseIndicatorLight（）务必放前面
                sysPara->status.beeperOnFlag = true;
                if(sysPara->status.gearPumpRunStopFlag && pushButtonStartFlag)
                {
                    ui->tabMainWindow->setRunStatus(tr("压力泄漏或压力传感器故障!"));
                }
                if(!resumeFlag)
                {
                    resumeFlag = true;
                    pulse_4s = 0;
                    if(!sysPara->status.lastHighVoltageFault)
                    {
                        ui->tabMainWindow->onLabelFaultRusumePressed();
                    }
                }
            }
            else {
                sysPara->status.beeperOnFlag = false;
                sysPara->devOp->controlBeeper(false);
                if(pulse_4s >= 20)
                {
                    pulse_4s = 0;
                    resumeFlag = false;
                }
            }

            if(sysPara->status.beeperOnFlag){			//报警会时有时无
                sysPara->devOp->controlBeeper(!sysPara->devOp->isBeeperEnable());
            }

            if((sysPara->status.statWarn & (WARN_STATUS_POWER_MON))
                    ||sysPara->status.lastwarmInkPump||sysPara->status.lastwarmInkPump||sysPara->status.mainInkPumpError
                    ||sysPara->status.compressPumpError||sysPara->status.lastPhaseFault||sysPara->status.lastRecycleWarn||sysPara->status.lastHighVoltageFault)
            { //2013-12-12故障报警灯   杨
                sysPara->status.RedLightOnFlag = true;

            }
            else {
                sysPara->status.RedLightOnFlag = false;
                sysPara->devOp->controlRedLight(false);
                //sysPara->devOp->controlRedLight(true);
            }
            if(sysPara->status.RedLightOnFlag){			//报警会时有时无
                sysPara->devOp->controlRedLight(!sysPara->devOp->isRedLightEnable());
            }
            if((sysPara->status.statWarn & (WARN_STATUS_INK_WARN|WARN_STATUS_SOLV_WARN |WARN_STATUS_RECYCLE_FAULT|WARN_STATUS_SUMP_WARN))
                    && !sysPara->status.RedLightOnFlag){
                //if(!sysPara->status.RedLightOnFlag){
                sysPara->status.YellowLightOnFlag = true;
            }
            else {
                sysPara->status.YellowLightOnFlag = false;
                sysPara->devOp->controlYellowLight(false);
                //sysPara->devOp->controlYellowLight(true);
            }
            if(sysPara->status.YellowLightOnFlag){			//报警会时有时无
                sysPara->devOp->controlYellowLight(!sysPara->devOp->isYellowLightEnable());
            }

            if(sysPara->status.waitHightVolOff>0){
                sysPara->status.waitHightVolOff--;
                if(sysPara->status.waitHightVolOff==0){
                    sysPara->devOp->highVoltageCtrl(0);
                    ui->tabMainWindow->setRunStatus(tr("停止打印，自动关闭高压."));
                }
            }

        }//  1s

#ifdef WARNING
        static int pre_pressed=0,pre_hvcurrent=0,press_err_cnt=0;
        if(pulse_1s)
        {
            if((pre_pressed > sysPara->status.PRESSURE+70))
            {
                if(++press_err_cnt>3)
                {
                    LogInfo::setRunStatusText(tr("压力异常:上次压力值%1,当前压力值%2").arg(pre_pressed).arg(sysPara->status.PRESSURE));
                }
            }
            else
            {
                press_err_cnt = 0;
            }
            pre_pressed = sysPara->status.PRESSURE;


        }

        if(pulse_100ms)
        {
            if(pre_hvcurrent>150 && ( sysPara->status.HV_DETOUT> pre_hvcurrent+20) && (sysPara->status.waitHightVolOn==8 || sysPara->status.waitHightVolOff==1) &&  sysPara->status.isPrinting )
                pre_hvcurrent = sysPara->status.HV_DETOUT;

            if(sysPara->status.waitHightVolOn<8)sysPara->status.waitHightVolOn++;
            if(sysPara->status.isPrinting==0) sysPara->status.waitHightVolOn=0;
        }
#endif
        if(sysPara->devOp->color_flag ==3){
            sysPara->devOp->color_flag = 0;
            pulse_30s = 0;
        }
        else if(pulse_1s && sysPara->para.gearPumpEnable && sysPara->status.selfCheckDone
                && (!sysPara->status.statWarn) && !sysPara->status.powerOffAppending){
            // 隔膜泵速度告警逻辑：检测转速是否异常超过最大工作转速
            // 最大工作转速对应的RPM约为：300 * 60 * 1000 / (500 * 2) = 1800 RPM
            // 给予余量，告警阈值设为2200 RPM
            const int MAX_SPEED_ALARM = 2200;

            if(sysPara->status.gearPumpRunSpeed <= MAX_SPEED_ALARM)
            {
                pulse_30s = 0;
            }
            else{
                pulse_30s++;
                if(pulse_30s >= 30){
                        sysPara->status.flagOfSpeedAlarm = true;
                        sysPara->devOp->color_flag = 2;
                        if(pulse_30s % 500 == 0){
                        LogInfo::setRunStatusText(tr("泵转速异常过高，请立即停机并联系供应商!"));
                        qDebug()<<"泵转速异常过高，请立即停机并联系供应商!";
                        }
                    ui->tabMainWindow->setRunStatus(tr("泵转速异常过高，请立即停机并联系供应商!"));
                        sysPara->devOp->controlRedLight(true);
                        if(sysPara->status.isPrinting)
                            ui->tabMainWindow->on_pushButtonStopPrint_pressed();
                }
                if(pulse_30s % 10 == 0)
                    qDebug()<<"粘度: "<<QString::number(sysPara->status.viscosity);
            }
        }
        else if(sysPara->status.statWarn & 0xFE){
            sysPara->devOp->color_flag = 3;
            pulse_30s = 0;
        }
    }

    //测试代码,发布模式自动忽略

}

void InkJetPrinter::autoControlHeater(){
    //100ms
    static int tempDly=1830;
    if(sysPara->para.heatTime == 0)
        sysPara->para.heatTime = 5;
    int maxHeatTime = sysPara->para.heatTime * 600;
    if(sysPara->para.flagOfContinueHeat)
        maxHeatTime = 60* 600;
    if(tempDly) tempDly--;
    if(tempDly>=1800)
    {
        if(tempDly==1800)
        {
            sysPara->status.indoorTemperature = sysPara->status.TEMP_ADIN/4;
            sysPara->devOp->pumpValveCtrl(1);
            if(sysPara->status.indoorTemperature-35>0)
                ui->tabSystemSetting->updateViscosityAdjust((sysPara->status.indoorTemperature-35));
            else
                ui->tabSystemSetting->updateViscosityAdjust(0);
        }
        return;
    }
    if(sysPara->status.TEMP_ADIN/4 < sysPara->para.temperature && sysPara->status.heaterONTimeCnt < MAX_HEATER_TIME){
        if(tempDly==0) sysPara->status.heaterONTimeCnt ++;
//        if(!sysPara->devOp->isHearterEnable())
        sysPara->devOp->controlHeater(true);

        if(sysPara->status.heaterONTimeCnt == maxHeatTime)
        {
            if(sysPara->status.TEMP_ADIN/4 < (sysPara->para.temperature - 2)){
                LogInfo::setRunStatusText(tr("警告:加热器长时间无法达到预期温度，故障或设置错误！"));
                ui->tabMainWindow->setRunStatus("加热器长时间无法达到预期温度，故障或设置错误！");//20150105 no check
                sysPara->devOp->controlHeater(false);
            }
            else
                sysPara->status.heaterONTimeCnt = 0;
        }
    }
    else if(sysPara->status.TEMP_ADIN/4 >= (sysPara->para.temperature + 2)){
        if(sysPara->status.heaterONTimeCnt < maxHeatTime)
        {
            sysPara->status.heaterONTimeCnt = 0;
        }
//        if(sysPara->devOp->isHearterEnable())
        sysPara->devOp->controlHeater(false);
    }
}

void InkJetPrinter::cnt1GroupCheck(void)
{
#ifdef COUNTER1_BY_GROUP /* 分段计米 */
    static  unsigned char lastGroupRunningIndex = 0;
    if(sysPara->para.cnt1ByGroupEnalbe)
    {


        sysPara->devOp->ReadCnt1GroupStatus();
        if(lastGroupRunningIndex == sysPara->status.cnt1GroupRunningIndex)
            return;
        lastGroupRunningIndex = sysPara->status.cnt1GroupRunningIndex;

        emit updateCnt1GroupDisp(1);
    }
#endif
}

void InkJetPrinter::cntGroupCheck()
{
#ifdef COUNTER1_BY_GROUP /* 分段计米 */
    static  unsigned char mlastGroupRunningIndex = 0;
    if(sysPara->para.cnt1ByGroupEnalbe)
    {
        sysPara->devOp->ReadCnt1GroupStatus();
        if(mlastGroupRunningIndex != sysPara->status.cnt1GroupRunningIndex) {
            mlastGroupRunningIndex = sysPara->status.cnt1GroupRunningIndex;
            LogInfo::setRunStatusText("Next cnt1 group index: " + QString::number(sysPara->status.cnt1GroupRunningIndex));
        }
    }
#endif

#ifdef COUNTER2_BY_GROUP /* 分段计米2 */
    if(sysPara->para.cnt2ByGroupEnalbe)
    {
        sysPara->devOp->ReadCnt2GroupStatus();
        if(mlastGroupRunningIndex != sysPara->status.cnt2GroupRunningIndex) {
            mlastGroupRunningIndex = sysPara->status.cnt2GroupRunningIndex;
            LogInfo::setRunStatusText("Next cnt2 group index: " + QString::number(sysPara->status.cnt2GroupRunningIndex));
        }
    }
#endif
    emit sig_updateDisp(1);
}

void InkJetPrinter::autoControlCycleValve()
{
    if(!sysPara->status.selfCheckDone || (sysPara->status.flagOfPowerOnMode && sysPara->para.gearPumpEnable)){
        //				if(!sysPara->devOp->isCycleValveOpen()){			//循环阀    //定时开机循环时隔膜泵不开关循环阀
        //					sysPara->devOp->controlCycleValve(true);
        //				}
        cycleValveRunForSelfCheck();
        if(sysPara->status.flagOfPowerOnMode)
        {
            if(sysPara->devOp->isMixValveOpen()) {			//
                sysPara->devOp->controlMixValve(false);
            }
        }
    }
    else {
        if(sysPara->status.cycleValveOpenCntAfterSWintOff){		// 开循环阀
            if(!sysPara->devOp->isCycleValveOpen()){
                sysPara->devOp->controlCycleValve(true);
            }
            sysPara->status.cycleValveOpenCntAfterSWintOff --;
        }
        else if(sysPara->devOp->isCycleValveOpen()){            // 关循环阀
            sysPara->devOp->controlCycleValve(false);
        }
    }
}

void InkJetPrinter::autoControlValvePump(void)
{
    if(sysPara){
        if(!sysPara->status.isPumpValveControledByHand){

            /*---------------------------------供墨阀--------------------------------------------*/
            bool enableFlag = ((sysPara->status.statWarn & WARN_STATUS_INK_SWINT)
                               || (sysPara->status.lastRecycleWarn && sysPara->para.RecycleWarnAction) // 2017.8.15版本回收故障关供墨阀问题
                               || ( sysPara->status.HVFaultCloseEn ) //高压故障关闭墨线
                               )?false:true;		//墨线开关

            if(enableFlag != sysPara->devOp->isInkValveOpen()){
                if(enableFlag == false) {		//关闭供墨阀的顺序 先开循环阀后关闭供墨阀间
                    if (sysPara->status.cycleValveOpenCntAfterSWintOff == 0) {
                        sysPara->status.cycleValveOpenCntAfterSWintOff = MAX_CYCLEVALVE_OPEN_TIME_AFTER_SWITN_OFF;
                    }
                    if (sysPara->status.cycleValveOpenCntAfterSWintOff < 60) { //在准备关闭循环阀的时候关闭供墨阀
                        sysPara->devOp->controlInkValve(enableFlag);		//关供墨
                        sysPara->devOp->controlInkValvePWM(enableFlag);		//关供墨
                    }
                }
                else { //开供墨阀
                    if(!sysPara->devOp->isReclaimPumpOpen())	//开供墨阀之前要判断回收泵有没有开，没开就提前打开
                    {
                        sysPara->devOp->controlReclaimPump(true, false); // 回收泵开
                    }
                    if(!ui->tabMainWindow->m_2sFlag)
                    {
                        sysPara->devOp->controlInkValve(enableFlag);
                        sysPara->devOp->controlInkValvePWM(enableFlag);
                    }
                }
            }

            if(!sysPara->status.selfCheckDone) {
                if(!sysPara->devOp->isCycleValveOpen()) {
                    sysPara->devOp->controlCycleValve(false);
                }
            }
            else {
                autoControlCycleValve();
            }

            /*----------------------------------泄压阀-------------------------------------------*/
            //=====================================================================================================
            if(sysPara->status.PRESSURE - sysPara->para.pressure > MAX_PRESSURE_RELEASE_DIFF)
                sysPara->status.pressureOverFlowCnt ++;
            else
                sysPara->status.pressureOverFlowCnt = 0;

            if((
                        sysPara->status.releaseValveOpenApending ||
                        sysPara->status.pressureOverFlowCnt > 2
                        )				//防止干扰和误动作
                    && !sysPara->status.releaseValveDelayCnt)
            {
                if(!sysPara->devOp->isReleaseValveOpen())
                {			//泄压阀
                    sysPara->devOp->controlReleaseValve(true);
                }
                sysPara->status.releaseValveDelayCnt = MAX_RELEASE_VALVE_DELAY_CNT;
                sysPara->status.releaseValveOpenApending = true;
            }
            else
            {
                if(sysPara->devOp->isReleaseValveOpen())
                {			//
                    //sysPara->devOp->controlReleaseValve(false);
                }

                if(sysPara->status.releaseValveDelayCnt)
                    sysPara->status.releaseValveDelayCnt --;
                if(sysPara->status.PRESSURE < sysPara->para.pressure)
                {
                    sysPara->status.releaseValveOpenApending = false;
                    if(sysPara->devOp->isReleaseValveOpen()){ sysPara->devOp->controlReleaseValve(false);

                    }
                }
            }

            /*-----------------------------------主墨泵------------------------------------------*/
            if(sysPara->status.SEPTAL_POSITION < (sysPara->para.septalPostion - DIFF_SEPTAL_POSITION))
                sysPara->status.septalPositionOverFlowCnt ++;
            else
                sysPara->status.septalPositionOverFlowCnt = 0;
            if(sysPara->status.septalPositionOverFlowCnt > 2 && !sysPara->status.mainInkPumpError){		//主墨泵
                if(!sysPara->devOp->isMainInkPumpOpen()){
                    sysPara->devOp->controlMainInkPump(true);
                    sysPara->status.mainInkPumpRunTmCnt = 0;
                }
                else if(sysPara->status.selfCheckDone){
                    if(sysPara->status.mainInkPumpRunTmCnt < MAX_MAIN_INK_PUMP_RUN_TIME){													//
                        sysPara->status.mainInkPumpRunTmCnt ++;
                    }
                    else {
                        if(!sysPara->para.gearPumpEnable)
                        {
                            sysPara->status.mainInkPumpError = true;
                            sysPara->devOp->controlMainInkPump(false);
                            LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!主墨泵故障"));
                            ui->tabMainWindow->setRunStatus(tr("主墨泵故障!!!"));
                        }
                    }
                }
            }
            else if(sysPara->status.SEPTAL_POSITION > sysPara->para.septalPostion){
                if(sysPara->devOp->isMainInkPumpOpen())
                    sysPara->devOp->controlMainInkPump(false);
            }
            /*-----------------------------------压缩机------------------------------------------*/

            if((sysPara->para.pressure - sysPara->status.PRESSURE > MAX_PRESSURE_DIFF) && !sysPara->status.compressPumpError){	//压缩机
                if(!sysPara->devOp->isCompressPumpOpen()){
                    sysPara->devOp->controlCompressPump(true);
                    sysPara->status.compressPumpRunTmCnt = 0;
                }
                else if(sysPara->status.selfCheckDone){
                    if(sysPara->status.compressPumpRunTmCnt < MAX_COMPRESS_PUMP_RUN_TIME){					//如果长时间开压缩机，考虑设备故障
                        sysPara->status.compressPumpRunTmCnt ++;
                    }
                    else {
                        sysPara->status.compressPumpError = true;
                        sysPara->devOp->controlCompressPump(false);
                        if(!sysPara->para.gearPumpEnable)
                        {
                            LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!压缩机故障"));
                            ui->tabMainWindow->setRunStatus(tr("压缩机故障!!!"));
                        }

                    }
                }
            }
            else if(sysPara->para.pressure <= sysPara->status.PRESSURE){		//压力到达预期的压力
                if(sysPara->devOp->isCompressPumpOpen())
                    sysPara->devOp->controlCompressPump(false);
            }

            /*------------------------------------粘度泵,混合阀-----------------------------------------*/

            /*-----------------------------每30s打开一次粘度泵以及相关处理--------------------------------------*/
            static bool hasDetectedBellow = false; // 检测到下位灯
            static bool hasDetectedTop = false;  // 检测到上位灯
            static int viscosity_low = 0; //统计粘度连续偏低10%次数
            static unsigned char Mixing_valve_open = 0;  //统计粘度连续偏高5%次数
            static unsigned char viscosity_faulty_num = 0; //统计粘度连续偏高13%次数
            static bool flag = 0;

            if(sysPara->status.cycleValveOpenCntAfterSWintOff) { //关闭墨线的时候要提前开粘度泵
                sysPara->status.viscosityDelayCnt = sysPara->para.viscosityPumpInterval*100 + 100;
            }
            ++sysPara->status.viscosityDelayCnt;
            int mixer_open_threshold = (105*sysPara->para.viscosity)/100;
            int viscosity_faulty_threshold =(113*sysPara->para.viscosity)/100;
            if(sysPara->status.viscosityDelayCnt >= sysPara->para.viscosityPumpInterval*100 && flag == 0)
            {
                flag=1;
                if (!sysPara->devOp->isViscosityPumpOpen())
                {
                    sysPara->devOp->controlViscosityPump(true);
                    viscosity_timer->start(10000);
                    qDebug()<<"粘度: "<<QString::number(sysPara->status.viscosity);
                }
                if((sysPara->status.viscosity >= 90*sysPara->para.viscosity/100) && (sysPara->status.viscosity <= mixer_open_threshold))
                {
                    sysPara->status.viscosityFault = 0;
                    viscosity_low=0;
                    Mixing_valve_open = 0;
                    viscosity_faulty_num = 0;
                }
                if(sysPara->status.viscosity < 90*sysPara->para.viscosity/100)
                {
                    viscosity_low++;
                    viscosity_faulty_num = 0;
                    Mixing_valve_open = 0;
                }
                if(sysPara->status.viscosity > mixer_open_threshold && sysPara->status.viscosity <= viscosity_faulty_threshold)
                {
                    Mixing_valve_open++;
                    viscosity_low = 0;
                    viscosity_faulty_num = 0;
                }
                if(sysPara->status.viscosity > viscosity_faulty_threshold){
                    Mixing_valve_open++;
                    viscosity_faulty_num++;
                    viscosity_low = 0;
                }

                if((!sysPara->devOp->isMixValveOpen()) && (((Mixing_valve_open > 1) && (!sysPara->para.gearPumpEnable)) || ((Mixing_valve_open > 4) && sysPara->para.gearPumpEnable))) {			//
                    sysPara->devOp->controlMixValve(true);
                    Mixing_valve_open = 0;
                    LogInfo::setRunStatusText(tr("添加溶剂:")+QString::number(sysPara->status.viscosity));
                    qDebug()<<"添加溶剂";
                }

                if(viscosity_low >= 60)
                {
                    LogInfo::setRunStatusText(tr("警告!!!!!!!!!!!粘度值偏低")+QString::number(sysPara->status.viscosity));
                    qDebug()<<"粘度值偏低";
                    sysPara->status.viscosityFault = 2;
                    if(sysPara->devOp->isMixValveOpen()) {
                        sysPara->devOp->controlMixValve(false);
                    }
                }
                if(viscosity_faulty_num >= 5)
                {
                    LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!粘度偏大故障")+QString::number(sysPara->status.viscosity));
                    qDebug()<<"粘度偏大故障";
                    sysPara->status.viscosityFault = 1;
                }

            }
            if((sysPara->status.viscosityDelayCnt >= (sysPara->para.viscosityPumpInterval*100+120)) && flag==1)
            {
                if(sysPara->devOp->isMixValveOpen()) {
                    sysPara->devOp->controlMixValve(false);
                }
            }

            if((sysPara->status.viscosityDelayCnt >= (sysPara->para.viscosityPumpInterval*100+130)) && flag==1)
            {
                if (sysPara->devOp->isViscosityPumpOpen()) {
                    sysPara->devOp->controlViscosityPump(false);
                }
                sysPara->status.viscosityDelayCnt = 0;
                flag=0;
            }

            if(sysPara->status.statWarn & WARN_STATUS_VISCOTITY_MEASURE_READY){ //上位灯检测标志位
                viscosity_timer->stop();
            }

            if(sysPara->status.viscosityDelayCnt < sysPara->para.viscosityPumpInterval*100) {
                static int detectBelow = 0;
                if (++detectBelow%400 == 0) {
                    if(sysPara->status.statWarn & WARN_STATUS_VISCOTITY_MEASURE_READY)
                    {
                        if(sysPara->status.rWarnViscoReady>=15){
                            sysPara->status.viscosityFault = 1;
                            sysPara->status.viscosity=0;
                            if(!firstTime)
                                qDebug()<<"错误!粘度计下位灯故障."+QString::number(sysPara->status.viscosity);
                            //  LogInfo::setRunStatusText(tr("错误!粘度计下位灯故障.")+QString::number(sysPara->status.viscosity));
                            hasDetectedBellow = true;
                        }
                        else   sysPara->status.rWarnViscoReady++;
                    }
                    else {
                        sysPara->status.rWarnViscoReady = 0;
                        sysPara->status.viscosityFault = 0;
                    }
                }
            }
            if(hasDetectedBellow && hasDetectedTop)
            {
                if(sysPara->devOp->isMixValveOpen()) {			//
                    sysPara->devOp->controlMixValve(false); //如果检测不到上下位灯就关掉混合阀
                }
            }
            if(sysPara->status.viscosityFault==0)
            {
                hasDetectedBellow = false;
                hasDetectedTop = false;
            }
            //            }
            /*-----------------------------------回收泵------------------------------------------*/

            if(!sysPara->status.autoCtlReclaimAfterSWintOff)
            {
                if(!sysPara->devOp->isReclaimPumpOpen() ){					//回收泵
                    // ui->tabMainWindow->setRunStatus(tr("全速回收泵!!!"));
                    sysPara->status.reclaimPumpFullSpeedCnt = 0;
                    sysPara->devOp->controlReclaimPump(true,true);			//先全速，后降速
                }
                else if(sysPara->status.reclaimPumpFullSpeedCnt <= RECLAIM_PUMP_FULL_SPEED_CNT){
                    sysPara->status.reclaimPumpFullSpeedCnt ++;
                    if(sysPara->status.reclaimPumpFullSpeedCnt == RECLAIM_PUMP_FULL_SPEED_CNT){		//降速
                        // ui->tabMainWindow->setRunStatus(tr("降速回收泵!!!"));
                        sysPara->devOp->controlReclaimPump(true,false);
                    }
                }
            }
            /*-----------------------------------------------------------------------------*/
        }
    }
}
//==========================
// 放在10ms的定时器运行,但和粘度泵工作周期一致
void InkJetPrinter::checkMixValveOpen(){
    //混合阀
    if(sysPara->status.viscosity>40000){
        sysPara->status.viscosityMaxFaultCnt++;
        if(sysPara->status.viscosityMaxFaultCnt>5)
        {
            sysPara->status.viscosityMaxFaultCnt=0;
            if(sysPara->status.viscosityFault ==0 )  LogInfo::setRunStatusText(tr("粘度检测异常,粘度值太大!!!"));
            sysPara->status.viscosityFault=1;
        }
        sysPara->status.viscosity=0;
    }
    int mixer_open_threshold = MAX_VISICOSITY_RATIO*sysPara->para.viscosity/100;
    int mixer_open_threshold_high = (MAX_VISICOSITY_RATIO + 11)*sysPara->para.viscosity/100;
    if(sysPara->status.viscosity > mixer_open_threshold)
    {// 粘度值高报警： 条件＠高于设定值的1.05，时间：120个测量周期
        sysPara->status.visocityValueOverflowNum ++;
        if(sysPara->status.visocityValueOverflowNum >= (MAX_VISICOSITY_VALUE_OVERFLOW_NUM/3)){
            if((sysPara->status.viscosity >= mixer_open_threshold_high)//超出太多加得快，否则隔三下，加一下
                    || ((sysPara->status.visocityValueOverflowNum % 3) == 0)){
                if(!sysPara->devOp->isMixValveOpen()){			//
                    sysPara->devOp->controlMixValve(true);
                    LogInfo::setRunStatusText(tr("混合阀打开2:")+QString::number(sysPara->status.viscosity));
                }
            }
        }
        if(sysPara->status.visocityValueOverflowNum > MAX_ALLOW_VISICOSITY_OVERFLOW_NUM){
            if(sysPara->status.viscosityFault ==0 )
                LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!粘度偏大故障"));

            sysPara->status.viscosityFault = 1;
        }
    }
    else if(sysPara->status.viscosity > 90*sysPara->para.viscosity/100){
        // 粘度值正常
        sysPara->status.visocityValueOverflowNum = 0;
        sysPara->status.viscosityFault = 0; // 20160922 粘度低报警不能复位问题
    }
    else {// 粘度值低报警： 条件＠ 低于设定值的0.9，时间：60个测量周期
        sysPara->status.visocityValueOverflowNum ++;
        if(sysPara->status.visocityValueOverflowNum > (MAX_ALLOW_VISICOSITY_OVERFLOW_NUM/2)){

            if(sysPara->status.viscosityFault ==0 )  LogInfo::setRunStatusText(tr("警告!!!!!!!!!!!粘度值偏低"));
            sysPara->status.viscosityFault = 2;
            sysPara->status.visocityValueOverflowNum=MAX_ALLOW_VISICOSITY_OVERFLOW_NUM-10;
        }
    }
}


void InkJetPrinter::checkMixValveClose(){
    if(sysPara->devOp->isMixValveOpen()){			//		关闭混合阀
        sysPara->devOp->controlMixValve(false);
    }
}

//在开机自检过程中交替打开和关闭循环阀
void InkJetPrinter::cycleValveRunForSelfCheck(){
    static int cycleValveOpenCnt = 0;
    if (++cycleValveOpenCnt%300 > 150) {
        if(!sysPara->devOp->isCycleValveOpen()){			//循环阀 开
            sysPara->devOp->controlCycleValve(true);
        }
    }
    else {
        if(sysPara->devOp->isCycleValveOpen()){			//循环阀 关
            sysPara->devOp->controlCycleValve(false);
        }
    }
}

void InkJetPrinter::onReclaimTankBlock(){
    if(sysPara){
        ui->tabMainWindow->enableReclaimCtrlButton(true);
        sysPara->status.reclaimTankBlockedAppending = true;
        if(sysPara->status.powerOffAppending && sysPara->status.powerOffAfterPhaseFaultAppending)
            ui->tabMainWindow->checkForPowerOff();
        sysPara->status.powerOffAppending = false;				//如果有关机动作，终止

    }

}
/*
 *
 * 控制回收槽
 *
 * */

void InkJetPrinter::detectAndcontrolReclaimTank(){
    sysPara->status.currReclaimTankPos =10*sysPara->status.curr_reclaimTankTime;
    sysPara->status.reclaimTankBlockedAppending =0;
    //qDebug()<<sysPara->status.reclaimTankstatus;
    //    if(sysPara->status.currReclaimTankPos == 0)
    //        ui->tabMainWindow->setReBootQtUIEnable(false);
    //     else
    //        ui->tabMainWindow->setReBootQtUIEnable(true);

    if(sysPara->status.reclaimTankstatus == 0x10) //7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        if(sysPara->devOp->isReclaimTankCloseEnable())
        {
            LogInfo::setRunStatusText(tr("电机故障"));
            ui->tabMainWindow->setRunStatus(tr("电机故障"));
            sysPara->devOp->controlReclaimTankClose(false);
            ui->tabMainWindow->resetReclaimCtrlButtonText();
            emit reclaimTankBlock();
        }
        else {
            LogInfo::setRunStatusText(tr("电机故障"));
            ui->tabMainWindow->setRunStatus(tr("电机故障!!!"));
            if(sysPara->devOp->isReclaimTankOpenEnable())
                sysPara->devOp->controlReclaimTankOpen(false);
            ui->tabMainWindow->resetReclaimCtrlButtonText();
            emit reclaimTankBlock();
        }

    }
    else  if(sysPara->status.reclaimTankstatus == 5)//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        if(sysPara->devOp->isReclaimTankOpenEnable())
            sysPara->devOp->controlReclaimTankOpen(false);		//到头，关闭
        sysPara->status.reclainTankReachEnd = true;
        /*应要求去掉多余到信息 LogInfo::setRunStatusText(tr("回收槽到头"));*/
        if(sysPara->status.currReclaimTankPos != 0)
            ui->tabMainWindow->setRunStatus(tr("回收槽到头"));
            
        ui->tabMainWindow->enablePrintButton(true);			//仅仅在此时能使能打印按钮
        ui->tabMainWindow->resetReclaimCtrlButtonText();
        // sysPara->devOp->highVoltageCtrl(1);
        emit reclaimTankOpenDone();
        /*回收槽开关时间校正*/
        sysPara->para.reclaimTankTime =( sysPara->status.currReclaimTankPos>120 )? sysPara->status.currReclaimTankPos/10-1:12;
        ui->tabSystemSetting->updateReclaimTime( sysPara->para.reclaimTankTime );

        qDebug()<<"reclaimTankOpenDone currReclaimTankPos:"<<sysPara->status.currReclaimTankPos;
        qDebug()<<"reclaimTankOpenDone curr_reclaimTankTime:"<<sysPara->status.curr_reclaimTankTime;
    }
    else  if(sysPara->status.reclaimTankstatus == 0x11 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        sysPara->devOp->controlReclaimTankOpen(false);		//卡住，关闭
        ui->tabMainWindow->resetReclaimCtrlButtonText();
        LogInfo::setRunStatusText(tr("回收槽卡住或者回收槽开关时间设置错误"));
        ui->tabMainWindow->setRunStatus(tr("回收槽卡住或者回收槽开关时间设置错误"));
        emit reclaimTankBlock();
    }
    else  if(sysPara->status.reclaimTankstatus == 1 || sysPara->status.reclaimTankstatus == 2)//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        emit setReclaimTankCurrentPos(sysPara->status.currReclaimTankPos);
        sysPara->status.reclaimBlockedCnt = 0;

    }
    else  if(sysPara->status.reclaimTankstatus == 6 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        if(sysPara->devOp->isReclaimTankCloseEnable())
            sysPara->devOp->controlReclaimTankClose(false);		//到头，关闭
        /*应要求去掉多余到信息 LogInfo::setRunStatusText(tr("回收槽到头"));*/
        ui->tabMainWindow->setRunStatus(tr("回收槽到头"));
        //sysPara->status.currReclaimTankPos = 0;				//将回收槽的时间置为零
        ui->tabMainWindow->resetReclaimCtrlButtonText();
        emit reclaimTankCloseDone();
        sysPara->status.lastRecycleWarn = 0;
        sysPara->status.HVFaultCloseEn=0;
        sysPara->status.reclainCloseAppending=false;
        sysPara->status.canRunAirPushing = true; //下次开回收槽就执行排气程序
        qDebug()<<"reclaimTankCloseDone currReclaimTankPos:"<<sysPara->status.currReclaimTankPos;
        qDebug()<<"reclaimTankCloseDone curr_reclaimTankTime:"<<sysPara->status.curr_reclaimTankTime;
    }
    else  if(sysPara->status.reclaimTankstatus == 0x12 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        sysPara->devOp->controlReclaimTankOpen(false);		//到头，关闭
        LogInfo::setRunStatusText(tr("回收槽卡住或者回收槽开关时间设置错误"));
        ui->tabMainWindow->setRunStatus(tr("回收槽卡住或者回收槽开关时间设置错误"));
        ui->tabMainWindow->resetReclaimCtrlButtonText();
        emit reclaimTankBlock();
    }
    else // if(sysPara->status.reclaimTankstatus == 7 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        emit setReclaimTankCurrentPos(sysPara->status.currReclaimTankPos);
    }
}

static void controlTabDisplay(QTabWidget *tab,QWidget *page,QString name,int enable){
    if(enable){
        if(tab->indexOf(page) == -1){
            tab->addTab(page,name);

        }
    }
    else {
        int index = tab->indexOf(page);
        if(index != -1)
            tab->removeTab(index);
    }

}

static void controlTabDisplay(QTabWidget *tab,QWidget *page,QString name,int enable,int Pos){
    if(enable){
        if(tab->indexOf(page) == -1){
            tab->insertTab(Pos,page,name);
        }
    }
    else {
        int index = tab->indexOf(page);
        if(index != -1)
            tab->removeTab(index);
    }

}
void InkJetPrinter::onAuthChanged(int auth){

    controlTabDisplay(this,ui->tabSystemSetting,tr("系统设置"),auth&AUTH_DISPLAY_SYSTEM_SETTING);
    controlTabDisplay(this,ui->tabSystemManage,tr("系统管理"),auth&AUTH_DISPLAY_SYSTEM_MANAGE);
    controlTabDisplay(this,ui->tabOtherInfo,tr("其他信息"),auth& AUTH_DISPLAY_OTHER_INFO);
    controlTabDisplay(this,ui->tabLogInfo,tr("日志信息"),auth&AUTH_DISPLAY_LOG_INFO);
    controlTabDisplay(this,ui->tabNetworkManager,tr("网络管理"),auth&AUTH_SUPER_USER1);

    // controlTabDisplay(this,ui->tabZkEdit,tr("图案编辑"),auth);
    ui->tabPrintSetting->updateAuthorization(auth);
    ui->tabSystemSetting->updateAuthorization(auth);
    ui->tabNetworkManager->updateAuthorization(auth);
}

void InkJetPrinter::onConfigChanged(void){

    sysPara->loadParaFromFile();
}

/*
 * 这个方法的主要目的是在切换tab时不要弹出输入法
 *
 */

void InkJetPrinter::onInkJetPrinterCurrentChanged(int index)
{
    QWidget *w = widget(index);
    if(w){
        QWidget *subWidget = w->focusWidget();
        if(subWidget)
            subWidget->clearFocus();
    }
    //if(index == 3||index == 3)  //刷新打印设置这个界面
    {
        ui->tabPrintSetting->update();
    }

}

void InkJetPrinter::closeEvent(QCloseEvent *event)
{
    event->ignore();
}
void InkJetPrinter::resizeEvent(QResizeEvent *event){

    event->ignore();
}

void InkJetPrinter::onChangeTab(QString)
{
    this->setCurrentIndex (indexOf( ui->tabPicEdit));
}
void InkJetPrinter::onchangeEditMode(int)
{
    if(sysPara){
        if(sysPara->para.EditMode == PICFILE) {
            insertTab(1,ui->tabPicEdit,tr("信息编辑"));
            // controlTabDisplay(this,ui->tabZkEdit,tr("图案编辑"),0);
        }
        else if(sysPara->para.EditMode == TXTFILE|| sysPara->para.EditMode == SCENE){
            controlTabDisplay(this,ui->tabPicEdit,tr("信息编辑"),0);
            // controlTabDisplay(this,ui->tabZkEdit,tr("图案编辑"),1,1);
        }
        ui->tabMainWindow->changeEditMode(sysPara->para.EditMode);
    }
    else{

    }
}


void InkJetPrinter::OnSpeedOver(int mode)
{
    if(mode==2){
        //emit QMessageBox::warning(NULL,tr("警告"),tr("喷印速度过快或间隔太短！无法喷印完全，自动暂停喷印!!!"));
        msgtest->setText(tr("喷印速度过快或间隔太短！无法喷印完全，自动暂停喷印!!!"));
        msgtest->show();
    }
    else if(mode==1){
        //emit QMessageBox::warning(NULL,tr("警告"),tr("喷印速度过快或间隔太短！无法喷印完全!!!"));
        msgtest->setText(tr("喷印速度过快或间隔太短！无法喷印完全!!!"));
        msgtest->show();
    }
}

void InkJetPrinter::onPrintErrorStatus(QString s,unsigned int res)
{
    if(res==1 || sysPara->status.WorkTimeOut ){
        sysPara->status.WorkTimeOut =1;
        sysPara->devOp->printCtrl( PRINT_CTRL_STOP);
        //emit  QMessageBox::warning(NULL,tr("警告"),s);
        msgtest->setText(s);
        msgtest->show();
    }
    else if(res==2) {
        //emit QMessageBox::warning(NULL,tr("警告"),s);
        msgtest->setText(s);
        msgtest->show();
    }
    else if(res==3)    {        sysPara->status.WorkTimeOut =0;    }
}
void InkJetPrinter::OnFinished(int event){
    //msgtest->setText(" ");msgtest->show();
    Q_UNUSED(event);
    msgtest->hide();

}
void InkJetPrinter::OnBoxFinished(int event){
    //msgtest->setText(" ");msgtest->show();
    Q_UNUSED(event);
    msgBox1->hide();

}
unsigned char BCDtoHEX(unsigned char BCD)
{
    unsigned char tempData;

    tempData = (BCD >> 4) * 10 + (BCD & 0x0F);
    return (tempData);
}
void InkJetPrinter::refreshModbusStatus(void)
{
#ifdef MODBUS
    if (modbus->getModbusStatus() != 1) {
        qDebug()<<"refresh get modbus error";
        return;
    }

    qint16 fileNameSize = QFileInfo(sysPara->para.lastOpenedFileName).fileName().size();
    if (fileNameSize) {
        if (fileNameSize > 100) {
            fileNameSize = 100;
        }
    }
    QString str = QFileInfo(sysPara->para.lastOpenedFileName).fileName();
    snprintf((char *)sysPara->modbusStatus.usedFileName, sizeof(sysPara->modbusStatus.usedFileName), "%s",(char *)str.toLatin1().constData());
    sysPara->modbusStatus.printStatus = ui->tabMainWindow->getCurrPrintStatus();
    memcpy(&sysPara->modbusStatus.curCalendarAndDate, &sysPara->status.calandar_and_dat, sizeof(sysPara->status.calandar_and_dat));

    unsigned char tmp[4];
    memcpy(&tmp,&sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue,4);
    tmp[0] = BCDtoHEX(tmp[0]);
    tmp[1] = BCDtoHEX(tmp[1]);
    tmp[2] = BCDtoHEX(tmp[2]);
    tmp[3] = BCDtoHEX(tmp[3]);
    //memcpy(&sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue,&tmp,4);
    sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue = tmp[3]*1000000 + tmp[2]*10000+ tmp[1]*100 + tmp[0] ;
    //sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue = QString::number(sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue).toUInt(0,16);
    sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt();
    sysPara->modbusStatus.curCalendarAndDate.cnt2CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt();
    sysPara->modbusStatus.curCalendarAndDate.cnt1End = sysPara->para.cnt1EndValue;
    sysPara->modbusStatus.curCalendarAndDate.cnt2End = sysPara->para.cnt2EndValue;
    sysPara->modbusStatus.curCalendarAndDate.cnt2Repeat = sysPara->para.cnt2RepeateValue;
    sysPara->modbusStatus.curCalendarAndDate.cnt2InitValue = sysPara->para.cnt2StartValue;
    sysPara->modbusStatus.productCnt = sysPara->status.productCnt;


    sysPara->modbusStatus.statWarn = sysPara->status.RedLightOnFlag ;
    // 显示正在打印内容的行数和列数
    int wmax = sysPara->status.currPrintRow;
    if (sysPara->para.AlterMode) {
        wmax = sysPara->status.currAlterPrintRow;
    }
    sysPara->modbusStatus.mbCurrPrintRow = wmax;
    sysPara->modbusStatus.mbCurrPrintCol = sysPara->status.currPrintCol;
#endif
}

void InkJetPrinter::onModbusWriteCalendar()
{
#ifdef MODBUS
    if (modbus->getModbusStatus() == -1) {
        qDebug()<<"get modbus error";
        return;
    }

    sysPara->para.cnt1StartValue = sysPara->modbusParas.setCalendar.cnt1CurrValue;
    sysPara->para.cnt1EndValue = sysPara->modbusParas.setCalendar.cnt1End;
    sysPara->para.cnt1CurrValue = sysPara->modbusParas.setCalendar.cnt1Repeat;
    sysPara->para.cnt1StepValue = sysPara->modbusParas.setCalendar.cnt1Step;

    sysPara->para.cnt2StartValue = sysPara->modbusParas.setCalendar.cnt2InitValue;
    sysPara->para.cnt2EndValue = sysPara->modbusParas.setCalendar.cnt2End;
    sysPara->para.cnt2StepValue = sysPara->modbusParas.setCalendar.cnt2Repeat;
    sysPara->para.cnt2RepeateValue = sysPara->modbusParas.setCalendar.cnt2Step;

    if (sysPara->modbusParas.setCalendar.cntCurrValueInitEnable & 0x02) {
        sysPara->status.cnt2CurrentValueInitDoneFlag = 0;
    }
    if (sysPara->modbusParas.setCalendar.cntCurrValueInitEnable & 0x01) {
        sysPara->status.cnt1CurrentValueInitDoneFlag = 0;
    }
    sysPara->para.cnt1CurrValue = sysPara->modbusParas.setCalendar.cnt1CurrValue;
    sysPara->para.cnt2CurrValue = sysPara->modbusParas.setCalendar.cnt2CurrValue;
    sysPara->devOp->writeFpgaCalandar(0);
    emit updataPara2UI();
#endif
}

void InkJetPrinter::close_jd_timer()
{
    timer->stop();
}


void InkJetPrinter::handlePushButtonStartPressed(bool flag)
{
    pushButtonStartFlag = flag;

    if(flag)
    {
        PID_init();
    }
    sysPara->status.gearPumpRunStopFlag = !flag;//齿轮泵开关
}

void InkJetPrinter::handleInitedPID()
{
    PID_init();
}

void InkJetPrinter::recievedFile2Save(QString fileName)
{
    //qDebug() << "recieveFile2Save:"<<fileName;
    QMessageBox::StandardButton ret;
    ret = QMessageBox::question(this, tr("提示"),
                                tr("是否接收新的信息!"),
                                QMessageBox::Ok | QMessageBox::Cancel);
    if (ret == QMessageBox::Ok){
        QString sourceName = "/tmp/" + fileName;
        QString saveName = DOC_DIR;
        saveName = saveName + "/";
        saveName = saveName + fileName;
        qDebug()<<"sourceName "<<sourceName<<"saveName "<<saveName;
        QDir *createfile     = new QDir;
        bool exist = createfile->exists(saveName);
        if (exist)
        {
            createfile->remove(saveName);
        }//end if
        QFile::copy ( sourceName,saveName );
        emit openFile(saveName,false);
        //emit startPrint();确认接收到消息立即打印
        //ui->tabMainWindow->getTexteditOption()->onFileOpen(saveName,false);
        //ui->tabMainWindow->on_pushButtonStartPrint_pressed();
    }
    else {

    }
}

void InkJetPrinter::viscosity_timerHandler()
{
    if(!firstTime)
        qDebug()<<"错误!粘度计故障:检测不到上位灯";
    // LogInfo::setRunStatusText(tr("错误!粘度计故障:检测不到上位灯"));
    viscosity_timer->stop();
    firstTime = 0;
}

void InkJetPrinter::disableTabClick(){
    this->setDisabled(true);
    this->setCurrentIndex(0);
}

void InkJetPrinter::enableInkJetTabClick(bool flag){
    this->setEnabled(flag);
}

bool InkJetPrinter::eventFilter(QObject *watched, QEvent *event)
{ 

    if(sysPara->status.flagOfKeyBoardType)
        return QTabWidget::eventFilter(watched,event);

    QSpinBox *qsb=dynamic_cast<QSpinBox*>(watched);
    QLineEdit *qle=dynamic_cast<QLineEdit*>(watched);
    QTextEdit *qte=dynamic_cast<QTextEdit*>(watched);
    QMouseEvent *me = dynamic_cast<QMouseEvent *>(event);
    switch (event->type()){
    case QEvent::FocusIn:
        if(qsb&&!qsb->isReadOnly()
                ||qle&&!qle->isReadOnly()
                ||qte&&!qte->isReadOnly())myInputMethod->updateHandler(1);
        break;
    case QEvent::FocusOut:
        myInputMethod->updateHandler(2);
        break;
    }

    return QTabWidget::eventFilter(watched,event);
}

void InkJetPrinter::sendDataManual(QString cmdstr,QString addrstr,QString datastr,QString lenstr,QString typestr){
    qDebug()<<"sendDataManual!!!";
    bool ok;
    quint8 arr[8]={0xAA,0x02,0x03,0x01,0x11,0x00,0x00,0x55};
    int cmd = cmdstr.toInt(&ok,16);
    int addr = addrstr.toInt(&ok,16);
    int len = lenstr.toInt(&ok,10);
    int type = typestr.toInt(&ok,10);
    QByteArray data;
    data.resize(datastr.length() / 2);

    for (int i = 0; i < datastr.length(); i += 2) {
        // 提取每两个字符
        QString byteString = datastr.mid(i, 2);
        // 将16进制字符串转换为unsigned char
        bool ok;
        unsigned char byte = static_cast<unsigned char>(byteString.toUInt(&ok, 16));
        data[i / 2] = byte;
    }
    //    quint16 data1[] = {68, 90, 108, 125, 141, 156, 170, 170, 180, 193, 204, 214};
    const char* charData = data.constData();

    // 转换为 unsigned char 指针
    const unsigned char* unsignedCharData = reinterpret_cast<const unsigned char*>(charData);
}

void InkJetPrinter::slt_showMsg(QString msg)
{
    msgtest->setText(msg);
    msgtest->show();
    LogInfo::setRunStatusText(msg);
}

/*************************FPGA通过串口读取状态赋值给status-start******************************************/
void InkJetPrinter::saveFPGAVersionNum(unsigned int data){
    sysPara->status.fpgaVersionNum=data;
}
unsigned char statWarnTempData=0;
void InkJetPrinter::saveFPGAStatus(unsigned char *data){
    quint16 len=data[5];
    len=len<<8;
    len+=data[6];
    unsigned char *target= ((unsigned char *)&sysPara->status);
    for(int i=0;i<len;i++){
        if(i == 17){
            statWarnTempData =(data[7+i] & 0x82);
        }
        else target[i]=data[7+i];
    }
    if(sysPara->status.dummy != sysPara->status.isPrinting && sysPara->status.selfCheckDone){
        sysPara->status.isPrinting = sysPara->status.dummy;
        ui->tabMainWindow->updatePrintDisplayLabel();
    }
}

void InkJetPrinter::saveFPGAPhaseDetectHighTm(unsigned char *data){
    quint16 len=data[5];
    len=len<<8;
    len+=data[6];
    unsigned char *target= ((unsigned char *)&sysPara->status.phaseDetectHighTm);
    for(int i=0;i<len;i++){
        target[i]=data[7+i];
    }
}

static int curCNT1 = 0;
void InkJetPrinter::saveFPGACalandarAndDat(unsigned char *data){
    quint16 len=data[5];
    len=len<<8;
    len+=data[6];
    unsigned char *target= ((unsigned char *)&sysPara->status.calandar_and_dat);
    for(int i=0;i<len;i++){
        target[i]=data[7+i];
    }
}

void InkJetPrinter::saveFPGACnt3CurrValue(unsigned char *data){
    quint16 len=data[5];
    len=len<<8;
    len+=data[6];
    unsigned char *target= ((unsigned char *)&sysPara->status.Status_Counter3.cnt3CurrValue);
    for(int i=0;i<len;i++){
        target[i]=data[7+i];
    }
}

void InkJetPrinter::saveFPGAXXXDay(unsigned char *data){
    quint16 len=data[5];
    len=len<<8;
    len+=data[6];
    unsigned char *target= ((unsigned char *)&sysPara->status.XXXDay);
    for(int i=0;i<len;i++){
        target[i]=data[7+i];
    }
}

void InkJetPrinter::stopSendFPGAData(bool flag){
    if(flag)
        sysPara->devOp->stopSendDataFPGA = true;
    else
        sysPara->devOp->stopSendDataFPGA = false;
}

void InkJetPrinter::stopSendSTM32Data(bool flag){
    if(flag)
        sysPara->devOp->stopSendDataSTM32 = true;
    else
        sysPara->devOp->stopSendDataSTM32 = false;
}


/*************************FPGA通过串口读取状态赋值给status-end******************************************/



//------------------------------------------------------------------------------------------------------------------------------------------



/*************************STM32通过串口读取状态赋值给status-start******************************************/
void InkJetPrinter::saveSTM32Status(unsigned char *data){
    unsigned char *target= ((unsigned char *)&sysPara->status)+0x44;
    for(int i=0;i<data[3];i++){
        if(i==16){
            target[i]=statWarnTempData | (data[4+i] & 0x7c);
        }
        else target[i]=data[4+i];
    }
    emit showReclaimTankstatus(sysPara->status.reclaimTankstatus);
    emit showMotorIsen(sysPara->status.MOTOR_ISEN,sysPara->status.AD_FIXED);
}

void InkJetPrinter::saveGearPumpVal(unsigned char *data){
    unsigned char *target= ((unsigned char *)&sysPara->para.gearPumpValue);
    for(int i=0;i<data[3];i++){
        target[i]=data[4+i];
    }
}


void InkJetPrinter::savePulseCntVal(unsigned char *data){
    qint16 speedTemp = 0 ;
    speedTemp = data[4+1];
    speedTemp = speedTemp << 8;
    speedTemp = speedTemp + data[4];
    if(speedTemp == 0 && sysPara->para.gearPumpValue > 0)
        return;

    unsigned char *target= ((unsigned char *)&PulseCnt);
    for(int i=0;i<data[3];i++){
        target[i]=data[4+i];
    }
}

void InkJetPrinter::saveSTM32Version(unsigned char *data){
    qDebug()<<"saveSTM32Version";
    static unsigned char STM32Verion[3] = {0}; //时间间隔内的脉冲累计数
    unsigned char *target= ((unsigned char *)&sysPara->status.stm32Verion);
    for(int i=0;i<data[3];i++){
        target[i]=data[4+i];
    }
    sysPara->status.flagOfPowerOnMode = (sysPara->status.stm32Verion>>23) & 0x01;
    if(sysPara->status.flagOfPowerOnMode)
        sysPara->status.waitPowerOffTime = 18;//半个小时
    else
        sysPara->status.waitPowerOffTime = 0;
    LogInfo::setRunStatusText(tr("flagOfPowerOnMode: %1").arg(sysPara->status.flagOfPowerOnMode));
    QString STM32Ver = QString("%1.%2.%3").arg((sysPara->status.stm32Verion>>16)&0x7F)
            .arg((sysPara->status.stm32Verion>>8) & 0xFF).arg(sysPara->status.stm32Verion&0xFF);
    qDebug()<<"STM32Ver:"<<STM32Ver;
}

void InkJetPrinter::saveSTM32Time(unsigned char *data){
    qDebug()<<"saveSTM32Time";
    LogInfo::setRunStatusText("saveSTM32Time");
    static uint8_t datatime[8] = {0};
    unsigned char *target= ((unsigned char *)&datatime);
    for(int i=0;i<data[3];i++){
        target[i]=data[4+i];
    }
    if(data[0] != 0){
        sysPara->status.stm32Time = true;
    }

    QString Year = QString::number(datatime[0])+QString::number(datatime[1]);
    QString Month = QString("%1").arg(datatime[2], 2, 10, QChar('0'));
    QString Day = QString("%1").arg(datatime[3], 2, 10, QChar('0'));
    QString Week = QString::number(datatime[4]);

    QString Hour = QString("%1").arg(datatime[5], 2, 10, QChar('0'));
    QString Minute = QString("%1").arg(datatime[6], 2, 10, QChar('0'));
    QString Second = QString("%1").arg(datatime[7], 2, 10, QChar('0'));
    QString date = Year+"-"+Month+"-"+Day+" "+Hour+":"+Minute+":"+Second;
    qDebug()<<QString("readSTM32Date: %1").arg(date);
    LogInfo::setRunStatusText(QString("readSTM32Date: %1").arg(date));
    LogInfo::setRunStatusText(QString("readSTM32Week: %1").arg(Week));
    ui->tabSystemManage->PowerOnSetTime(date);

}


/*************************STM32通过串口读取状态赋值给status-end******************************************/


void InkJetPrinter::closedSerial(){
    if(m_serialThreadFPGA->isRunning()){
        m_serialThreadFPGA->quit();
        m_serialThreadFPGA->wait();
    }
    if(m_serialThreadSTM32->isRunning()){
        m_serialThreadSTM32->quit();
        m_serialThreadSTM32->wait();
    }
    if(serialFPGA)
        delete serialFPGA;
    if(serialSTM32)
        delete serialSTM32;
}


static int highPressureCnt = 0;
static unsigned int logCnt = 0;
void InkJetPrinter::checkPressureControl(){ //1s
    unsigned int alarmPressure = 0;
    if(sysPara->para.pressure <= 700)
        alarmPressure = 800;
    else
        alarmPressure = 950;

    if(sysPara->status.PRESSURE > alarmPressure)
        highPressureCnt++;
    else
        highPressureCnt = 0;

    if(highPressureCnt >= 4 && sysPara->status.PRESSURE > 1000){
        QString str = tr("压力过高,请检查管路是否堵塞,然后点击故障恢复按钮");
        showMessage(str);
        sysPara->para.gearPumpValue = 0;
        sysPara->devOp->WriteMoterPump();
        sysPara->status.isPumpValveControledByHand = true;
        sysPara->devOp->mainInkCtrl();
        sysPara->status.flagOfPressureFault = true;
    }
}

void InkJetPrinter::showMessage(QString str){
    if(logCnt++ % 30 == 0){
        LogInfo::setRunStatusText(str);
        qDebug()<<str;
    }
    sysPara->devOp->color_flag = 2;
    ui->tabMainWindow->setRunStatus(str);
}

#ifdef __RFID_CARD
void InkJetPrinter::initRFIDManager()
{
    if (manager_rfid == nullptr) {
        manager_rfid = RFIDManager::instance();
        connect(manager_rfid, &RFIDManager::sig_showMsg,
                this, &InkJetPrinter::slt_showMsg);
    }
}
#endif

void InkJetPrinter::resetPressureCnt(){
    logCnt = 0;
    highPressureCnt = 0;
}

void InkJetPrinter::pressureAdjustForsystemseeting(){
    pressureAdj();
}

void InkJetPrinter::closeSerialFPGA(){
    if(m_serialThreadFPGA->isRunning()){
        m_serialThreadFPGA->quit();
        m_serialThreadFPGA->wait();
    }

    if(serialFPGA)
        delete serialFPGA;
}

void InkJetPrinter::closeSerialSTM32(){
    if(m_serialThreadSTM32->isRunning()){
        m_serialThreadSTM32->quit();
        m_serialThreadSTM32->wait();
    }
    if(serialSTM32)
        delete serialSTM32;
}

void InkJetPrinter::restartSerialPort(){

    closeSerialFPGA();
    closeSerialSTM32();

    serialFPGA = new Serial("/dev/ttyAS5");
    serialFPGA->moveToThread(m_serialThreadFPGA);
    connect(serialFPGA,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendFPGADate(int,int,unsigned char*,int,int)));
    connect(serialFPGA,SIGNAL(resendFPGAData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendFPGADate(int,int,unsigned char*,int,int)));
    connect(sysPara->devOp,SIGNAL(sendSerialDataToFPGA(int,int,unsigned char*,int,int)),serialFPGA,SLOT(sendSerialData(int,int,unsigned char*,int,int)),Qt::QueuedConnection);
    connect(serialFPGA,SIGNAL(getFPGAVersion(uint)),this,SLOT(saveFPGAVersionNum(uint)));
    connect(m_serialThreadFPGA,&QThread::started,serialFPGA,&Serial::startInitSlot);
    connect(serialFPGA,SIGNAL(stopSendData(bool)),this,SLOT(stopSendFPGAData(bool)));
    connect(serialFPGA,SIGNAL(getFPGAPhaseDetectHighTm(unsigned char*)),this,SLOT(saveFPGAPhaseDetectHighTm(unsigned char*)));
    connect(serialFPGA,SIGNAL(getFPGAStatus(unsigned char*)),this,SLOT(saveFPGAStatus(unsigned char*)));
    connect(serialFPGA,SIGNAL(getFPGACalandarAndDat(unsigned char*)),this,SLOT(saveFPGACalandarAndDat(unsigned char*)));
    connect(serialFPGA,SIGNAL(getFPGACnt3CurrValue(unsigned char*)),this,SLOT(saveFPGACnt3CurrValue(unsigned char*)));
    connect(serialFPGA,SIGNAL(getFPGAXXXDay(unsigned char*)),this,SLOT(saveFPGAXXXDay(unsigned char*)));
    connect(serialFPGA,SIGNAL(queueSizeFPGA(int)),ui->tabMainWindow,SLOT(showFPGAqueuesize(int)));
    connect(serialFPGA,SIGNAL(queueFPGASizeSIG(int)),ui->tabMainWindow,SLOT(showqueueFPGAsize(int)));
    connect(serialFPGA, &Serial::FPGABuildDat, this, [this](int buildTime){
        sysPara->status.build_dat.builTime = quint16(buildTime);
        qDebug() << "FPGA build time: " << buildTime;
    });

    serialSTM32 = new Serial("/dev/ttyAS2");
    serialSTM32->moveToThread(m_serialThreadSTM32);
    connect(serialSTM32,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendSTM32Date(int,int,unsigned char*,int,int)));
    connect(sysPara->devOp,SIGNAL(sendSerialDataToSTM32(int,int,unsigned char*,int,int)),serialSTM32,SLOT(sendSerialData(int,int,unsigned char*,int,int)));
    connect(serialSTM32,SIGNAL(getSTM32Status(unsigned char*)),this,SLOT(saveSTM32Status(unsigned char*)));
    connect(serialSTM32,SIGNAL(getGearPumpVal(unsigned char*)),this,SLOT(saveGearPumpVal(unsigned char*)));
    connect(serialSTM32,SIGNAL(getPulseCnt(unsigned char*)),this,SLOT(savePulseCntVal(unsigned char*)));
    connect(serialSTM32,SIGNAL(getSTM32Version(unsigned char*)),this,SLOT(saveSTM32Version(unsigned char*)));
    connect(serialSTM32,SIGNAL(getSTM32Time(unsigned char*)),this,SLOT(saveSTM32Time(unsigned char*)));
    connect(serialSTM32,SIGNAL(stopSendData(bool)),this,SLOT(stopSendSTM32Data(bool)));
    connect(serialSTM32,SIGNAL(powerOffReady()),ui->tabMainWindow,SLOT(powerOffConfirmed()));
    connect(m_serialThreadSTM32,&QThread::started,serialSTM32,&Serial::startInitSlot);
    connect(serialSTM32,SIGNAL(queueSizeSTM32(int)),ui->tabMainWindow,SLOT(showSTM32queuesize(int)));
    connect(serialSTM32, &Serial::STM32Connected, this, [this](bool ok, QString errStr){
        if(!ok || !sysPara || !sysPara->devOp) {
            return;
        }

        QTimer::singleShot(1000, this, [this](){
            sysPara->devOp->highVoltageCtrl(0);
            LogInfo::setRunStatusText("High voltage forced off at app boot");
        });
        
    }, Qt::QueuedConnection);

    flagOfSerialThreadStratEn = true;
}