#include "InkJetPrinter.h"
#include "ui_inkjetprinter.h"
#include "QDebug"
#include "LogInfo.h"
#include "mainwindow.h"
#include "./Network/NetworkManager.h"
#include "ZkEdit.h"
#include "myinclude.h"
//#include "PIDController/fuzzy_PID.h"
#include <QFile>
// ℃℉㎡±ΦφΩ◆✪@☢*✿❧


//#define DEBUG_CNT
#define MAX_VOL		300
#define MIN_VOL		0
void PID_init();
#define ONLYCNTCLEAR

static bool firstTime = 1;
InkJetPrinter::InkJetPrinter(QWidget *parent) :
    QTabWidget(parent),
    ui(new Ui::InkJetPrinter)
{

    system("ifconfig eth1 down");
    system("rm /usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/fonts/*.ttf > tty1");

    ui->setupUi(this);

    SysPara *para = new SysPara();

    //        t_label = new QLabel();
    //        t_label->setWindowFlags(Qt::WindowStaysOnTopHint);
    //        t_label->setGeometry(0,0,640,480);
    //        t_label->setPixmap(QPixmap(QString::fromUtf8(":/image/Turkey_logo.png")));

    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 (tcpTransceiv,SIGNAL(printer_operate_0x01()),ui->tabMainWindow,SLOT(printer_operate_launch()));//启动指令
    connect (ui->tabMainWindow,SIGNAL(printer_operate_launch_result(int)),tcpTransceiv,SLOT(printer_operate_0x01_result(int)),Qt::DirectConnection);//启动指令-回收槽就绪
    connect (tcpTransceiv,SIGNAL(printer_operate_0x02()),ui->tabMainWindow,SLOT(on_pushButtonStopPrint_pressed()));//停止指令
    connect (tcpTransceiv,SIGNAL(printer_operate_0x03(QString)),ui->tabMainWindow,SLOT(print_data_comein(QString)));//喷码指令
    connect (tcpTransceiv,SIGNAL(printer_operate_0x04()),ui->tabMainWindow,SLOT(query_print_queue()));//获取缓存指令
    connect (ui->tabMainWindow,SIGNAL(WriteInstructionCodeAck(int,QByteArray)),tcpTransceiv,SLOT(WriteInstructionCodeAck(int,QByteArray)),Qt::DirectConnection);
    connect (tcpTransceiv,SIGNAL(clear_DataCache()),ui->tabMainWindow,SLOT(clearPrintDataQueue()));//清空缓存指令
    connect (tcpTransceiv,SIGNAL(drop_NextSignal()),ui->tabMainWindow,SLOT(drop_NextSignalHandler()));//清空缓存指令

    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);
    //#ifdef __NETWORKMANAGER__
#if 1
    ui->tabNetworkManager->bindSysPara(para);
#else
    //ui->tabNetworkManager->deleteLater();
    removeTab(9);
#endif

    //以下两个信号要在(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)));
    ui->tabMainWindow->updateSysParaToUI();

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

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

    timer = new QTimer();
    connect(timer, SIGNAL(timeout()), this, SLOT(timerHandler()));
    timer->start(10);

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

    jd_timer = new QTimer();
    connect(jd_timer, SIGNAL(timeout()), this, SLOT(jd_timerHandler()));
    jd_timer->start(500);
    jd_res = 0;
    if(sysPara->para.gearPumpEnable)
    {
        pushButtonStartFlag = true;
    }
    //connect(this,SIGNAL(SpeedOver(int)),this,SLOT(OnSpeedOver(int)));

    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

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

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


    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->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()));

    sysPara->status.rWarnViscoReady=0;

#ifdef SYS_LINUX
    onAuthChanged(AUTH_NONE);
#else
    onAuthChanged(AUTH_NONE | AUTH_SUPER_USER2 |AUTH_DISPLAY_SYSTEM_SETTING| 0xffff);
#endif



    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().toAscii().constData());
        modbus = new ModbusTcp(&sysPara->modbusParas, &sysPara->modbusStatus);
        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(receivedPrintContent(int)),ui->tabMainWindow,SLOT(onModbusPrintReceivedContent(int)), 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);
#ifdef __STC_POWER__
    if(sysPara->devOp->getPowerSource() == POWER_SOURCE_TIMER)
    {
        sysPara->status.powerSource = POWER_SOURCE_TIMER;
        sysPara->status.needPowerOffTimerout = 1;
        sysPara->status.waitPowerOffTime = 18;      //运行半个钟
        LogInfo::setRunStatusText(tr("定时开机"));
        //qDebug()<<"power by:"<< sysPara->status.powerSource;
    }
    else
    {
        sysPara->status.powerSource = POWER_SOURCE_KEY;
        sysPara->status.needPowerOffTimerout = 0;
    }
    //sysPara->devOp->setWakeUpTimer(3);
    qDebug()<<"power by:"<< sysPara->status.powerSource;
#endif
    //pidControllerInit();
    PID_init();


#ifndef __DAC_ADJ_FUNCTION__
    qDebug()<<"__DAC_ADJ_FUNCTION__";
    removeTab(indexOf(ui->tabDacAdjust));
    removeTab(indexOf(ui->tabFpgaDebug));
#else

    //        qDebug()<<"!!!!!!!!!!!!!!!!!!!!deleteLater";

    removeTab(indexOf(ui->tabDacAdjust));
    removeTab(indexOf(ui->tabFpgaDebug));
    //        removeTab(indexOf(ui->tabNetworkManager));
    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()));
#endif
#ifdef __FPGA_DEBUG__
    connect(ui->fpgaWriteBytePushButton,SIGNAL(clicked()), this,SLOT( fpgaDebugWriteByte()));
    connect(ui->fpgaReadBytePushButton,SIGNAL(clicked()), this,SLOT( fpgaDebugReadByte()));

    connect(ui->fpgaWriteWordPushButton,SIGNAL(clicked()), this,SLOT( fpgaDebugWriteWord()));
    connect(ui->fpgaReadWordPushButton,SIGNAL(clicked()), this,SLOT( fpgaDebugReadWord()));

    connect(ui->fpgaWriteDWordPushButton,SIGNAL(clicked()), this,SLOT( fpgaDebugWriteDWord()));
    connect(ui->fpgaReadDWordPushButton,SIGNAL(clicked()), this,SLOT( fpgaDebugReadDWord()));
#endif
    sysPara->status.statWarn = sysPara->status.statWarn | WARN_STATUS_INK_WARN; //先置墨水标示为1
    sleep(3);
}


void InkJetPrinter::loadVoltageValue()
{
#ifdef __DAC_ADJ_FUNCTION__
    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;
    //ui->dacScaledSpinBox->setValue(sysPara->para.dacScale);
    //memcpy(sysPara->status.printed_adj_dac, sysPara->para.printed_adj_dac, sizeof(sysPara->para.printed_adj_dac));
#endif
}

float PID_realize(float speed);

#if 1
struct _pid{
    float SetSpeed;//定义设定值
    float ActualSpeed;//定义实际值
    float err;//定义偏差值
    float err_last;//定义上一个偏差值
    float Kp,Ki,Kd;//定义比例、积分、微分系数
    float voltage;//定义电压值(控制执行器的变量)
    float integral;//定义积分值
}pid;
#if 0
int main()
{
    cout<<"System begin \n";
    PID_init();
    int count=0;
    while(count<1000)
    {
        float speed=PID_realize(200.0);
        cout<<"第 "<<count<<" 次的速度为: "<<speed<<endl;
        count++;
    }
    return 0;

}
#endif

void PID_init(){
    //cout<<"PID_init begin \n";
    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;
    //cout<<"PID_init end \n";
}

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;
    }
#if 0
    if(abs(pid.err)>500)
    {
        index=0;
    }
    else
    {
        index=1;
        pid.integral+=pid.err;
    }
#endif
    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;
}
#endif

float PID_realize2(float speed, float act){
    pid.Kp = 0.08f;
    pid.Ki = 0.003f;   // 0.015 * (100ms/500ms) = 0.003，防积分饱和
    pid.Kd = 0.0f;
    pid.SetSpeed    = speed;
    pid.ActualSpeed = act;
    pid.err         = pid.SetSpeed - pid.ActualSpeed;

    // 增量式PID差分公式：Δu = Kp*(e[k]-e[k-1]) + Ki*e[k] + Kd*(e[k]-2*e[k-1]+e[k-2])
    // e[k-2] 用 voltage 字段暂存
    float delta_u = pid.Kp * (pid.err - pid.err_last)
                  + pid.Ki * pid.err
                  + pid.Kd * (pid.err - 2.0f * pid.err_last + pid.voltage);

    // 自适应步长：误差大时快速逼近，误差小时精细调节
    float absErr = (pid.err < 0) ? -pid.err : pid.err;
    float maxStep, minStep;
    if(absErr > 50.0f) {
        maxStep = 6.0f;  minStep = -10.0f;  // 大误差：快速逼近
    } else if(absErr > 20.0f) {
        maxStep = 3.0f;  minStep = -5.0f;   // 中误差：适中
    } else {
        maxStep = 1.5f;  minStep = -2.5f;   // 小误差：精细调节
    }
    if(delta_u >  maxStep) delta_u =  maxStep;
    if(delta_u <  minStep) delta_u =  minStep;

    pid.voltage  = pid.err_last;  // 暂存 e[k-2]
    pid.err_last = pid.err;
    return delta_u;
}

#if 0
struct _pid{
    float SetSpeed;            //定义设定值
    float ActualSpeed;        //定义实际值
    float err;                //定义偏差值
    float err_next;            //定义上一个偏差值
    float err_last;            //定义最上前的偏差值
    float Kp,Ki,Kd;            //定义比例、积分、微分系数
}pid;

void PID_init(){
    pid.SetSpeed=0.0;
    pid.ActualSpeed=0.0;
    pid.err=0.0;
    pid.err_last=0.0;
    pid.err_next=0.0;
    pid.Kp=0.15;
    pid.Ki=0.20;
    pid.Kd=0.25;
}

float PID_realize(float speed, float act){
    pid.SetSpeed=speed;
    pid.ActualSpeed = act;
    pid.err=pid.SetSpeed-pid.ActualSpeed;
    float incrementSpeed=pid.Kp*(pid.err-pid.err_next)+pid.Ki*pid.err+pid.Kd*(pid.err-2*pid.err_next+pid.err_last);
    pid.ActualSpeed+=incrementSpeed;
    pid.err_last=pid.err_next;
    pid.err_next=pid.err;
    return pid.ActualSpeed;
}
#endif

//#include <cmath>


void InkJetPrinter::pressureAdj(int type)
{
    if(sysPara->status.gearPumpRunStopFlag || sysPara->status.flagOfSpeedAlarm)
    {
        sysPara->para.gearPumpValue = 0;
        u              = 0.0f;
        m_rampDone     = false;
        m_adjSkip      = 0;
        m_lastAvgPressure = 0;
        m_bufValidCount = 0;
        for(int i = 0; i < 20; i++) m_pressureBuf[i] = 0;
        m_bufIdx = 0;
        sysPara->devOp->WriteMoterPump();
        return;
    }

    if(!sysPara->para.gearPumpEnable)
    {
        // 非齿轮泵模式：沿用原有位置式PID
        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;
    }

    //回收泵模式限速
    int maxValue = sysPara->para.flagOfReclaimPumEnable ? 420 : 800;
    if(maxValue < 60) maxValue = 60;

    int maxSpeed = (int)sysPara->para.gearPumpSpeedAlarm;

    int actual = sysPara->status.PRESSURE;
    int target = (int)sysPara->para.pressure;
    int cur;

    //每次进入都更新滑动平均缓冲
    m_pressureBuf[m_bufIdx] = actual;
    m_bufIdx = (m_bufIdx + 1) % 20;
    if(m_bufValidCount < 20) m_bufValidCount++;  // 累积有效点数

    // 优化：缓冲区未满时只对有效数据求平均，避免0值拉低平均值
    int avgPressure = 0;
    for(int i = 0; i < m_bufValidCount; i++) {
        avgPressure += m_pressureBuf[i];
    }
    avgPressure /= m_bufValidCount;

    //硬保护：压力超过目标+50，立即强制减速，优先级最高
    if(actual > target + 50)
    {
        float overErr = (float)(actual - (target + 50));
        float delta   = -0.1f * overErr;
        if(delta < -15.0f) delta = -15.0f;
        u += delta;
        if(u < 60.0f)           u = 60.0f;
        if(u > (float)maxValue) u = (float)maxValue;
        m_lastAvgPressure = actual;
        sysPara->para.gearPumpValue = (unsigned short)(int)u;
        sysPara->devOp->WriteMoterPump();
        return;
    }

    // 软启动：自适应步长，每 800ms 一次
    // 自检期间也走此逻辑，自检完成后重置重新收敛
    // 软启动阶段不做压力稳定检测，优先快速收敛
    if(!m_rampDone)
    {
        if(++m_adjSkip < 8)
        {
            sysPara->para.gearPumpValue = (unsigned short)(int)u;
            sysPara->devOp->WriteMoterPump();
            return;
        }
        m_adjSkip = 0;

        int err = target - actual;

        if(err < 0)
        {
            // 超压：小步减速
            u -= 1.0f;
        }
        else
        {
            // 自适应步长：差得远步子大，差得近步子小
            float step;
            if     (err > 200) step = 5.0f;
            else if(err > 100) step = 3.0f;
            else if(err > 50)  step = 2.0f;
            else               step = 1.0f;
            u += step;
        }

        if(u < 60.0f)           u = 60.0f;
        if(u > (float)maxValue) u = (float)maxValue;

        // 转速上限保护：VX4特有，防止回收泵模式下转速超标
        if(sysPara->para.flagOfReclaimPumEnable &&
           sysPara->status.gearPumpRunSpeed >= maxSpeed)
        {
            u -= 3.0f;
            if(u < 60.0f)           u = 60.0f;
            if(u > (float)maxValue) u = (float)maxValue;
        }

        cur = (int)u;

        // 进入闭环条件：压力已接近目标±30以内
        if(sysPara->status.selfCheckDone && err >= -30 && err <= 30)
        {
            m_rampDone = true;
            m_adjSkip  = 0;
        }

        sysPara->para.gearPumpValue = (unsigned short)cur;
        sysPara->devOp->WriteMoterPump();
        return;
    }

    //闭环：使用实时压力做快速小步修正，每200ms调整一次
    {
        m_adjSkip++;
        if(m_adjSkip < 2)
        {
            sysPara->para.gearPumpValue = (unsigned short)(int)u;
            sysPara->devOp->WriteMoterPump();
            return;
        }
        m_adjSkip = 0;

        float err = (float)(target - actual);
        float absErr = err;
        if(absErr < 0.0f) absErr = -absErr;

        if(absErr < 0.5f)
        {
            m_lastAvgPressure = actual;
            sysPara->para.gearPumpValue = (unsigned short)(int)u;
            sysPara->devOp->WriteMoterPump();
            return;
        }

        int pressureChange = actual - m_lastAvgPressure;
        m_lastAvgPressure = actual;

        float delta_u;
        if(absErr <= 5.0f &&
           ((err > 0.0f && pressureChange > 0) ||
            (err < 0.0f && pressureChange < 0)))
        {
            delta_u = -0.20f * (float)pressureChange;
        }
        else
        {
            delta_u = 0.05f * err - 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;

        if(sysPara->para.flagOfReclaimPumEnable &&
           sysPara->status.gearPumpRunSpeed >= maxSpeed)
        {
            if(delta_u > 0.0f) delta_u = 0.0f;
        }

        u += delta_u;
        if(u < 60.0f)           u = 60.0f;
        if(u > (float)maxValue) u = (float)maxValue;
        cur = (int)u;

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

void InkJetPrinter::DacAdjustStore()
{
#ifdef __DAC_ADJ_FUNCTION__
    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();
    //memcpy(sysPara->para.printed_adj_dac, sysPara->status.printed_adj_dac, sizeof(sysPara->para.printed_adj_dac));

    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->para.dacScale = ui->dacScaledSpinBox->value();
    sysPara->devOp->writeFpgaPrintPara();
#endif
}


InkJetPrinter::~InkJetPrinter()
{
    delete ui;
    delete timer;
#ifdef MODBUS
    if (modbus) {
        delete modbus;
    }
#endif
    if (fileTransceiv) {
        fileTransceiv->deleteLater();
    }
    //edit@01-03
    if (tcpTransceiv) {
        tcpTransceiv->deleteLater();
    }
}

void InkJetPrinter::jd_timerHandler(void)
{
    static int count_time = 0;

    count_time++;
    if(count_time>= 20){    //each 10s
        count_time = 0;
#ifdef MIMA
        jd_res = ui->tabPrintSetting->dlgInputAddr->isEnabled();
        //        qDebug()<<"jd_timerHandler";
#endif
#ifdef __RFID_CARD
        static uint lastSecondes = QDateTime::currentDateTime().toTime_t();
        static uint noticeICReaderErrorTime = QDateTime::currentDateTime().toTime_t();
        QString str = "";
        unsigned char showFlag = 0;

        if(QDateTime::currentDateTime().toTime_t() - noticeICReaderErrorTime > 1800)
        {
            noticeICReaderErrorTime = QDateTime::currentDateTime().toTime_t();
            sysPara->devOp->setICReaderModeFlag = true;
            //if(sysPara->devOp->noticeICReaderError)
            if(sysPara->devOp->queryReadRFID_address() == 2)
            {
                msgtest->setText(tr("读卡器故障!"));
                msgtest->show();
                LogInfo::setRunStatusText(tr("13.读卡器故障!"));
            }
            sysPara->devOp->setICReaderModeFlag = false;
        }
#endif
    }
}
extern void MySleep(unsigned int msec);
extern unsigned char test_flag;
bool gearPumpRunNormalFlag = false;
void InkJetPrinter::timerHandler(void){
    // QFile file("/usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/libQtssl.o");

    int pulse_100ms = 0;
    int pulse_1s = 0;
    int pulse_10s = 0;
    int pulse_100s = 0;
    int pulse_300ms = 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 char res=0;
    static int save_weeknum = 0;
    static bool gearPumpRunFlag = false;
    static bool ControledSwitchFlag = false;
    static bool gearPumpStartFlag = false;
    static bool delay3s;
    //gearPumpRunStopFlag = false;
    bool InkSwintFlag = false,lastInkSwintFlag = false;

    static float gearPumpRunNormalValue = 0.0;
#ifdef DEBUG1
    sysPara->status.selfCheckDone=1;
#endif

    if(sysPara){
#ifdef MODBUS
        //        processCommands();
#endif

#ifdef MIMA
        if(xxxm==0)
        {

#ifdef AM335TEST

#else

#ifdef MYTEST
            xxxm=1;
#else
            QFile file("/usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/libQtssl.o");
            if(!file.exists())   return;
#endif
#endif
        }
        xxxm=1;

#endif

        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;
            }
            //ui->tabSystemSetting->setSpinBoxPressureMaxValue(900);
            if(!gearPumpRunFlag)
            {
                ui->tabMainWindow->enableReclaimCtrlButton(false);
            }
        }
        else
        {
            ui->tabMainWindow->enablePushButtonStart(false);
            //ui->tabSystemSetting->setSpinBoxPressureMaxValue(5000);
        }

        /*-----------------------形成脉冲-----------------------------*/
        sysPara->status.delay10ms ++;
        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

        }
        if((sysPara->status.delay10ms%3) == 0) //读取状态后再检測
        {
            if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN) && !gearPumpRunFlag && !sysPara->status.isPumpValveControledByHand)//刚启动前3秒
            {
                if(sysPara->para.gearPumpEnable) {
                    sysPara->para.gearPumpValue = 150;
                    sysPara->devOp->WriteMoterPump();
                    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;
        }
        // 直接恢复压力控制，不走 gearPumpStartFlag 的 3s 等待
        // 平滑切换，避免手动操作后自动恢复时出现压力突变
        if(m_lastByHand && !sysPara->status.isPumpValveControledByHand)
        {
            ControledSwitchFlag = true;
            u              = (float)sysPara->para.gearPumpValue; // 同步当前转速，避免突变
            m_rampDone     = false;  // 重新软启动，适应切换后的压力状态
            m_adjSkip      = 0;
            m_lastAvgPressure = 0;
            m_bufValidCount = 0;
            for(int i = 0; i < 20; 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 count_3s = 0;
            if(u > gearPumpRunNormalValue*1.5)//改大一点
            {
                if(pulse_1s)
                {
                    count_3s++;
                    if(count_3s == 3)
                    {
                        count_3s = 0;
                        ui->tabMainWindow->setRunStatus(tr("压力泄漏或压力传感器故障!"));
                        sysPara->status.gearPumpRunStopFlag = true;
                        gearPumpRunNormalFlag = false;
                        LogInfo::setRunStatusText(tr("运行中压力泄漏，停齿轮泵!"));
                    }
                }
            }
            else
            {
                count_3s = 0;
            }
        }
        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 && sysPara->para.flagOfReclaimPumEnable)
                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 == 10){
                pulse_10s = 1;
                sysPara->status.delay1s = 0;
            }
            //if(pushButtonStartFlag)
            pulse_4s++;
            if(gearPumpStartFlag)
            {
                pulse_3s ++;
                if(pulse_3s == 3)
                {
                    pulse_3s = 0;
                    gearPumpRunFlag = true;
                    ControledSwitchFlag = true;
                }
            }
#ifdef QTV4
            if( sysPara->status.reclainTankReachEnd) sysPara->para.openInkLineTime++;
#else
            if( sysPara->status.reclainTankReachEnd) sysPara->para.openInkLineTime++;
#endif
        }
        if(pulse_10s){
#ifdef __STC_POWER__
            {
                sysPara->devOp->Heartbeat(1);
            }
#endif
            sysPara->status.delay10s ++;
            if(sysPara->status.delay10s == 10){
                pulse_100s = 1;
                sysPara->status.delay10s = 0;
#ifdef __STC_POWER__
                if(!sysPara->status.selfCheckDone){
                    qDebug()<<"gearPumpRunFlag: "<<gearPumpRunFlag;
                    qDebug()<<"gearPumpEnable: "<<sysPara->para.gearPumpEnable;
                }
//                qDebug()<<"needPowerOffTimerout: "<<sysPara->status.needPowerOffTimerout;
//                qDebug()<<"getCurrPrintStatus: "<<ui->tabMainWindow->getCurrPrintStatus();
                if(sysPara->status.needPowerOffTimerout && (ui->tabMainWindow->getCurrPrintStatus() != 1))
                {
                    qDebug()<<"waitPowerOffTime: "<<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("准备关机"));
                        }
                    }
                }
#endif
            }
#ifdef AM335TEST
            jd_res =0;
#else

#endif
        }

        /*------------------------------------------------------*/
#ifdef UART2
        static bool Flag300=0;
        if(sysPara->status.ExtScreenEn && sysPara->para.ExtScreenType)
        {

            if(sysPara->para.ExtScreenType==2)
            {
                if(pulse_300ms)
                {
                    if(Flag300)  sysPara->devOp->RecDim();
                    else    sysPara->devOp->DatToDisp2();
                    Flag300 = !Flag300;

                }
            }
            else if(pulse_1s)
            {
                if(Flag300)  sysPara->devOp->RecDim();
                else    sysPara->devOp->DatToDisp2();
                Flag300 = !Flag300;
            }
            sysPara->devOp->recUart2();
        }
#endif

        sysPara->devOp->readFgaStatus();
        sysPara->status.gearPumpRunSpeed = 0;

#if 0
        unsigned char ByteData = 0;
        static unsigned char lastByteData = 0;

        sysPara->devOp->fpgaRd(0x00fc,(unsigned char *)&ByteData,1);//读取1字节
        //ui->tabMainWindow->setRunStatus(tr("ByteData:<%1>").arg(ByteData));
        if((ByteData & 0x80) != lastByteData)
        {
            //LogInfo::setRunStatusText(tr("结果:%1").arg(ByteData & 0x80));
            lastByteData = ByteData & 0x80;
            if(sysPara->status.selfCheckDone)
            {
                if(ui->tabMainWindow->getCurrPrintStatus() == 3)
                {
                    ui->tabMainWindow->on_pushButtonStartPrint_pressed();
                }
                else
                {
                    ui->tabMainWindow->on_pushButtonStopPrint_pressed();
                }
            }
        }
#endif
        //                unsigned int  PulseMs  = 0; //时间间隔

        unsigned int PulseCnt = 0; //时间间隔内的脉冲累计数
        sysPara->devOp->fpgaRd(0x004E,(unsigned char *)&PulseCnt,2);//读取脉冲个数低字节
        {
            sysPara->status.gearPumpRunSpeed = (PulseCnt * 60 * 1000) / (500 * 2);
        }
        if(!sysPara->para.gearPumpEnable)
            sysPara->status.PRESSURE *= 5;			//响应群众号召，数值放大五倍
        sysPara->devOp->ReadSomeDataForLostPrint();
#ifdef UART1
        if(pulse_100ms){
            //static int uartReadcnt=0;
            emit sysPara->devOp->readUart1();
        }
#endif

        /*-------------------------------------------------------*/
        bool lostCommuFlag = 0;
        if(sysPara->status.configDone){
            lostCommuFlag = sysPara->status.maginNum  != FPGA_MAGIC_NUM_AFTER_CONF;
        }
        else {
            lostCommuFlag = sysPara->status.maginNum != FPAG_INIT_MAGIC_NUM;
        }
#ifdef AM335TEST
        sysPara->status.WorkTimeOut=0;
#else
#ifdef MIMAgearPumpRunFlag
        if(jd_res &(1<<2))  {
            sysPara->status.WorkTimeOut=1;
        }
#endif
#endif

#ifdef X86TEST
        lostCommuFlag=0;
#endif
#ifdef MODBUS

        if(sysPara->status.delay10ms%5 == 0)
        {
#if 1 //复位发送打印数据
            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;
                }
            }
#endif
            static  unsigned int lastProductCount=0;
            if(!sysPara->para.flagOfWeiDaLiAutoPrint){
                if(!sysPara->status.flagOfWeiDaLiTCP){
                    sysPara->devOp->fpgaRd(0x0054,&sysPara->status.flagOfWeiDaLiTCPStartPrinting,1);
                    sysPara->status.flagOfWeiDaLiTCPStartPrinting = 0;
                }
                else{
                    if(sysPara->status.flagOfWeiDaLiTCPStartPrinting == 0)
                        sysPara->devOp->fpgaRd(0x0054,&sysPara->status.flagOfWeiDaLiTCPStartPrinting,1);
                    if((sysPara->status.flagOfWeiDaLiTCPStartPrinting & 0x01) == 1){
                        sysPara->status.flagOfWeiDaLiTCPStartPrinting = 0;
                        if(!sysPara->status.flagOfDropNextSignal){
                            if(sysPara->status.flagLogInfo){
                                sysPara->status.flagLogInfo= 0;
                            }
                            if(!sysPara->status.isPrinting)
                                ui->tabMainWindow->on_pushButtonStartPrint_pressed();
                        }
                        else{
                            if(sysPara->status.flagLogInfo){
                                sysPara->status.flagLogInfo= 0;
                                qDebug()<<"丢弃废膜";
                            }
                            sysPara->status.flagOfDropNextSignal = false;
                        }
                    }
                }
            }

            if(sysPara->status.productCnt != lastProductCount || sysPara->status.printDoneFlag)
            {
                sysPara->RFIDPara.PrintInkDots += sysPara->status.TextInkDots;
                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"));
                //**********维达力TCP通信项目********
                if(sysPara->status.flagOfWeiDaLiTCP){
                    sysPara->status.flagLogInfo = 1;
                    ui->tabMainWindow->print_complete();
                    ui->tabMainWindow->on_pushButtonStopPrint_pressed();
                    if(sysPara->para.flagOfWeiDaLiAutoPrint)
                        ui->tabMainWindow->on_pushButtonStartPrint_pressed();
                }
                //********维达力TCP通信项目*******
            }
            if (modbus->getModbusStatus() == 1) {
                refreshModbusStatus();
            }
        }
#endif
        if(lostCommuFlag){
            static unsigned char lostCommuCnt=0;
            if(sysPara->status.currentRunStatus != RUN_STATUS_LOST_COMMUNICATION_WITH_FPGA) {
                // 增加FPGA通信异常判别阀值，避免产生误判。2017.8.30
                if(lostCommuCnt<10) lostCommuCnt ++;
                else {
                    sysPara->status.fpgaVersionNum = 0;
                    LogInfo::setRunStatusText(tr("与FPGA失去通信!!!"));
                    sysPara->devOp->controlCompressPump(false);
                    sysPara->devOp->controlCycleValve(false);
                    sysPara->devOp->controlInkValve(false);
                    sysPara->devOp->controlInkValvePWM(false);
                    sysPara->devOp->controlMainInkPump(false);
                    sysPara->devOp->controlMixValve(false);
                    //sysPara->devOp->controlReclaimPump(false);
                    sysPara->devOp->controlViscosityPump(false);
                    sysPara->devOp->controlReleaseValve(false);
                    sysPara->devOp->controlHeater(false);
                    qDebug()<<"lostCommuteCation now."<<sysPara->status.maginNum;
                }
            }
            sysPara->status.currentRunStatus = RUN_STATUS_LOST_COMMUNICATION_WITH_FPGA;
        }
        else if(!sysPara->status.lostCommuFlag && !SIMULATE_PRINTING_MODE) {
            if(sysPara->status.currentRunStatus == RUN_STATUS_LOST_COMMUNICATION_WITH_FPGA)
                LogInfo::setRunStatusText(tr("与FPGA通信恢复正常"));


            sysPara->status.currentRunStatus = RUN_STATUS_IDLE;
            if(gearPumpRunFlag || sysPara->para.gearPumpEnable == 0)
            {
                if(!sysPara->status.selfCheckDone)
                {		/*开机自检*/
                    autoControlValvePump();
                    pressureAdj(0);
                    /*-----------------------------------------------------*/
                    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);


#ifdef X86TEST
                        // if(sysPara->status.selfCheckCnt < MAX_SELF_CHECK_CNT-2)sysPara->status.selfCheckCnt = MAX_SELF_CHECK_CNT-2;

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

                    sysPara->status.selfCheckCnt ++;
                    if(sysPara->status.selfCheckCnt >= MAX_SELF_CHECK_CNT)
                    {
                        sysPara->status.selfCheckDone = 1;
                        // 自检完成平滑进入闭环，不强制跳转造成扰动
                        m_rampDone = true;
                        m_adjSkip  = 0;
                        // 同步 gearPumpValue 与 u，防止两者不一致
                        sysPara->para.gearPumpValue = (unsigned short)u;
                        LogInfo::setRunStatusText(tr("自检完成!!!"));
                        ui->tabMainWindow->setRunStatus(tr("自检完成!!!"));
                        qDebug()<<"自检完成!!!";
                        ui->tabPrintSetting->PrintSettingLog();
                        ui->tabMainWindow->enableReclaimCtrlButton(true);

                        // 先让软件更新泵/阀的期望状态
                        autoControlValvePump();
                        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;

                        // 仅在压力偏离目标较大时才重置软启动
                        // 避免模式抖动导致反复重新爬坡
                        int err = (int)sysPara->para.pressure - sysPara->status.PRESSURE;
                        if(err < -100 || err > 100) {
                            m_rampDone     = false;       // 误差大时重新软启动
                            m_adjSkip      = 0;
                            m_lastAvgPressure = 0;
                            m_bufValidCount = 0;
                            for(int i = 0; i < 20; i++) m_pressureBuf[i] = 0;
                            m_bufIdx = 0;
                        }
                        // 否则保持当前控制状态，只更新maxValue限制
                    }
                    // 压力调节改为100ms调用一次
                    if(pulse_100ms && sysPara->para.gearPumpEnable && !sysPara->status.isPumpValveControledByHand && ControledSwitchFlag) {
                        pressureAdj(0);
                    }
                }
            }
            else{
                static bool flag = 1;
                if(delay3s){
                    if(flag){
                        flag = 0;
                        LogInfo::setRunStatusText(tr("缺少墨水,喷码机不能正常工作!"));
                        qDebug()<<"缺少墨水,喷码机不能正常工作!";
                    }
                    ui->tabMainWindow->setRunStatus(tr("缺少墨水,喷码机不能正常工作!"));
                }
            }
            /*----------------------------控制温度--------------------------------------*/
            if(pulse_100ms){
                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);   //
        /*----------------------------------界面更新状态---------------------------------------*/
        if(pulse_300ms){
#ifdef __RFID_CARD
            if(!sysPara->devOp->setICReaderModeFlag)
            {
                sysPara->devOp->strRevdata  ="";
                sysPara->devOp->receiveReadRFID_data();
                if(sysPara->devOp->strRevdata.length() > 1)
                {
                    if((sysPara->devOp->strRevdata.left(3) == QString::number(ui->tabPrintSetting->dlgInputAddr->jd.addr).left(3))
                            ||  sysPara->devOp->strRevdata.left(3) == "100")
                    {
                        if(sysPara->devOp->strRevdata.at(3) == 'A')
                        {
                            if(!sysPara->status.flagOfNeedInkCard){
                                msgtest->setText(tr("不需要刷墨水卡!"));
                                msgtest->show();
                                ui->tabMainWindow->setRunStatus(tr("不需要刷墨水卡!"));
                                LogInfo::setRunStatusText(tr("不需要刷墨水卡!"));
                            }
                            else if(sysPara->status.statWarn & WARN_STATUS_INK_WARN){
                                msgtest->setText(tr("请先添加原厂墨水再刷墨水卡!"));
                                msgtest->show();
                                ui->tabMainWindow->setRunStatus(tr("请先添加原厂墨水再刷墨水卡!"));
                                LogInfo::setRunStatusText(tr("请先添加原厂墨水再刷墨水卡!"));
                            }
                            else if(sysPara->devOp->comWriteRFID_data() == 1)//把卡数据清零
                            {
                                sysPara->RFIDPara.InkRFIDCnt = 0;
                                sysPara->RFIDPara.PrintInkDots = 0;
                                sysPara->saveRFIDPara();
                                sysPara->para.RFIDInkWarn = false;
                                sysPara->para.inkWarnDate = 0;
                                sysPara->para.inkWarnTime = 0;
                                sysPara->status.flagOfInkMaxDot = false;
                                sysPara->status.flagOfNeedInkCard = false;
                                sysPara->devOp->checkCardIntervalTime = QDateTime::currentDateTime().toTime_t();
                                msgtest->setText(tr("刷墨水卡成功!"));
                                msgtest->show();
                                ui->tabMainWindow->setRunStatus(tr("刷墨水卡成功!"));
                                LogInfo::setRunStatusText(tr("刷墨水卡成功!"));
                            }

                        }
                        else if(sysPara->devOp->strRevdata.at(3) == 'B')
                        {
                            if(!sysPara->status.flagOfNeedSolventCard){
                                msgtest->setText(tr("不需要刷溶剂卡!"));
                                msgtest->show();
                                ui->tabMainWindow->setRunStatus(tr("不需要刷溶剂卡!"));
                                LogInfo::setRunStatusText(tr("不需要刷溶剂卡!"));
                            }
                            else if(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN){
                                msgtest->setText(tr("请先添加原厂溶剂再刷溶剂卡!"));
                                msgtest->show();
                                ui->tabMainWindow->setRunStatus(tr("请先添加原厂溶剂再刷溶剂卡!"));
                                LogInfo::setRunStatusText(tr("请先添加原厂溶剂再刷溶剂卡!"));
                            }
                            else if(sysPara->devOp->comWriteRFID_data() == 1)//把卡数据清零
                            {
                                sysPara->RFIDPara.SOLVRFIDCnt = 0;
                                sysPara->RFIDPara.solventNumber = 0;
                                sysPara->saveRFIDPara();
                                sysPara->para.RFIDSolventWarn = 0;
                                sysPara->para.solventWarnDate = 0;
                                sysPara->para.solventWarnTime = 0;
                                sysPara->para.RFIDSolventWarnMixCnt = 0;
                                sysPara->status.flagOfSolventMaxNum = false;
                                sysPara->status.flagOfNeedSolventCard = false;
                                sysPara->devOp->checkCardIntervalTime = QDateTime::currentDateTime().toTime_t();
                                msgtest->setText(tr("刷溶剂卡成功!"));
                                msgtest->show();
                                ui->tabMainWindow->setRunStatus(tr("刷溶剂卡成功!"));
                                LogInfo::setRunStatusText(tr("刷溶剂卡成功!"));
                            }
                        }
                        else
                        {
                            msgtest->setText(tr("MAC无效卡!"));
                            msgtest->show();
                            LogInfo::setRunStatusText(tr("MAC无效卡!"));
                        }
                    }
                    else
                    {
                        LogInfo::setRunStatusText(tr("card data: %1").arg(sysPara->devOp->strRevdata));
                        QString str1 = QString::number(sysPara->devOp->strRevdata.mid(0,2).toInt(0,16)).rightJustified(2,'0');
                        QString str2 =QString::number(sysPara->devOp->strRevdata.mid(2,2).toInt(0,16)).rightJustified(2,'0');
                        QString str3 = QString::number(sysPara->devOp->strRevdata.mid(4,2).toInt(0,16)).rightJustified(2,'0');
                        QString str4 = QString::number(sysPara->devOp->strRevdata.mid(6,2).toInt(0,16)).rightJustified(2,'0');
                        QString str5 = QString::number(sysPara->devOp->strRevdata.mid(8,2).toInt(0,16)).rightJustified(2,'0');
                        QString str6 =QString::number( sysPara->devOp->strRevdata.mid(10,2).toInt(0,16)).rightJustified(2,'0');
                        QString strDateTime = str1 + "-" + str2 + "-" + str3 + " " + str4 + ":" + str5 + ":" + str6;
                        QString strShow = tr("无效卡,这张卡已经在%1时使用过").arg(strDateTime);
                        msgtest->setText(strShow);
                        msgtest->show();
                        LogInfo::setRunStatusText(strShow);
                    }
                }
            }
#endif
            sysPara->devOp->readCalandarDat();			//务必读一下此数据
#ifdef RANDDEBUG
            if(sysPara->status.RandomNum>0)
                sysPara->devOp->Read_RanddomFromFpga();
#endif
#ifdef COUNTER1_BY_GROUP /* 分段计米 */
            cnt1GroupCheck();//分段计米
#endif
            QWidget *widget = this->currentWidget();
            //无墨水或溶剂3小时，自动关机
            if(sysPara->status.InkOrSOLVEmptyCnt>MAX_INK_SOLV_EMTYTIME-10)
            {
                if(!sysPara->status.powerOffAfterInkOrSOLVEmptyAppending){
                    sysPara->status.powerOffAfterInkOrSOLVEmptyAppending = 1;
                    ui->tabMainWindow->_on_pushButtonPowerOff_pressed(false);
                    LogInfo::setRunStatusText(tr("墨水或溶剂空，准备关机"));
                    ui->tabMainWindow->setRunStatus(tr("墨水或溶剂空，准备关机"));
                }
            }

            static bool read_flag =  false;
            if(widget == ui->tabMainWindow) {
                ui->tabMainWindow->updateSysStatusToUI();
            }
            else if(widget == ui->tabTriggerMode){
                ui->tabTriggerMode->updateSysStatusToUI();
                if(sysPara->status.build_dat.builTime ==0)  sysPara->devOp->readbuilDat();
                else
                {
                    QString strFPGADate;
                    if(sysPara->status.build_dat.year!=0xff && sysPara->status.build_dat.month!=0xff && sysPara->status.build_dat.day!=0xff)
                    {
                        strFPGADate = QString("(%1-%2-%3)").arg(sysPara->status.build_dat.year).arg(sysPara->status.build_dat.month).arg(sysPara->status.build_dat.day);
                    }
                    if(sysPara->status.flagOfNo67FPGA && sysPara->para.flagOfFastMode)
                        ui->tabTriggerMode->setBuildTime(QString(" No66") + "_" + strFPGADate);
                    else if(sysPara->status.flagOfNo67FPGA && !sysPara->para.flagOfFastMode)
                        ui->tabTriggerMode->setBuildTime(QString(" No67") + "_" +strFPGADate);
                     else
                        ui->tabTriggerMode->setBuildTime(QString(" No%1").arg(sysPara->status.build_dat.builTime) + "_"+ strFPGADate);
                }
            }
            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){
            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->para.RFIDSolventWarn && 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){
                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();
                    }
                }
                else{
                    LogInfo::setRunStatusText(tr("detect Ink warning cnt: %1").arg(warnNum1));
                    qDebug()<<"检测到墨水液位次数:"<<warnNum1;
                }
            }
            else
                warnNum1 = 0;

            if(sysPara->RFIDPara.PrintInkDots >= MAX_INK_DOTS || sysPara->para.RFIDInkWarn){
                if(logFlag4 && sysPara->para.RFIDInkWarn){
                    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;
                }
                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 % 60 == 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("打印墨点已达到2.3billion,请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
                        msgtest->show();
                        LogInfo::setRunStatusText(tr("打印墨点已达到2.3billion,请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
                        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 % 60 == 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("请添加原厂溶剂,然后刷溶剂卡,否则将会在打开10次混合阀之后禁用喷码机!"));
                        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();
                        }
                    }
                    else{
                        LogInfo::setRunStatusText(tr("detect solvent warning cnt: %1").arg(warnNum2));
                        qDebug()<<"检测到溶剂液位次数:"<<warnNum2;
                    }
                }
                else{
                    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("溶剂液位报警后已经打开混合阀10次,请刷卡以恢复机器的正常功能"));
                    if(logFlag3){
                        logFlag3 = false;
                        msgtest->setText(tr("溶剂液位报警后已经打开混合阀10次,请刷卡以恢复机器的正常功能!"));
                        msgtest->show();
                        LogInfo::setRunStatusText(tr("溶剂液位报警后已经打开混合阀10次,请刷卡以恢复机器的正常功能"));
                        qDebug()<<"溶剂液位报警后已经打开混合阀10次,请刷卡以恢复机器的正常功能";
                    }
                }
                else{
                    ui->tabMainWindow->setRunStatus(tr("已经打开混合阀360次,请刷卡以恢复机器的正常功能"));
                    if(logFlag3){
                        logFlag3 = false;
                        msgtest->setText(tr("已经打开混合阀360次,请刷卡以恢复机器的正常功能!"));
                        msgtest->show();
                        LogInfo::setRunStatusText(tr("已经打开混合阀360次,请刷卡以恢复机器的正常功能"));
                        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){
            if((!sysPara->para.flagOfReclaimPumEnable && sysPara->status.gearPumpRunSpeed <= 2000)
                    ||(sysPara->para.flagOfReclaimPumEnable && sysPara->status.gearPumpRunSpeed <= sysPara->para.gearPumpSpeedAlarm))
            {
                pulse_30s = 0;
            }
            else{
                pulse_30s++;
                if(pulse_30s >= 5){
                    if((sysPara->status.gearPumpRunSpeed >= 3000)||(sysPara->devOp->color_flag == 2)
                            ||(sysPara->para.flagOfReclaimPumEnable && sysPara->status.gearPumpRunSpeed > sysPara->para.gearPumpSpeedAlarm))
                    {
                        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();
                    }
                    else{
                        sysPara->devOp->color_flag = 1;
                        if(pulse_30s % 500 == 0){
                            LogInfo::setRunStatusText(tr("齿轮泵转速过高，请清理过滤器或者检查是否泄露!"));
                            qDebug()<<"齿轮泵转速过高，请清理过滤器或者检查是否泄露!";
                        }
                        ui->tabMainWindow->setRunStatus(tr("齿轮泵转速过高，请清理过滤器或者检查是否泄露!"));
                        sysPara->devOp->controlYellowLight(true);
                    }
                }
                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(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 == MAX_HEATER_TIME){
            LogInfo::setRunStatusText(tr("警告:加热器长时间无法达到预期温度，故障或设置错误！"));
            ui->tabMainWindow->setRunStatus("加热器长时间无法达到预期温度，故障或设置错误！");//20150105 no check
            sysPara->devOp->controlHeater(false);
        }
    }
    else {
        if(sysPara->status.heaterONTimeCnt < MAX_HEATER_TIME)
        {
            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::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()){
            //                    sysPara->devOp->controlInkValve(enableFlag);		//供墨阀
            //                    if(enableFlag == false){		//关闭
            //                            sysPara->status.cycleValveOpenCntAfterSWintOff = MAX_CYCLEVALVE_OPEN_TIME_AFTER_SWITN_OFF;
            //                    }
            //            }

            if(enableFlag != sysPara->devOp->isInkValveOpen()){
                if(enableFlag == false) {		//关闭供墨阀的顺序 先开循环阀后关闭供墨阀
                    //#ifdef __AIR_RELEASE_OLD__ // 旧管路关闭墨线后 开粘度泵和循环阀一段时间
                    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
                    //                    // 新管路直接关闭墨线
                    //                    sysPara->devOp->controlInkValve(enableFlag);		//关供墨
                    //#endif
                }
                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 || (sysPara->status.needPowerOffTimerout && sysPara->para.gearPumpEnable)){
                //				if(!sysPara->devOp->isCycleValveOpen()){			//循环阀    //定时开机循环时隔膜泵不开关循环阀
                //					sysPara->devOp->controlCycleValve(true);
                //				}
                cycleValveRunForSelfCheck();
                if(sysPara->status.needPowerOffTimerout)
                {
                    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);
                }
            }

            /*----------------------------------泄压阀-------------------------------------------*/
            //=====================================================================================================
            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);

                    }
                }
            }

            /*----------------------------------混合阀-------------------------------------------*/

            /*备忘内容：主板的型号与软件版本
            `define JETV3     // EP4F15 V3板子
            `define JETV32    // EP3C10 V4板子
            `define JETV23    // V23板子 EP3C25
            */

            /*-----------------------------------主墨泵------------------------------------------*/
            if(PRODUCT_VERSION(sysPara->status.fpgaVersionNum) == JETV3 || PRODUCT_VERSION(sysPara->status.fpgaVersionNum) >= JETV23 ){
                //20170830修改主板硬件版本号，以便与主板硬件版本编号对应, V7主板编号为7
                if(sysPara->status.warm_InkPump){
                    if(!sysPara->status.lastwarmInkPump){
                        if(!sysPara->para.gearPumpEnable)
                        {
                            LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!主墨泵故障"));
                            ui->tabMainWindow->setRunStatus(tr("主墨泵故障!!!"));
                            sysPara->status.lastwarmInkPump = 1;
                        }
                    }
                }
            }
            else
            {
                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;
                        /*备忘内容：主板的型号与软件版本
                        `define JETV3     // EP4F15 V3板子
                        `define JETV32    // EP3C10 V4板子
                        `define JETV23    // V23板子 EP3C25
                        */
                        /*-----------------------------------老管路的溶剂随主墨泵一起动作---------------------------*/
                        if(sysPara->status.selfCheckDone && !sysPara->para.mixValveisNewVersion && PRODUCT_VERSION(sysPara->status.fpgaVersionNum) == JETV1){
                            if(sysPara->devOp->isMixValveOpen())
                                checkMixValveClose();
                            else
                                checkMixValveOpen();
                        }
                        /*--------------------------------------------------------------------------------------*/
                    }
                    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打开一次粘度泵以及相关处理--------------------------------------*/
            else {
                //    static int viscosity_flag = 0;
                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);
                        sysPara->RFIDPara.solventNumber++;
                        if(sysPara->para.RFIDSolventWarn){
                            sysPara->para.RFIDSolventWarnMixCnt++;
                            LogInfo::setRunStatusText(tr("RFIDSolventWarnMixCnt = %1").arg(sysPara->para.RFIDSolventWarnMixCnt));
                            qDebug()<<"RFIDSolventWarnMixCnt ="<<sysPara->para.RFIDSolventWarnMixCnt;
                        }
                        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(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.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("电机故障!!!"));
            sysPara->devOp->controlReclaimTankOpen(false);
            ui->tabMainWindow->resetReclaimCtrlButtonText();
            emit reclaimTankBlock();
        }

    }
    else  if(sysPara->status.reclaimTankstatus == 5 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        sysPara->devOp->controlReclaimTankOpen(false);		//到头，关闭
        sysPara->status.reclainTankReachEnd = true;
        /*应要求去掉多余到信息 LogInfo::setRunStatusText(tr("回收槽到头"));*/
        ui->tabMainWindow->setRunStatus(tr("回收槽到头"));
        ui->tabMainWindow->enablePrintButton(true);			//仅仅在此时能使能打印按钮
        ui->tabMainWindow->resetReclaimCtrlButtonText();
        emit reclaimTankOpenDone();
        /*回收槽开关时间校正*/
        sysPara->para.reclaimTankTime =( sysPara->status.currReclaimTankPos>120 )? sysPara->status.currReclaimTankPos/10-1:12;
        ui->tabSystemSetting->updateReclaimTime( sysPara->para.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-无操作
    {
        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; //下次开回收槽就执行排气程序
        //emit reclaimTankBlock();
    }
    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)
{
#ifdef SYS_LINUX
    event->ignore();
#else
    exit(1);
#endif
}
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();

}
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.toAscii().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()
{
    jd_timer->stop();
    timer->stop();
}

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

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

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

void InkJetPrinter::fpgaDebugWriteByte()
{
#ifdef __FPGA_DEBUG__
    if(sysPara == NULL) {
        return;
    }
    int fpgaAddr = ui->fpgaByteAddrSpinBox->value();
    unsigned char fpgaValue = ui->fpgaByteValueSpinBox->value();
    sysPara->devOp->fpgaWr(fpgaAddr, &fpgaValue, 1);
#endif
}

void InkJetPrinter::fpgaDebugReadByte()
{
#ifdef __FPGA_DEBUG__
    if(sysPara == NULL) {
        return;
    }
    int fpgaAddr = ui->fpgaByteAddrSpinBox->value();
    unsigned char fpgaValue;
    sysPara->devOp->fpgaRd(fpgaAddr, &fpgaValue, 1);
    ui->fpgaByteValueSpinBox->setValue(fpgaValue);

#endif
}

void InkJetPrinter::fpgaDebugWriteWord()
{
#ifdef __FPGA_DEBUG__
    if(sysPara == NULL) {
        return;
    }
    int fpgaAddr = ui->fpgaWordAddrSpinBox->value();
    unsigned int fpgaValue = ui->fpgaWorldValueSpinBox->value();
    unsigned char buff[2];
    buff[0] = fpgaValue & 0xFF;
    buff[1] = (fpgaValue >> 8) & 0xFF;
    sysPara->devOp->fpgaWr(fpgaAddr, buff, 2);
#endif
}

void InkJetPrinter::fpgaDebugReadWord()
{
#ifdef __FPGA_DEBUG__
    if(sysPara == NULL) {
        return;
    }
    int fpgaAddr = ui->fpgaWordAddrSpinBox->value();
    unsigned int fpgaValue;
    unsigned char buff[2];
    sysPara->devOp->fpgaRd(fpgaAddr, buff, 2);
    fpgaValue = buff[1]<<8|buff[0];
    ui->fpgaWorldValueSpinBox->setValue(fpgaValue);
#endif
}

void InkJetPrinter::fpgaDebugWriteDWord()
{
#ifdef __FPGA_DEBUG__
    if(sysPara == NULL) {
        return;
    }
    int fpgaAddr = ui->fpgaDWordAddrSpinBox->value();
    unsigned int fpgaValueH = ui->fpgaDWorldValueHSpinBox->value();
    unsigned int fpgaValueL = ui->fpgaDWorldValueLSpinBox->value();
    unsigned char buff[4];
    buff[0] = fpgaValueL & 0xFF;
    buff[1] = (fpgaValueL >> 8) & 0xFF;
    buff[2] = fpgaValueH & 0xFF;
    buff[3] = (fpgaValueH >> 8) & 0xFF;
    sysPara->devOp->fpgaWr(fpgaAddr, buff, 4);
#endif
}

void InkJetPrinter::fpgaDebugReadDWord()
{
#ifdef __FPGA_DEBUG__
    if(sysPara == NULL) {
        return;
    }
    int fpgaAddr = ui->fpgaDWordAddrSpinBox->value();
    unsigned char buff[4];
    sysPara->devOp->fpgaRd(fpgaAddr, buff, 4);
    unsigned int fpgaValueL = buff[1]<<8|buff[0];
    unsigned int fpgaValueH = buff[3]<<8|buff[2];
    ui->fpgaDWorldValueHSpinBox->setValue(fpgaValueH);
    ui->fpgaDWorldValueLSpinBox->setValue(fpgaValueL);
#endif
}

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);
}


static int lowSpeedCnt = 0;
static int highSpeedCnt = 0;
static int lowPressureCnt = 0;
static int highPressureCnt = 0;
static unsigned int logCnt = 0;
float rateOld = 1.0;
#define Min_Speed 100
#define lowSpeed_ToleranceTime 10
#define highSpeed_ToleranceTime 10
#define lowPressure_ToleranceTime 20
#define highPressure_ToleranceTime 10
void InkJetPrinter::checkPressureControl(){ //1s
    logCnt++;
    unsigned int targetP = sysPara->para.pressure;
    unsigned int actualP = sysPara->status.PRESSURE;
    unsigned short actualS = sysPara->status.gearPumpRunSpeed;
    float rate = (float)actualP/targetP;
   // if(logCnt % 30 == 0)
        //LogInfo::setRunStatusText(tr("pressureRate = %1").arg(rate));
    if(!sysPara->para.gearPumpEnable || !sysPara->para.flagOfReclaimPumEnable)
        return;
    if(rate >=0.9 && rate <=1.1 && actualS >= Min_Speed && actualS <= sysPara->para.gearPumpSpeedAlarm){
        lowSpeedCnt = 0;
        highSpeedCnt = 0;
        lowPressureCnt = 0;
        highPressureCnt = 0;
        return;
    }
    /*************非手动状态下进行检查开始************************/
    if(!sysPara->status.isPumpValveControledByHand){
        if(actualS < Min_Speed){
            lowSpeedCnt++;
            highSpeedCnt = 0;
        }
        else if(actualS <= sysPara->para.gearPumpSpeedAlarm){
            lowSpeedCnt = 0;
            highSpeedCnt = 0;
        }
        else{
            lowSpeedCnt = 0;
            highSpeedCnt++;
        }

        if(rate < 0.8){
            lowPressureCnt++;
            highPressureCnt = 0;
            if(lowPressureCnt == 1)
                rateOld = rate;
            else if(lowPressureCnt == 10){
                if((rate - rateOld) < 0.1 && highSpeedCnt > 0){
                    QString str = "高转速下压力提升缓慢,请检查管路是否堵塞或者压力传感器是否正常";
                    showMessage(str);
                    sysPara->para.gearPumpValue = 0;
                    sysPara->devOp->WriteMoterPump();
                    sysPara->status.flagOfPressureFault = true;
                }
            }
        }
        else if(rate <= 1.2){
            lowPressureCnt = 0;
            highPressureCnt = 0;
        }
        else{
            lowPressureCnt = 0;
            highPressureCnt++;
        }
    }
    /****************非手动状态下进行检查结束***************************/

    if(lowPressureCnt == 0) rateOld = 1.0;

    if(lowSpeedCnt >= lowSpeed_ToleranceTime){
        if(lowPressureCnt >= lowPressure_ToleranceTime){
//            QString str = "转速过低,压力值过低,请检查电路,或者压力传感器是否正常";
//            showMessage(str);
        }
        else if(highPressureCnt >= highPressure_ToleranceTime){
            QString str = "转速过低,压力值过高,请检查压力传感器是否正常";
            showMessage(str);
        }
        else{
        }
    }
    else if(highSpeedCnt >= highSpeed_ToleranceTime){
        if(lowPressureCnt >= lowPressure_ToleranceTime){
            QString str = "转速过高,压力偏低,请检查管路是否堵塞";
            showMessage(str);
            sysPara->para.gearPumpValue = 0;
            sysPara->devOp->WriteMoterPump();
            sysPara->status.isPumpValveControledByHand = true;
            sysPara->devOp->mainInkCtrl();
            sysPara->status.flagOfPressureFault = true;
        }
        else if(highPressureCnt >= highPressure_ToleranceTime){
            QString str = "转速过高,压力过高,请检查压力传感器是否正常";
            showMessage(str);
            sysPara->para.gearPumpValue = 0;
            sysPara->devOp->WriteMoterPump();
            sysPara->status.isPumpValveControledByHand = true;
            sysPara->devOp->mainInkCtrl();
            sysPara->status.flagOfPressureFault = true;
        }
        else{
            QString str = "转速过高,请检查管路是否堵塞";
            showMessage(str);
            sysPara->para.gearPumpValue = 0;
            sysPara->devOp->WriteMoterPump();
            sysPara->status.isPumpValveControledByHand = true;
            sysPara->devOp->mainInkCtrl();
            sysPara->status.flagOfPressureFault = true;
        }
    }
    else{

    }
}

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

void InkJetPrinter::resetPressureCnt(){
    lowSpeedCnt = 0;
    highSpeedCnt = 0;
    lowPressureCnt = 0;
    highPressureCnt = 0;
}

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