#include "InkJetPrinter.h"

#include <QDebug>
//#include <QTextCursor>
#include <QElapsedTimer>
#include "VerBVersion.h"
#include <QEvent>

#ifdef __RFID_CARD
#define DETECT_WARNING_TIME 10 //Seconds
#define RFID_WARNING_INTERVAL 5 //Minutes
#endif

#pragma execution_character_set("utf-8")

extern MyInputMethod *myInputMethod;
extern unsigned char vartypeR;
static unsigned int PulseCnt = 0; //时间间隔内的脉冲累计数
InkJetPrinter::InkJetPrinter(QWidget* parent)
    : QWidget(parent)
{
    // 加载.ui文件生成的UI界面
    ui.setupUi(this);

    // 关联原有成员变量到UI控件（保持变量名和原代码一致）
    m_LabelTimer = ui.m_LabelTimer;
    m_StackedWidget = ui.m_StackedWidget;
    
    // 初始化业务逻辑（仅保留原init中的非UI创建部分）
    init();
    initRunTimeCtrl();
#ifdef __RFID_CARD
    initRFIDManager();
#endif

    QThread::sleep(3);
    qApp->installEventFilter(this);

    QString ARM_Version;
    ARM_Version.sprintf("%d.%d.%02d%s%s", UP_PRINTER_MAJOR_VER, UP_PRINTER_MINOR_VER,UP_PRINTER_RIVISION_VER,SUB_VERSION,SUB_RFID);
    ui.label_version->setText(QString("A%1/F%2.%3.%4").arg(ARM_Version).arg(sysPara->status.fpgaVersionNum >> 12)
                                        .arg((sysPara->status.fpgaVersionNum>>8) & 0x0f).arg(sysPara->status.fpgaVersionNum&0xff) );


#ifdef ARCH_X86
    setFixedSize(800, 600);
#endif
}

InkJetPrinter::~InkJetPrinter()
{
    if(m_serialThreadFPGA->isRunning()){
        m_serialThreadFPGA->requestInterruption();
        m_serialThreadFPGA->quit();
        m_serialThreadFPGA->wait();
    }
    if(m_serialThreadSTM32->isRunning()){
        m_serialThreadSTM32->requestInterruption();
        m_serialThreadSTM32->quit();
        m_serialThreadSTM32->wait();
    }
    if(serialFPGA){
        delete serialFPGA;
        serialFPGA = nullptr;
    }
    if(serialSTM32){
        delete serialSTM32;
        serialSTM32 = nullptr;
    }
}

void InkJetPrinter::init()
{    
    // 创建自定义子控件（原逻辑不变）
    m_MainWidget = new MainWidget(this);
    m_TestPrintWidget = new TestPrintWidget(this);
//    m_ErCodeSettingsWidget = new ErCodeSettingsWidget(this);
//    m_MainInterfaceWidget = new MainInterfaceWidget(this);

    m_FontSetWidget = new FontSetWidget(this);
    m_PrintSetting = new PrintSetting(this);

    m_BarCodeDlg = new QBarCode(this);
    m_QRCodeDlg = new dlgQrCode(this);

    m_MainInstruction = new MainInstruction(this);
    m_SystemManage = new SystemManage(this);
    m_SystemUpdate = new SystemUpdate(this);
    m_SystemSetting = new SystemSetting(this);
    m_OtherInfo = new OtherInfo(this);
    m_LogInfo = new LogInfo(this);
    m_scheduleShiftsEditor = new ScheduleShiftsEditor(this);
    m_DateVarSet = new DateVarSet(this);
    m_CounterVarSet = new CounterVarSet(this);

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

    msgtest = new QMessageBox(this);
    msgtest->setWindowTitle(tr("提示"));
    connect(msgtest, SIGNAL(finished(int)), this, SLOT(OnFinished(int)));

    // 我真的不想拉，但是今天状态燃尽了，以后再改了
    m_TestPrintWidget->setPrintSettingWidget(m_PrintSetting);

    // 信号槽连接（原逻辑完全不变）
    connect(m_MainWidget, &MainWidget::sendButtonClickedSignal, this, &InkJetPrinter::getMainWidgetButtonClickedSlot);
    connect(m_MainWidget,SIGNAL(setDisableAll()),this,SLOT(disableTabClick()));
    connect (m_MainWidget,SIGNAL(CloseJd()),this,SLOT(close_jd_timer()));
    connect(m_MainWidget, &MainWidget::newFileAcquired, this, &InkJetPrinter::createNewJobFile);
    connect(m_TestPrintWidget, &TestPrintWidget::sendButtonClickedSignal, this, &InkJetPrinter::getTestPrintWidgetButtonClickedSlot);

    // TestPrintWidget::sendButtonClickedSignal(16) 转由 openDatetimeEditor 处理
    connect(m_TestPrintWidget, &TestPrintWidget::sig_showEditDateTime, this, &InkJetPrinter::openDatetimeEditor);

    // 班时元素与编辑 连接
    connect(m_TestPrintWidget, &TestPrintWidget::sig_showScheduleShiftsEditor, this, &InkJetPrinter::showScheduleShiftsEditor);
    connect(m_scheduleShiftsEditor, &ScheduleShiftsEditor::accepted, this, &InkJetPrinter::onScheduleShiftsEditDone);
    connect(m_scheduleShiftsEditor, &ScheduleShiftsEditor::rejected, [this](){
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
    });

//    connect(m_ErCodeSettingsWidget, &ErCodeSettingsWidget::sendButtonClickedSignal, this, &InkJetPrinter::getErCodeSettingsWidgetButtonClickedSlot);
//    connect(m_MainInterfaceWidget, &MainInterfaceWidget::sendButtonClickedSignal, this, &InkJetPrinter::getErCodeSettingsWidgetButtonClickedSlot);
    connect(m_MainWidget,&MainWidget::showVserionInfo,this,&InkJetPrinter::setShowVserionInfo);

    connect(m_FontSetWidget,&FontSetWidget::sendButtonClickedSignal,this,&InkJetPrinter::getFontSetWidgetButtonClickedSlot);
    connect(m_PrintSetting,&PrintSetting::sendButtonClickedSignal,this,&InkJetPrinter::getPrintSettingButtonClickedSlot);
    connect(m_MainInstruction,&MainInstruction::sendButtonClickedSignal,this,&InkJetPrinter::getMainInstructWidgetButtonClickedSlot);
    connect(m_SystemManage,&SystemManage::sendButtonClickedSignal,this,&InkJetPrinter::getSystemManageWidgetButtonClickSlot);
    connect(m_SystemSetting,&SystemSetting::sendButtonClickedSignal,this,&InkJetPrinter::getSystemSettingWidgetButtonClickSlot);
    connect(m_OtherInfo,&OtherInfo::sendButtonClickedSignal,this,&InkJetPrinter::getOtherInfoWidgetButtonClickSlot);
    connect(m_LogInfo,&LogInfo::sendButtonClickedSignal,this,&InkJetPrinter::getLogInfoWidgetButtonClickSlot);

    connect(m_DateVarSet,&DateVarSet::sendButtonClickedSignal,this,&InkJetPrinter::getDateSetWidgetButtonClickSlot);
    //添加计数器，修改计数器
    connect(m_CounterVarSet,&CounterVarSet::sendButtonClickedSignal,this,&InkJetPrinter::getCounterVarSetWidgetButtonClickSlot);
    connect(m_CounterVarSet,&CounterVarSet::sig_updateSelectedCounter,this,&InkJetPrinter::slt_counterVarUpdate);
    
    connect(m_MainInstruction,&MainInstruction::newFileBtnClick,m_TestPrintWidget,&TestPrintWidget::on_newfileButton_pressed);

//    connect(myInputMethod,&MyInputMethod::sendEnterClickedSignal,&TestPrintWidget::onEditItemDone);
    connect(myInputMethod,SIGNAL(sendEnterClickedSignal()),m_TestPrintWidget,SLOT(onEditItemDone()));
    connect(m_DateVarSet,SIGNAL(backSpaceBtn()),myInputMethod,SLOT(backSapceButtonDel()));
    connect(m_TestPrintWidget,SIGNAL(sendUpdateFontSignl(int)),m_FontSetWidget,SLOT(updateFontSelect(int)));

    connect (m_MainWidget,SIGNAL(repeatInitedPid()),this,SLOT(handleInitedPID()));
    connect(m_MainWidget,SIGNAL(clearPressureFault()),this,SLOT(resetPressureCnt()));
    connect(m_LogInfo,SIGNAL(faultTesumePress()),m_MainWidget,SLOT(onLabelFaultRusumePressed()));

    // 信号槽：用于修改计数器
    connect(m_TestPrintWidget, &TestPrintWidget::sig_showEditCounter,
            this, &InkJetPrinter::slt_editCounter);

    // 状态界面
    if (ctrl_loginfo == nullptr) ctrl_loginfo = LogInfoCtrl::instance();
    connect(ctrl_loginfo, &LogInfoCtrl::sig_show, this, [=](){
        getMainWidgetButtonClickedSlot(5);
        m_LogInfo->checkState();
    });

    SysPara *para = new SysPara();
    sysPara = para;
    m_MainWidget->bindSysPara(para);
    m_FontSetWidget->bindSysPara(para);
    m_PrintSetting->bindSysPara(para);
    m_SystemManage->bindSysPara(para);
    m_SystemSetting->bindSysPara(para);
    m_OtherInfo->bindSysPara(para);
    m_TestPrintWidget->bindSysPara(para);
    m_DateVarSet->bindSysPara(para);
    m_CounterVarSet->bindSysPara(para);
    m_MainInstruction->bindSysPara(para);
    m_BarCodeDlg->bindSysPara(para);
    m_QRCodeDlg->bindSysPara(para);
    m_LogInfo->bindSysPara(para);

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

    m_PrintSetting->updateModelToUI();
    m_SystemSetting->updateSysParaToUI();
    m_OtherInfo->updateSysParaToUI();
    m_CounterVarSet->updateSysParaToUI();

    m_SystemManage->loadKeyBoardType();

    m_MainWidget->bindTxTEdit(m_TestPrintWidget->getQTextEdit());
    m_MainWidget->bindPicScene(m_TestPrintWidget->getPicScene());
    m_FontSetWidget->bindTxTEdit(m_TestPrintWidget->getQTextEdit());
    m_CounterVarSet->bindTxTEdit(m_TestPrintWidget->getQTextEdit());
    m_BarCodeDlg->bindTxTEdit(m_TestPrintWidget->getQTextEdit());
    m_QRCodeDlg->bindTxTEdit(m_TestPrintWidget->getQTextEdit());
    m_textEdit = m_TestPrintWidget->getQTextEdit();

    // 添加子控件到StackedWidget（原逻辑不变）
    m_StackedWidget->addWidget(m_MainWidget);
    m_StackedWidget->addWidget(m_TestPrintWidget);
//    m_StackedWidget->addWidget(m_ErCodeSettingsWidget);
//    m_StackedWidget->addWidget(m_MainInterfaceWidget);

    m_StackedWidget->addWidget(m_FontSetWidget);
    m_StackedWidget->addWidget(m_BarCodeDlg);
    m_StackedWidget->addWidget(m_QRCodeDlg);

    m_StackedWidget->addWidget(m_PrintSetting);
    m_StackedWidget->addWidget(m_MainInstruction);
    m_StackedWidget->addWidget(m_SystemManage);
    m_StackedWidget->addWidget(m_SystemUpdate);
    m_StackedWidget->addWidget(m_SystemSetting);
    m_StackedWidget->addWidget(m_OtherInfo);
    m_StackedWidget->addWidget(m_LogInfo);
    m_StackedWidget->addWidget(m_scheduleShiftsEditor);
    m_StackedWidget->addWidget(m_DateVarSet);
    m_StackedWidget->addWidget(m_CounterVarSet);

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

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

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

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

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

    serialSTM32->moveToThread(m_serialThreadSTM32);
    connect(serialSTM32,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendSTM32Date(int,int,unsigned char*,int,int)));
    connect(sysPara->devOp,SIGNAL(sendSerialDataToSTM32(int,int,unsigned char*,int,int)),serialSTM32,SLOT(sendSerialData(int,int,unsigned char*,int,int)));
    connect(serialSTM32,SIGNAL(getSTM32Status(unsigned char*)),this,SLOT(saveSTM32Status(unsigned char*)));
    connect(serialSTM32,SIGNAL(getGearPumpVal(unsigned char*)),this,SLOT(saveGearPumpVal(unsigned char*)));
    connect(serialSTM32,SIGNAL(getPulseCnt(unsigned char*)),this,SLOT(savePulseCntVal(unsigned char*)));
    connect(serialSTM32,SIGNAL(getSTM32Version(unsigned char*)),this,SLOT(saveSTM32Version(unsigned char*)));
    connect(serialSTM32,SIGNAL(getSTM32Time(unsigned char*)),this,SLOT(saveSTM32Time(unsigned char*)));
    connect(serialSTM32,SIGNAL(stopSendData(bool)),this,SLOT(stopSendSTM32Data(bool)));
    connect(serialSTM32,SIGNAL(powerOffReady()),m_MainWidget,SLOT(powerOffConfirmed()));
    
    connect(serialSTM32,SIGNAL(queueSizeSTM32(int)),this,SLOT(showSTM32queuesize(int)));
    connect(serialSTM32, &Serial::STM32Connected, this, [this](bool ok, QString errorMsg){
        if(ok){
            LogInfo::setRunStatusText("Connected to STM32 serial port");
        }
        else{
            LogInfo::setRunStatusText("STM32 serial port connection failed: " + errorMsg);
        }
    });

    connect(m_SystemManage,SIGNAL(sigToCloseSerialFPGA()),this,SLOT(closeSerialFPGA()));
    connect(m_SystemManage,SIGNAL(sigToCloseSerialSTM32()),this,SLOT(closeSerialSTM32()));
    connect(m_SystemManage,SIGNAL(restartSerial()),this,SLOT(restartSerialPort()));
    connect(m_SystemManage, &SystemManage::rebootAppAcquired, this, &InkJetPrinter::rebootApp);
    flagOfSerialThreadStratEn = true;

    connect(m_SystemManage,SIGNAL(enableClick(bool)),this,SLOT(enableInkJetTabClick(bool)));
    connect(m_SystemManage,SIGNAL(upgradeSTM32(QString)),serialSTM32,SLOT(upgradeSTM32File(QString)));
    connect(serialSTM32,SIGNAL(progress(int,int)),m_SystemManage,SLOT(progressBarControl(int,int)));

    /*系统更新*/
    connect(m_MainInstruction,&MainInstruction::sendButtonClickedSignal,this,&InkJetPrinter::getMainInstructWidgetButtonClickedSlot);

    /*系统更新的信号和槽*/
    connect(m_SystemUpdate,&SystemUpdate::sendProgramSTM32Signal,m_SystemManage,&SystemManage::on_pushButtonProgamSTM32_clicked);
    connect(m_SystemUpdate,&SystemUpdate::sendProgramFPGASignal,m_SystemManage,&SystemManage::on_pushButtonProgamFPGA_clicked);
    connect(m_SystemUpdate,&SystemUpdate::sendUpDateSOFTSignal,m_SystemManage,&SystemManage::on_pushButtonUpdateSoftware_pressed);
    connect(m_SystemUpdate,&SystemUpdate::sendUpDateChARLIBSignal,m_SystemManage,&SystemManage::on_pushButtonUpdateCharLib_pressed);
    connect(m_SystemUpdate,&SystemUpdate::sendButtonClickedSignal,this,&InkJetPrinter::getSystemManageWidgetButtonClickSlot);

    
    // 原注释的默认页面设置（按需启用）

    sysPara->status.machineMac = m_MainInstruction->dlgInputAddr->jd.addr;
    sysPara->para.rfidCountDown = 5;

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

// type 1,2: 分别显示计数器1或2的界面
void InkJetPrinter::slt_editCounter(CounterViewModel vm)
{
    if (m_CounterVarSet) {
        m_CounterVarSet->updateSysParaToUI();
        m_CounterVarSet->setCounterConfig(vm);
        m_StackedWidget->setCurrentWidget(m_CounterVarSet);
    }
}

void InkJetPrinter::slt_warningMaintenance()
{
    // 新逻辑的时间跨度更短，优先判断
    if (timeoutDay >= 30) {
        double runHours = sysPara->RFIDPara.runTime / 60.0 / 60.0;
        double hours = sysPara->RFIDPara.maintenanceHours - runHours;
        QString str;
        if (hours >= 0) {
            str = tr("保养期还有%1小时到期,请及时保养,否则喷码机容易损坏")
                    .arg(QString::number(hours, 'f', 2));
        } else {
            hours = hours * (-1);
            str = tr("保养期已超过%1小时,请及时保养,否则喷码机容易损坏")
                    .arg(QString::number(hours, 'f', 2));
        }
        msgtest->setText(str);
        msgtest->show();
//        m_MainWidget->setRunStatus(str);
        LogInfo::setRunStatusText(str);
        return;
    } else {
        warningHandler(3);
        return;
    }

}

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

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

float PID_realize(float speed);

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


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

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

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

float PID_realize2(float speed, float act){
    pid.Kp = 0.8;
    pid.Ki = 0.02;
    pid.Kd = 0.5;
    pid.integral_max = 12000;
    pid.SetSpeed=speed;
    pid.ActualSpeed = act;
    pid.err=pid.SetSpeed-pid.ActualSpeed;

    float Pout = pid.Kp * pid.err;
    pid.integral += pid.err;
    if (pid.integral > pid.integral_max) {
            pid.integral = pid.integral_max;
        } else if (pid.integral < -pid.integral_max) {
            pid.integral = -pid.integral_max;
        }
    float Iout = pid.Ki * pid.integral;
    float Dout = pid.Kd * ((pid.err + pid.err_last)/2 - pid.err_last);

    pid.voltage = Pout + Iout + Dout;
    pid.err_last=pid.err;
    return pid.voltage;
}

void InkJetPrinter::pressureAdj()
{
    //float u, actual;
    signed short delta_u;
    signed short old = (signed short)sysPara->para.gearPumpValue;
    static unsigned int oldPressure = 0;
    static qint32 printOut = 0;
    if(printOut++%2 !=0) {
        return;
    }
    static qint32 dbgCnt = 0;
    if(++dbgCnt % 50 == 0){
        // qDebug()<<"[pressureAdj] pressure="<<sysPara->para.pressure
        //         <<" PRESSURE="<<sysPara->status.PRESSURE
        //         <<" gearPumpValue="<<sysPara->para.gearPumpValue
        //         <<" u="<<u
        //         <<" flagOfReclaimPumEnable="<<sysPara->para.flagOfReclaimPumEnable
        //         <<" gearPumpSpeedAlarm="<<sysPara->para.gearPumpSpeedAlarm
        //         <<" gearPumpRunStopFlag="<<sysPara->status.gearPumpRunStopFlag
        //         <<" flagOfSpeedAlarm="<<sysPara->status.flagOfSpeedAlarm;
    }

    if(!sysPara->status.gearPumpRunStopFlag)
    {
        if(sysPara->para.gearPumpEnable && sysPara->para.flagOfReclaimPumEnable)


            u=PID_realize2((float)sysPara->para.pressure,(float)sysPara->status.PRESSURE);

        else if(u > 0 || ((sysPara->para.pressure - sysPara->status.PRESSURE) > 0) )
        {
            //
            u=PID_realize((float)sysPara->para.pressure,(float)sysPara->status.PRESSURE);
        }
    }

    if(u > 0)
    {
        sysPara->para.gearPumpValue = (unsigned short)u;
    }
    else
    {
        sysPara->para.gearPumpValue = 0;
    }
    if(sysPara->para.gearPumpValue>800) {
        sysPara->para.gearPumpValue = 800;
    }
    /*********************改回收泵后压力调整*********************************/
    if(sysPara->para.gearPumpValue && sysPara->para.flagOfReclaimPumEnable){
        int maxValue;
        if(sysPara->para.gearPumpSpeedAlarm <= 1200){
            maxValue = 200 + (sysPara->para.pressure - 500)*0.1;
            if(maxValue > 260) maxValue = 260;
        }else{
            maxValue = 350 + (sysPara->para.pressure - 500)*0.1;
            if(maxValue > 420) maxValue = 420;
        }

        if(sysPara->para.gearPumpValue < 60)
            sysPara->para.gearPumpValue = 75;
        else if(sysPara->para.gearPumpValue > maxValue)
            sysPara->para.gearPumpValue = maxValue;
    }
    /************************************************************/

    if(sysPara->status.gearPumpRunStopFlag)
    {
        sysPara->para.gearPumpValue = 0;
    }
    if(sysPara->status.flagOfSpeedAlarm)
        sysPara->para.gearPumpValue = 0;
    sysPara->devOp->WriteMoterPump();
    oldPressure = sysPara->status.PRESSURE;
}


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

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

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

    static int tempFlag=0;
    static int save_weeknum = 0;
    static bool gearPumpRunFlag = false;
    static bool ControledSwitchFlag = false;
    static bool gearPumpStartFlag = false;
    static bool delay3s;
    bool InkSwintFlag = false,lastInkSwintFlag = false;
    static float gearPumpRunNormalValue = 0.0;
    if(sysPara){
        ui.label_queue->setText(tr("%1/%2/%3").arg(sysPara->status.sizeFPGA).arg(sysPara->status.sizequeueFPGA).arg(sysPara->status.sizeSTM32));
        ui.m_LabelTimer->setText(QDateTime::currentDateTime().toString("yyyy-MM-dd  hh:mm:ss"));
        ui.label_pressure->setText(QString("%1/%2").arg(sysPara->status.PRESSURE).arg(sysPara->para.pressure));
        ui.label_speed->setText(QString("%1").arg(sysPara->status.gearPumpRunSpeed));
        xxxm=1;
        if(sysPara->para.flagOfModuleDecimal || sysPara->para.flagOfModuleHide){
            sysPara->para.flagOfModuleDecimal = 0;
            sysPara->para.flagOfModuleHide = 0;
        }

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

        if(sysPara->para.gearPumpEnable)
        {
//            m_MainWidget->enablePushButtonStart(true);
            if(!pushButtonStartFlag)
            {
                gearPumpRunNormalFlag = false;
            }
            if(!gearPumpRunFlag)
            {
                m_MainWidget->enableReclaimCtrlButton(false);
            }
        }
        else
        {
//            ui->tabMainWindow->enablePushButtonStart(false);
        }

        /*-----------------------形成脉冲-----------------------------*/
        sysPara->status.delay10ms ++;
        if(sysPara->status.delay10ms == 2){
            pulse_20ms = 1;
        }
        if(sysPara->status.delay10ms == 5){
            pulse_50ms = 1;
        }
        if(sysPara->status.delay10ms == 10){
            pulse_100ms = 1;
            sysPara->status.delay10ms = 0;
        }
        if(pulse_100ms){
            sysPara->status.delay100ms ++;
            if(sysPara->status.delay100ms == 10){
                pulse_1s = 1;
                sysPara->status.delay100ms = 0;
            }
            pulse_300ms = (sysPara->status.delay100ms%3) == 0;		//1秒3次，并非精确的300ms
            pulse_200ms = (sysPara->status.delay100ms%2) == 0;
        }
        if(pulse_300ms) tempFlag=1;
        if((sysPara->status.delay10ms%3) == 0) //读取状态后再检測
        {
            if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN) && !gearPumpRunFlag && !sysPara->status.isPumpValveControledByHand)//刚启动前3秒
            {
                if(sysPara->para.gearPumpEnable) {
                    sysPara->para.gearPumpValue = 150;
                    if(tempFlag){
                        sysPara->devOp->WriteMoterPump();
                        tempFlag=0;
                    }
                    gearPumpStartFlag = true;
                }
            }
        }

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

                    pulse_5s++;
                }
                if( pulse_5s == 5)
                {
                    pulse_5s = 0;
                    gearPumpRunNormalFlag = true;
                    gearPumpRunNormalValue = u;
                }
            }
        }
        if(sysPara->status.isPumpValveControledByHand)
        {
            gearPumpRunNormalFlag = false;
            ControledSwitchFlag = false;
            pulse_3s = 0;
        }
        if(!(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(m_MainWidget->getCurrPrintStatus() != 1){
                    m_MainWidget->_on_pushButtonPowerOff_pressed(false);
                    LogInfo::setRunStatusText(tr("测试时间结束，准备关机"));
                }
            }
            if(sysPara->status.selfCheckDone && sysPara->para.Reciclar  && test_flag){
                reciclar_30s++;
                if(reciclar_30s > 30){
                    reciclar_30s = 0;
                    test_flag++;
                }
            }
            else if(reciclar_30s){
                reciclar_30s = 0;
            }
            QDate d = QDate::currentDate();

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

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

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

            pulse_4s++;
            if(gearPumpStartFlag)
            {
                pulse_3s ++;
                if(pulse_3s == 3)
                {
                    pulse_3s = 0;
                    gearPumpRunFlag = true;
                    ControledSwitchFlag = true;
                }
            }
            if( sysPara->status.reclainTankReachEnd) sysPara->para.openInkLineTime++;
            // byons: 改到往下一百行左右的位置了 byons@2026年4月11日
            // 用于刷新时间类型    byons@2026年4月10日
            // 现在只用于更新界面，给人看的，因此理论延迟1秒左右，实际受系统用量影响可能会更慢
            // if(m_StackedWidget->currentWidget() == m_MainWidget) 
            //     m_MainWidget->onPreviewScene();

            // end by byons@2026年4月10日
        }

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

        if(pulse_10s){
            sysPara->status.delay10s ++;
            if(sysPara->status.delay10s == 10){
                pulse_100s = 1;
                sysPara->status.delay10s = 0;
            }
        }

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

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

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

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

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

        if(sysPara->status.delay10ms%5 == 0)
        {//复位发送打印数据
            if((m_MainWidget->getCurrPrintStatus() == 1)&&sysPara->para.ResetSendData)
            {
                static bool oneTimeFlag = false;
                if(sysPara->status.productCnt== 0 && (oneTimeFlag==false))//计米复位发送打印数据
                {
                    oneTimeFlag = true;
                    m_MainWidget->on_m_StartBtn_clicked();
                    //复位重设起始值
                    if(sysPara->para.cnt1ResetToInitValue)
                    {
                        sysPara->para.cnt1CurrValue = sysPara->para.cnt1StartValue;
                        sysPara->status.cnt1CurrentValueInitDoneFlag = false;
                        sysPara->devOp->writeFpgaCalandar(0);
                    }
                }
                if(sysPara->status.productCnt != 0)
                {
                    oneTimeFlag = false;
                }
            }
            static  unsigned int lastProductCount=0;
            if(sysPara->status.productCnt != lastProductCount || sysPara->status.printDoneFlag)
            {
                sysPara->status.printDoneFlag = false;
                lastProductCount = sysPara->status.productCnt;

                if(vartypeR != 0){     //更新替换变量的值
//                    LogInfo::setRunStatusText("vartypeR");
                    MySleep(100);
                    m_MainWidget->onPreviewScene();
                    m_MainWidget->SendPrintDataToFpga(0);
                }

                sysPara->modbusStatus.printFinishFlag = 1;
                memcpy((void*)(&sysPara->modbusStatus.orderCode), (void*)(&sysPara->modbusParas.QRcode_buf), 2);//写返回序列号
//                ui->tabMainWindow->UpdateDateTimeQRCode(QDateTime::currentDateTime().toString("hh:mm"));
            }

            // byons: 时间类型图元更新 @2026年4月11日
            if (m_MainWidget->dateTimeItemsDotUpdate()) {
                // // 统计追踪更新频率
                // static QElapsedTimer bnsTimer;
                // static int toogleCount = 0;
                // ++toogleCount;
                // if(toogleCount > 10) {
                //     auto elapsed = bnsTimer.restart();
                //     qDebug() << (QString("timeHandler avg elapsed: %1 s").arg(elapsed / qreal(toogleCount) / 1000.0));
                //     toogleCount = 0;
                // }

                if(sysPara->status.isPrinting) {
                    m_MainWidget->SendPrintDataToFpga(0, true);
                }

                if(m_StackedWidget->currentWidget() == m_MainWidget) {
                    m_MainWidget->updatePrintDisplayLabel();
                }
            }

//            if (modbus->getModbusStatus() == 1) {
//                refreshModbusStatus();
//            }
        }

            if(gearPumpRunFlag || sysPara->para.gearPumpEnable == 0)
            {
                if(!sysPara->status.selfCheckDone && sysPara->status.isPrinting){
                    sysPara->status.selfCheckDone = true;
                    m_MainWidget->updatePrintDisplayLabel();
//                    sysPara->status.flagOfAbnormalStatus = true;
                    qDebug()<<"打印过程中死机了!!!";
                }
                if(!sysPara->status.selfCheckDone)
                {
                    /*开机自检*/
                    autoControlValvePump();
                      if(pulse_100ms){
                        pressureAdj();
                      }
                    /*-----------------------------------------------------*/
                    if(!sysPara->status.selfCheckCnt) {
                        LogInfo::setRunStatusText(tr("开始自检,请等待60秒..."));
                        m_MainWidget->enableReclaimCtrlButton(false);
                        m_MainWidget->enablePrintButton(false);
                        sysPara->devOp->mainInkCtrl();
                        sysPara->para.TrunOnPowerCnt++;// 20151218 开机次数加1
                        sysPara->saveParaToFile();     // 保存开机次数值

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

                       m_MainWidget->updateTotalCnt(0);


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

                    if(sysPara->status.selfCheckCnt >= MAX_SELF_CHECK_CNT)
                    {
                        sysPara->status.selfCheckDone = 1;
                        LogInfo::setRunStatusText(tr("自检完成!!!"));
                        m_MainWidget->setRunStatus(tr("自检完成!!!"));
                        qDebug()<<"自检完成!!!";
                        m_MainWidget->enableReclaimCtrlButton(true);
                        sysPara->devOp->mainInkCtrl();
                        sysPara->status.canRunAirPushing = true;

                        // 自检结束发送打印设置
                        qInfo() << "Self check done and send print para to FPGA";
                        sysPara->devOp->setHighVoltageAmplitudetoSTM32();
                        sysPara->devOp->writeFpgaCalandar(0);
                        sysPara->devOp->writeFpgaPrintPara();

                        if(sysPara->para.Reciclar)
                            test_flag = 1;
                    }
                    else {
                        if((sysPara->status.selfCheckCnt % 200) == 0)
                            m_MainWidget->enableReclaimCtrlButton(false);
                    }

                }
                else{
                    // 开机自检完成的前提下
                    if (!sysPara->status.airPushing || m_MainWidget->m_2sFlag) {
                        autoControlValvePump();
                    }
                    static qint32 adjDbgCnt = 0;
                    if(pulse_100ms && ++adjDbgCnt % 50 == 0){

                        // 调整压力算法时用这个追踪
                        // qDebug()<<"[adjCond] gearPumpEnable="<<sysPara->para.gearPumpEnable
                        //         <<" isPumpValveControledByHand="<<sysPara->status.isPumpValveControledByHand
                        //         <<" ControledSwitchFlag="<<ControledSwitchFlag
                        //         <<" gearPumpRunFlag="<<gearPumpRunFlag
                        //         <<" gearPumpStartFlag="<<gearPumpStartFlag;
                    }
                    if(pulse_100ms && sysPara->para.gearPumpEnable && !sysPara->status.isPumpValveControledByHand && ControledSwitchFlag ) {
                        pressureAdj();
                    }
                }
            }
            else{
                static bool flag = 1;
                if(delay3s){
                    if(flag){
                        flag = 0;
//                        LogInfo::setRunStatusText(tr("缺少墨水,喷码机不能正常工作!"));
                        qDebug()<<"缺少墨水,喷码机不能正常工作!";
                    }
//                    ui->tabMainWindow->setRunStatus(tr("缺少墨水,喷码机不能正常工作!"));
                }
            }
            /*----------------------------控制温度--------------------------------------*/
            if(pulse_300ms){
                autoControlHeater();
                sysPara->devOp->readSyncCounterAtZero();
            }

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

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

#endif
            if(pulse_300ms){
            sysPara->devOp->readCalandarDat();			//务必读一下此数据
            if(sysPara->status.RandomNum>0)
                sysPara->devOp->Read_RanddomFromFpga();
#ifdef COUNTER1_BY_GROUP /* 分段计米 */
//            cnt1GroupCheck();//分段计米
#endif
            //reserved
            QWidget *widget = m_StackedWidget->currentWidget();
            static bool read_flag =  false;    
            if((widget == m_MainWidget || widget == m_LogInfo) && pulse_100ms) {
                m_MainWidget->updateSysStatusToUI();
                m_MainWidget->updateGeneralState(m_MainWidget->alarmStatus);
                m_LogInfo->updateSysStatusToUI(m_MainWidget->alarmStatus);
            }
            /*
            else if(widget == ui->tabTriggerMode){
                ui->tabTriggerMode->updateSysStatusToUI();

                if(sysPara->status.fpgaVersionNum != 0){
                    QString FpgaVersion;
                    if((sysPara->status.fpgaVersionNum>>12) == 8 || (sysPara->status.fpgaVersionNum>>12) == 6)
                        FpgaVersion = "72";
                    else if((sysPara->status.fpgaVersionNum>>12) == 2 || (sysPara->status.fpgaVersionNum>>12) == 1){
                        if(sysPara->para.flagOfFastMode)
                            FpgaVersion = "66";
                        else
                            FpgaVersion = "67";
                    }
                    FpgaVersion +=  QString("_F%1.%2.%3").arg(sysPara->status.fpgaVersionNum >> 12)
                            .arg((sysPara->status.fpgaVersionNum>>8) & 0x0f).arg(sysPara->status.fpgaVersionNum&0xff);
                     ui->tabTriggerMode->setBuildTime(QString(" No%1").arg(FpgaVersion));
              }

            }
            */
            else if(widget == m_PrintSetting)
            {
                m_PrintSetting->updateSysStatusToUI();
//                if(!read_flag)
//                {
//                    emit sendPicScene(ui->tabMainWindow->getPicScene());
//                }
                read_flag = true;
            }
            else if(widget == m_SystemSetting){

                m_SystemSetting->updateSysStatusToUI();
            }
            else if(widget == m_SystemManage){
                m_SystemManage->updateSysStatusToUI();
            }
            else if(widget == m_OtherInfo){
                m_OtherInfo->updateSysStatusToUI();
            }
//            else if(widget == ui->tabNetworkManager){
//                if(!sysPara->status.bLanConfigManual)
//                {
//                    ui->tabNetworkManager->updateSysStatusToUI();
//                }
//            }
            if(widget  !=  m_PrintSetting)
            {
                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) {
//                        m_MainWidget->on_pushButtonPausePrint_pressed();// 2014-03-19
//                        ui->tabMainWindow->setRunStatus(tr("喷印速度过快！无法喷印完全，自动暂停喷印!!!"));

                    }
                    else {
//                        ui->tabMainWindow->setRunStatus(tr("喷印速度过快！无法喷印完全!!!"));
                    }

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

            if(last_lesslen_warn) last_lesslen_warn--;

        }

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

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

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

#ifdef __RFID_CARD
            // hlp 0513 :甲方要求提示越来越频繁
            if(sysPara->status.needMaintenanceRemind){
//                warningHandler(3);
            }
            static bool logFlagCard1 = 1;
            if(!sysPara->para.flagOfInkWarning){
                if(sysPara->status.statWarn & WARN_STATUS_INK_WARN)
                    sysPara->status.inkWarningCnt++;
                if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN))
                    sysPara->status.inkWarningCnt = 0;
                if(sysPara->status.inkWarningCnt >= DETECT_WARNING_TIME){
                    sysPara->para.flagOfInkWarning = true;
                    QDateTime curDateTime = QDateTime::currentDateTime();
                    QString strCurDateTime = curDateTime.toString("yyMMddhhmmss");
                    LogInfo::setRunStatusText("Ink warning.");
                    qDebug()<<"墨水液位报警";
                    if(sysPara->para.inkWarnDate == 0){
                        sysPara->para.inkWarnDate = strCurDateTime.mid(0,6).toInt();
                        sysPara->para.inkWarnTime = strCurDateTime.mid(6,6).toInt();
                    }
                    sysPara->saveParaToFile();
                }
            }
            else{
                if(logFlagCard1){
                    logFlagCard1 = 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;
                }
            }

            static bool logFlag2 = 1;
            if(!sysPara->para.flagOfSolventWarning){
                if(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN)
                    sysPara->status.solventWarningCnt++;
                if(!(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN))
                    sysPara->status.solventWarningCnt = 0;
                if(sysPara->status.solventWarningCnt >= DETECT_WARNING_TIME){
                    sysPara->para.flagOfSolventWarning = true;
                    QDateTime curDateTime = QDateTime::currentDateTime();
                    QString strCurDateTime = curDateTime.toString("yyMMddhhmmss");
                    LogInfo::setRunStatusText("Solvent warning.");
                    qDebug()<<"溶剂液位报警";
                    if(sysPara->para.solventWarnDate == 0){
                        sysPara->para.solventWarnDate = strCurDateTime.mid(0,6).toInt();
                        sysPara->para.solventWarnTime = strCurDateTime.mid(6,6).toInt();
                    }
                    sysPara->saveParaToFile();
                }
            }
            else{
                if(logFlag2){
                    logFlag2 = 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.flagOfInkWarning){
                if(!sysPara->RFIDPara.needInkCard){
                    QDateTime curDateTime = QDateTime::currentDateTime();
                    QByteArray curDateTimestr = curDateTime.toString("yyyy-MM-dd HH::mm::ss").toUtf8();
                    QFile file("/home/plg/inkRFIDTime.txt");
                    if(!file.open(QIODevice::WriteOnly)){
                        qDebug()<<"Open inkRFIDTime Failure.";
                        LogInfo::setRunStatusText("Open inkRFIDTime Failure.");
                    }
                    int ret = file.write(curDateTimestr);
                    if(ret <= 0){
                        qDebug()<<"Write inkRFIDTime Failure.";
                        LogInfo::setRunStatusText("Write inkRFIDTime Failure.");
                    }
                    file.close();

                    sysPara->RFIDPara.needInkCard = true;
                    sysPara->saveRFIDPara();
                }
                warningHandler(1);
            }
            if(sysPara->para.flagOfSolventWarning){
                if(!sysPara->RFIDPara.needSolventCard){
                    QDateTime curDateTime = QDateTime::currentDateTime();
                    QByteArray curDateTimestr = curDateTime.toString("yyyy-MM-dd HH::mm::ss").toUtf8();
                    QFile file("/home/plg/solventRFIDTime.txt");
                    if(!file.open(QIODevice::WriteOnly)){
                        qDebug()<<"Open solventRFIDTime Failure.";
                        LogInfo::setRunStatusText("Open solventRFIDTime Failure.");
                    }
                    int ret = file.write(curDateTimestr);
                    if(ret <= 0){
                        qDebug()<<"Write solventRFIDTime Failure.";
                        LogInfo::setRunStatusText("Write solventRFIDTime Failure.");
                    }
                    file.close();

                    sysPara->RFIDPara.needSolventCard = true;
                    sysPara->saveRFIDPara();
                }
                warningHandler(2);
            }
#endif

            static bool resumeFlag = false;
            if(lostCommuFlag  || m_MainWidget->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)
            {
                sysPara->status.beeperOnFlag = true;
                if(sysPara->status.gearPumpRunStopFlag && pushButtonStartFlag)
                {
                    m_MainWidget->setRunStatus(tr("压力泄漏或压力传感器故障!"));
                }
                if(!resumeFlag)
                {
                    resumeFlag = true;
                    pulse_4s = 0;
                    if(!sysPara->status.lastHighVoltageFault)
                    {
                        m_MainWidget->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);
                    m_MainWidget->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 >= 30){
                    if((sysPara->status.gearPumpRunSpeed >= 2500)||(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)
                            m_MainWidget->on_m_StopBtn_clicked();
                    }
                    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::getTestPrintWidgetButtonClickedSlot(int index)
{
    switch (index)
    {
    case 201:
    {
        m_StackedWidget->setCurrentWidget(m_BarCodeDlg);
        break;
    }
    case 202:
    {
        m_StackedWidget->setCurrentWidget(m_QRCodeDlg);
        break;
    }

    case 9:
    {
        m_PrintSetting->updateModelToUI();
        m_StackedWidget->setCurrentWidget(m_PrintSetting);
        break;
    }
    case 10:
    {
        m_StackedWidget->setCurrentWidget(m_FontSetWidget);
        break;
    }
    case 16:
    {
        // 已经转由 @see InkJetPrinter::openDatetimeEditor 处理
        break;
    }
    case 5:
    {
        // m_StackedWidget->setCurrentWidget(m_CounterVarSet);
        // 转由 @see InkJetPrinter::slt_editCounter 处理
        break;
    }
    case 20:
    {
        m_StackedWidget->setCurrentWidget(m_MainWidget);
         MySleep(200);
//        m_MainWidget->PreviewPressed();
         m_MainWidget->onPreviewScene();
        break;
    }

    // 哪个天才写的？ 有什么用？
    case 21:
    {
          // 没用的切换，不讲逻辑的嘛？
          // m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
          break;
    }
    default:
        break;
    }
}

void InkJetPrinter::openDatetimeEditor(DateItemModel dateModel, TextItemModel textItemModel)
{
    m_DateVarSet->initUI();
    m_DateVarSet->initReplaceValue();

    m_DateVarSet->setTextItemModel(textItemModel);
    m_DateVarSet->setDateModel(dateModel);

    m_StackedWidget->setCurrentWidget(m_DateVarSet);
}

void InkJetPrinter::getFontSetWidgetButtonClickedSlot(int index)
{
    switch (index)
    {
    case 1:
    {
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
        break;
    }
    default:
        break;
    }
}

void InkJetPrinter::getMainWidgetButtonClickedSlot(int index)
{
    switch (index)
    {
    case 1:
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
        break;
    case 2:
//        m_StackedWidget->setCurrentWidget(m_MainInterfaceWidget);
        m_TestPrintWidget->on_openfileButton_pressed();
        break;
    case 3:
        close();
        break;
    case 4:
        m_StackedWidget->setCurrentWidget(m_MainInstruction);
        break;
    case 5:
        m_StackedWidget->setCurrentWidget(m_LogInfo);
        break;
    default:
        break;
    }
}

void InkJetPrinter::getPrintSettingButtonClickedSlot(int index){
    switch (index)
    {
    case 1:
    case 2:
    {
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
        break;
    }
    default:
        break;
    }
}

void InkJetPrinter::getMainInstructWidgetButtonClickedSlot(int index)
{
    switch (index)
    {
    case 1:
    {
        m_StackedWidget->setCurrentWidget(m_MainWidget);
        break;
    }
    case 2:
    {
        m_StackedWidget->setCurrentWidget(m_SystemManage);
        break;
    }
    case 3:
    {
        m_StackedWidget->setCurrentWidget(m_SystemSetting);
        break;
    }
    case 4:
    {
        m_StackedWidget->setCurrentWidget(m_OtherInfo);
        break;
    }
    case 5:
    {
        m_StackedWidget->setCurrentWidget(m_SystemUpdate);
    }
    default:
        break;
    }
}

void InkJetPrinter::getSystemManageWidgetButtonClickSlot(int index){
    switch (index)
    {
    case 1:
    {
        m_StackedWidget->setCurrentWidget(m_MainInstruction);
        break;
    }
    default:
        break;
    }
}

void InkJetPrinter::getSystemUpdateWidgetButtonClickSlot(int index){
    switch (index)
    {
    case 1:
    {
        m_StackedWidget->setCurrentWidget(m_MainInstruction);
        break;
    }
        break;

    default:
        break;
    }
}

void InkJetPrinter::getSystemSettingWidgetButtonClickSlot(int index){
    switch (index)
    {
    case 1:
    case 2:
    {
        m_StackedWidget->setCurrentWidget(m_MainInstruction);
        break;
    }
    default:
        break;
    }
}

void InkJetPrinter::getOtherInfoWidgetButtonClickSlot(int index){
    switch (index)
    {
    case 1:
    case 2:
    {
        m_StackedWidget->setCurrentWidget(m_MainInstruction);
        break;
    }
    default:
        break;
    }
}

void InkJetPrinter::getLogInfoWidgetButtonClickSlot(int index){
    switch (index)
    {
    case 1:
    case 2:
    case 3:
    case 4:
    {
        m_StackedWidget->setCurrentWidget(m_MainWidget);
        break;
    }
    default:
        break;
    }
}

void InkJetPrinter::getDateSetWidgetButtonClickSlot(int index){
    switch (index)
    {
    case 1:
    {
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
        // m_TestPrintWidget->onEditItemVarDone();
        DateItemModel model  = m_DateVarSet->dateModel();
        const auto textModel = m_DateVarSet->textItemModeL();
        qInfo() << "A new datetime pattern: " << model.datetimePattern;
        qInfo() << "Text model: " << TextItemModel::toString(textModel);
        m_TestPrintWidget->addDateTimeItem(model, textModel);
        break;
    }
    case 2:
    {
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
        break;
    }
    case 3:
    {
        break;
    }
    default:
        break;
    }

}

void InkJetPrinter::getCounterVarSetWidgetButtonClickSlot(int index){
    switch (index)
    {
    case 1:
    {
        CounterViewModel vm = m_CounterVarSet->getCounterConfig();
        m_TestPrintWidget->addCounterItem(vm);
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
        break;
    }
    case 2:
    {
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
        break;
    }
    case 3:
    {
        break;
    }
    default:
        break;
    }
}

void InkJetPrinter::slt_counterVarUpdate()
{
    // m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
}

void InkJetPrinter::showScheduleShiftsEditor(QVector<ScheduleModel> schedules, TextItemModel txtModel)
{
    m_StackedWidget->setCurrentWidget(m_scheduleShiftsEditor);
    m_scheduleShiftsEditor->setItemModel(schedules, txtModel);
}

void InkJetPrinter::onScheduleShiftsEditDone()
{
    m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
    m_TestPrintWidget->addScheduleShiftsItem(m_scheduleShiftsEditor->scheduleModel(), m_scheduleShiftsEditor->textItemModel());
}

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

//    if(sysPara->status.flagOfKeyBoardType)
//         return QTabWidget::eventFilter(watched,event);
//qDebug()<<"eventFilter";
    QSpinBox *qsb=dynamic_cast<QSpinBox*>(watched);
    QLineEdit *qle=dynamic_cast<QLineEdit*>(watched);
    QTextEdit *qte=dynamic_cast<QTextEdit*>(watched);
    QWidget *widget = qobject_cast<QWidget *>(watched);
    switch (event->type()){
    case QEvent::FocusIn:
        if(qsb&&!qsb->isReadOnly()||qle&&!qle->isReadOnly()||qte&&!qte->isReadOnly() && watched->objectName() != "inputPreviewBox")
            myInputMethod->updateHandler(1);
        break;
    case QEvent::FocusOut:
        if(watched->objectName() != "inputPreviewBox")
            myInputMethod->updateHandler(2);
        break;
    case QEvent::MouseButtonPress:
        if(widget && !qsb && !qle && !qte && !myInputMethod->shouldIgnoreHideForWidget(widget))
            myInputMethod->clearCurrentFocusAndHide();
        break;
    }

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

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

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

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

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

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

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

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


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



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



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

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


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

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

void InkJetPrinter::saveSTM32Version(unsigned char *data){
    qDebug()<<"saveSTM32Version";
    static unsigned char STM32Verion[3] = {0}; //时间间隔内的脉冲累计数
    unsigned char *target= ((unsigned char *)&sysPara->status.stm32Verion);
    for(int i=0;i<data[3];i++){
        target[i]=data[4+i];
    }

    QString STM32Ver = QString("%1.%2.%3").arg((sysPara->status.stm32Verion>>16)&0xFF)
            .arg((sysPara->status.stm32Verion>>8) & 0xFF).arg(sysPara->status.stm32Verion&0xFF);
    qDebug()<<"STM32Ver:"<<STM32Ver;

    LogInfo::setRunStatusText(QString("STM32Ver: %1").arg(STM32Ver));
}

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

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

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

}


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


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

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

    if(serialFPGA){
        delete serialFPGA;
        serialFPGA = nullptr;
    }
}

void InkJetPrinter::closeSerialSTM32(){
    
    if(m_serialThreadSTM32->isRunning()){

        LogInfo::setRunStatusText("Closing STM32 serial port and exit thread...");

        m_serialThreadSTM32->requestInterruption();
        m_serialThreadSTM32->quit();
        m_serialThreadSTM32->wait();
    }
    if(serialSTM32){
        delete serialSTM32;
        serialSTM32 = nullptr;
    }
}

void InkJetPrinter::restartSerialPort(){

    closeSerialFPGA();
    closeSerialSTM32();

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

    serialSTM32 = new Serial("/dev/ttyAS2");
    serialSTM32->moveToThread(m_serialThreadSTM32);
    connect(serialSTM32,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendSTM32Date(int,int,unsigned char*,int,int)));
    connect(sysPara->devOp,SIGNAL(sendSerialDataToSTM32(int,int,unsigned char*,int,int)),serialSTM32,SLOT(sendSerialData(int,int,unsigned char*,int,int)));
    connect(serialSTM32,SIGNAL(getSTM32Status(unsigned char*)),this,SLOT(saveSTM32Status(unsigned char*)));
    connect(serialSTM32,SIGNAL(getGearPumpVal(unsigned char*)),this,SLOT(saveGearPumpVal(unsigned char*)));
    connect(serialSTM32,SIGNAL(getPulseCnt(unsigned char*)),this,SLOT(savePulseCntVal(unsigned char*)));
    connect(serialSTM32,SIGNAL(getSTM32Version(unsigned char*)),this,SLOT(saveSTM32Version(unsigned char*)));
    connect(serialSTM32,SIGNAL(getSTM32Time(unsigned char*)),this,SLOT(saveSTM32Time(unsigned char*)));
    connect(serialSTM32,SIGNAL(stopSendData(bool)),this,SLOT(stopSendSTM32Data(bool)));
    connect(serialSTM32,SIGNAL(powerOffReady()),m_MainWidget,SLOT(powerOffConfirmed()));
    connect(m_serialThreadSTM32,&QThread::started,serialSTM32,&Serial::startInitSlot);
    connect(serialSTM32,SIGNAL(queueSizeSTM32(int)),this,SLOT(showSTM32queuesize(int)));
    connect(serialSTM32, &Serial::STM32Connected, this, [this](bool ok, QString errorMsg){
        if(ok){
            LogInfo::setRunStatusText("Connected to STM32 serial port");
        }
        else{
            LogInfo::setRunStatusText("STM32 serial port connection failed: " + errorMsg);
        }
    });

    flagOfSerialThreadStratEn = true;
}

void InkJetPrinter::showFPGAqueuesize(int size){
    sysPara->status.sizeFPGA = size;
}

void InkJetPrinter::showSTM32queuesize(int size){
    sysPara->status.sizeSTM32 = size;
}

void InkJetPrinter::showqueueFPGAsize(int size){
    sysPara->status.sizequeueFPGA = size;
}

void InkJetPrinter::autoControlValvePump(void)

{
    if(sysPara){
        if(!sysPara->status.isPumpValveControledByHand){

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

            if(enableFlag != sysPara->devOp->isInkValveOpen()){
                if(enableFlag == false) {		//关闭供墨阀的顺序 先开循环阀后关闭供墨阀间
                    if (sysPara->status.cycleValveOpenCntAfterSWintOff == 0) {
                        sysPara->status.cycleValveOpenCntAfterSWintOff = MAX_CYCLEVALVE_OPEN_TIME_AFTER_SWITN_OFF;
                    }
                    if (sysPara->status.cycleValveOpenCntAfterSWintOff < 60) { //在准备关闭循环阀的时候关闭供墨阀
                        sysPara->devOp->controlInkValve(enableFlag);		//关供墨
                        sysPara->devOp->controlInkValvePWM(enableFlag);		//关供墨
                    }
                }
                else { //开供墨阀
                    if(!sysPara->devOp->isReclaimPumpOpen())	//开供墨阀之前要判断回收泵有没有开，没开就提前打开
                    {
                        sysPara->devOp->controlReclaimPump(true, false); // 回收泵开
                    }
                    if(!m_MainWidget->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.releaseValveOpenApending ||
                        sysPara->status.pressureOverFlowCnt > 2
                        )				//防止干扰和误动作
                    && !sysPara->status.releaseValveDelayCnt)
            {
                if(!sysPara->devOp->isReleaseValveOpen())
                {			//泄压阀
                    sysPara->devOp->controlReleaseValve(true);
                }
                sysPara->status.releaseValveDelayCnt = MAX_RELEASE_VALVE_DELAY_CNT;
                sysPara->status.releaseValveOpenApending = true;
            }
            else
            {
                if(sysPara->devOp->isReleaseValveOpen())
                {			//
                    //sysPara->devOp->controlReleaseValve(false);
                }

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

                    }
                }
            }

            /*-----------------------------------主墨泵------------------------------------------*/
//                if(sysPara->status.SEPTAL_POSITION < (sysPara->para.septalPostion - DIFF_SEPTAL_POSITION))
//                    sysPara->status.septalPositionOverFlowCnt ++;
//                else
//                    sysPara->status.septalPositionOverFlowCnt = 0;
                if(sysPara->status.septalPositionOverFlowCnt > 2 && !sysPara->status.mainInkPumpError){		//主墨泵
                    if(!sysPara->devOp->isMainInkPumpOpen()){
                        sysPara->devOp->controlMainInkPump(true);
                        sysPara->status.mainInkPumpRunTmCnt = 0;
                    }
                    else if(sysPara->status.selfCheckDone){
                        if(sysPara->status.mainInkPumpRunTmCnt < MAX_MAIN_INK_PUMP_RUN_TIME){													//
                            sysPara->status.mainInkPumpRunTmCnt ++;
                        }
                        else {
                            if(!sysPara->para.gearPumpEnable)
                            {
                                sysPara->status.mainInkPumpError = true;
                                sysPara->devOp->controlMainInkPump(false);
//                                LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!主墨泵故障"));
//                                ui->tabMainWindow->setRunStatus(tr("主墨泵故障!!!"));
                            }
                        }
                    }
                }
                else if(sysPara->status.SEPTAL_POSITION > sysPara->para.septalPostion){
                    if(sysPara->devOp->isMainInkPumpOpen())
                        sysPara->devOp->controlMainInkPump(false);
                }
            /*-----------------------------------压缩机------------------------------------------*/
                /*reserved
            if((sysPara->para.pressure - sysPara->status.PRESSURE > MAX_PRESSURE_DIFF) && !sysPara->status.compressPumpError){	//压缩机
                if(!sysPara->devOp->isCompressPumpOpen()){
                    sysPara->devOp->controlCompressPump(true);
                    sysPara->status.compressPumpRunTmCnt = 0;
                }
                else if(sysPara->status.selfCheckDone){
                    if(sysPara->status.compressPumpRunTmCnt < MAX_COMPRESS_PUMP_RUN_TIME){					//如果长时间开压缩机，考虑设备故障
                        sysPara->status.compressPumpRunTmCnt ++;
                    }
                    else {
                        sysPara->status.compressPumpError = true;
                        sysPara->devOp->controlCompressPump(false);
                        if(!sysPara->para.gearPumpEnable)
                        {
//                            LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!压缩机故障"));
//                            ui->tabMainWindow->setRunStatus(tr("压缩机故障!!!"));
                        }

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

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

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

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

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

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

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

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

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

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

            if(!sysPara->status.autoCtlReclaimAfterSWintOff)
            {
                if(!sysPara->devOp->isReclaimPumpOpen() ){					//回收泵
                    // ui->tabMainWindow->setRunStatus(tr("全速回收泵!!!"));
                    sysPara->status.reclaimPumpFullSpeedCnt = 0;
                    sysPara->devOp->controlReclaimPump(true,true);			//先全速，后降速
                }
                else if(sysPara->status.reclaimPumpFullSpeedCnt <= RECLAIM_PUMP_FULL_SPEED_CNT){
                    sysPara->status.reclaimPumpFullSpeedCnt ++;
                    if(sysPara->status.reclaimPumpFullSpeedCnt == RECLAIM_PUMP_FULL_SPEED_CNT){		//降速
                        // ui->tabMainWindow->setRunStatus(tr("降速回收泵!!!"));
                        sysPara->devOp->controlReclaimPump(true,false);
                    }
                }
            }
            /*-----------------------------------------------------------------------------*/
        }
    }
}

//在开机自检过程中交替打开和关闭循环阀
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::autoControlHeater(){
    //100ms
    static int tempDly=1830;
    if(sysPara->para.heatTime == 0)
        sysPara->para.heatTime = 5;
    int maxHeatTime = sysPara->para.heatTime * 600;
    if(sysPara->para.flagOfContinueHeat)
        maxHeatTime = 60* 600;
    if(tempDly) tempDly--;
    if(tempDly>=1800)
    {
        if(tempDly==1800)
        {
            sysPara->status.indoorTemperature = sysPara->status.TEMP_ADIN/4;
            sysPara->devOp->pumpValveCtrl(1);
//            if(sysPara->status.indoorTemperature-35>0)
//                ui->tabSystemSetting->updateViscosityAdjust((sysPara->status.indoorTemperature-35));
//            else
//                ui->tabSystemSetting->updateViscosityAdjust(0);
        }
        return;
    }
    if(sysPara->status.TEMP_ADIN/4 < sysPara->para.temperature && sysPara->status.heaterONTimeCnt < MAX_HEATER_TIME){
        if(tempDly==0) sysPara->status.heaterONTimeCnt ++;
        sysPara->devOp->controlHeater(true);

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

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

void InkJetPrinter::detectAndcontrolReclaimTank(){
    sysPara->status.currReclaimTankPos =10*sysPara->status.curr_reclaimTankTime;
    sysPara->status.reclaimTankBlockedAppending =0;
    if(sysPara->status.reclaimTankstatus == 0x10) //7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        LogInfo::setRunStatusText(tr("电机故障"));
        m_MainWidget->setRunStatus(tr("电机故障"));
        if(sysPara->devOp->isReclaimTankCloseEnable())
        {
            sysPara->devOp->controlReclaimTankClose(false);
        }
        else {
            if(sysPara->devOp->isReclaimTankOpenEnable())
                sysPara->devOp->controlReclaimTankOpen(false);
        }

    }
    else  if(sysPara->status.reclaimTankstatus == 5 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        if(sysPara->devOp->isReclaimTankOpenEnable())
            sysPara->devOp->controlReclaimTankOpen(false);		//到头，关闭
        sysPara->status.reclainTankReachEnd = true;
        m_MainWidget->setRunStatus(tr("回收槽到头"));
        m_MainWidget->setReclaimStatus(true, 100);
        m_MainWidget->enablePrintButton(true);			//仅仅在此时能使能打印按钮  
        sysPara->devOp->highVoltageCtrl(1);
//        emit reclaimTankOpenDone();
        /*回收槽开关时间校正*/
        sysPara->para.reclaimTankTime =( sysPara->status.currReclaimTankPos>120 )? sysPara->status.currReclaimTankPos/10-1:12;
        m_SystemSetting->updateReclaimTime( sysPara->para.reclaimTankTime );

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

    }
    else  if(sysPara->status.reclaimTankstatus == 6 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        if(sysPara->devOp->isReclaimTankCloseEnable())
            sysPara->devOp->controlReclaimTankClose(false);		//到头，关闭
        m_MainWidget->setReclaimStatus(false, 0);
        //sysPara->status.currReclaimTankPos = 0;				//将回收槽的时间置为零
//        emit reclaimTankCloseDone();
        sysPara->status.lastRecycleWarn = 0;
        sysPara->status.HVFaultCloseEn=0;
        sysPara->status.reclainCloseAppending=false;
        sysPara->status.canRunAirPushing = true; //下次开回收槽就执行排气程序

        // 过度占用日志，由Byons注释于2026年4月22日
        // qDebug()<<"reclaimTankCloseDone currReclaimTankPos:"<<sysPara->status.currReclaimTankPos;
        // qDebug()<<"reclaimTankCloseDone curr_reclaimTankTime:"<<sysPara->status.curr_reclaimTankTime;
    }
    else  if(sysPara->status.reclaimTankstatus == 0x12 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        sysPara->devOp->controlReclaimTankOpen(false);		//到头，关闭
        LogInfo::setRunStatusText(tr("回收槽卡住或者回收槽开关时间设置错误"));
        m_MainWidget->setRunStatus(tr("回收槽卡住或者回收槽开关时间设置错误"));
    }
}

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

void InkJetPrinter::rebootApp()
{
    if(!sysPara->status.selfCheckDone)
        sysPara->status.selfCheckDone = true;
        
    this->setDisabled(true);

    m_StackedWidget->setCurrentWidget(m_MainWidget);

    // emit setDisableAll();
    if(!TEST_MODE && sysPara->para.flagOfReclaimPumEnable){
        for(int i=15;i>11;i--)
        {
            if(i == 15){
                sysPara->status.isPumpValveControledByHand = true;		//停止自动
                sysPara->devOp->controlInkValve(true);
                sysPara->devOp->controlInkValvePWM(true);
                sysPara->devOp->controlReclaimPump(true,true);
                sysPara->devOp->controlViscosityPump(true);
                sysPara->devOp->controlCycleValve(true);
                sysPara->para.gearPumpValue = 0;
                sysPara->devOp->WriteMoterPump();
            }
            if(i == 12){
                sysPara->devOp->controlInkValve(false);
                sysPara->devOp->controlInkValvePWM(false);
            }
            m_MainWidget->setRunStatus(tr("正在准备重启,请等待%1秒...............").arg(i));
            MySleep(1000);
        }
    }
    sysPara->devOp->controlReclaimTankOpen(true);
    sysPara->status.isPumpValveControledByHand = true;		//停止自动
    if(sysPara->para.gearPumpEnable ){
        if(!sysPara->para.flagOfReclaimPumEnable){
            sysPara->para.gearPumpValue = 360;
            sysPara->devOp->WriteMoterPump();
        }
        else{
            sysPara->devOp->controlReclaimPump(true,false);
            sysPara->para.gearPumpValue = 0;
            sysPara->devOp->WriteMoterPump();
        }
    }
    else{
        sysPara->para.reclaimPumpPWMWidth = 95;
        sysPara->devOp->controlReclaimPump(true,true);
    }

    if(!sysPara->devOp->isViscosityPumpOpen())
        sysPara->devOp->controlViscosityPump(true);
    sysPara->devOp->controlCycleValve(true);
    sysPara->devOp->controlInkValve(false);		//关供墨
    sysPara->devOp->controlInkValvePWM(false);		//关供墨

    if(!TEST_MODE){
        for(int i=11;i>7;i--)
        {
            if(i==9)
                sysPara->devOp->controlReclaimTankOpen(false);
            m_MainWidget->setRunStatus(tr("正在准备重启,请等待%1秒...............").arg(i));
            MySleep(1000);
        }
    }

    if(!sysPara->status.lostCommuFlag){
        sysPara->para.calandar_and_dat.cnt1CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt();
        sysPara->para.calandar_and_dat.cnt2CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt();
        sysPara->para.Counter3.cnt3CurrValue = QString::number(sysPara->status.Status_Counter3.cnt3CurrValue,16).toInt();

        m_MainWidget->updateTotalCnt(0);
        sysPara->saveParaToFile();					// 关机前将相关配置保存
    }
    sysPara->status.powerOffAppending = false;
    if(!TEST_MODE){
        for(int i=7;i>0;i--)
        {
            if(i == 5)
                sysPara->devOp->controlReclaimTankClose(true);
            if(i == 4){
                sysPara->devOp->controlViscosityPump(false);
                sysPara->devOp->controlCycleValve(false);
                sysPara->devOp->controlReclaimPump(false,false);
                sysPara->para.gearPumpValue = 0;
                sysPara->devOp->WriteMoterPump();
            }
            m_MainWidget->setRunStatus(tr("正在准备重启,请等待%1秒...............").arg(i));
            MySleep(1000);
        }
    }

    sysPara->saveParaToFile();					// 关机前将相关配置保存
    sysPara->saveRFIDPara();
    MySleep(200);
    system("sync");//缓存同步
    QCoreApplication::quit();
}

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

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

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

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

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

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

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

void InkJetPrinter::setShowVserionInfo(QString str){
    ui.label_version->setText(str);
}

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

}


#define INTERVAL_BEFORE48H  30
#define INTERVAL_AFTER48H   5

void InkJetPrinter::warningHandler(int type){
    static int lastMin = 0;
    static bool flagOfWarning = true;
    static  bool flagOfmtWarning = true;
    static int lastTimeElasped = 0;
    QTime curTime = QTime::currentTime();
    QDateTime curDateTime = QDateTime::currentDateTime();
    int curMin = curTime.minute();
    int timeElasped = 0;
    if(lastMin != curMin){
        lastMin = curMin;
        if(type == 1 && sysPara->RFIDPara.inkCardTimeOut){
            if(++sysPara->status.showInkWarningNumber >= INTERVAL_AFTER48H){
                warningShow(type,49);
                sysPara->status.showInkWarningNumber = 0;
            }
            return;
        }
        if(type == 2 && sysPara->RFIDPara.solventCardTimeOut){
            if(++sysPara->status.showSolventWarningNumber >= INTERVAL_AFTER48H){
                warningShow(type,49);
                sysPara->status.showSolventWarningNumber = 0;
            }
            return;
        }
        /***********处理保养到期提示start************************/
        if(type == 3){
            static int i = 1;
            if(sysPara->RFIDPara.needMaintenance){//保养到期,喷码机禁用
                warningShow(3,timeoutDay);
            }
            else if(sysPara->status.needMaintenanceRemind){//保养到期提前一个月提示
                if(flagOfmtWarning){
                    warningShow(3,timeoutDay);
                    flagOfmtWarning = false;
                }
                QDateTime curDateTime = QDateTime::currentDateTime();
                int elasped = curPowerOnDateTime.secsTo(curDateTime);
                if(elasped >= 7200*i){
                    i++;
                    flagOfmtWarning = true;
                }
            }
            return;
        }
        /***********处理保养到期提示end**************************************/

        timeElasped = dateTimeElasped(type,curDateTime.toString("yyyy-MM-dd HH::mm::ss"));
        if(timeElasped - lastTimeElasped >= 60*INTERVAL_BEFORE48H){
            qDebug()<<"Next Hour Warning";
            LogInfo::setRunStatusText("Next Hour Warning");
            flagOfWarning = true;//一个小时提示一次
        }
        for(int i = 1;i<49;i++){
            if(timeElasped <= i*3600 && flagOfWarning){
                lastTimeElasped = timeElasped;
                warningShow(type,49-i);
                flagOfWarning = false;
                break;
            }
        }
        if(timeElasped > 48*3600){
            if(type == 1){
                sysPara->RFIDPara.inkCardTimeOut = true;
                warningShow(1,49);
            }
            if(type == 2){
                sysPara->RFIDPara.solventCardTimeOut = true;
                warningShow(2,49);
            }
            sysPara->saveRFIDPara();
        }
    }
}

void InkJetPrinter::warningShow(int type,int num){
    QString str = "";
    if(type == 1){
        if(num < 49)
            str = tr("请刷墨水卡,请使用原厂墨水耗材,否则机器将在%1小时后禁止使用!").arg(num);
        else if(num == 49)
            str = tr("墨水液位报警超过48小时,机器无法正常打印,请先添加原厂墨水再刷墨水卡,以恢复喷码机的正常工作!");
        msgtest->setText(str);
        msgtest->show();
//        m_MainWidget->setRunStatus(str);
        LogInfo::setRunStatusText(str);
        qDebug()<<str;
    }
    else if(type == 2){
        if(num < 49)
            str = tr("请刷溶剂卡,请使用原厂溶剂耗材,否则机器将在%1小时后禁止使用!").arg(num);
        else if(num == 49)
            str = tr("溶剂液位报警超过48小时,机器无法正常打印,请先添加溶剂再刷溶剂卡以恢复喷码机的正常工作!");
        msgtest->setText(str);
        msgtest->show();
//        m_MainWidget->setRunStatus(str);
        LogInfo::setRunStatusText(str);
        qDebug()<<str;
    }
    else if(type == 3){
        if(timeoutDay >= 0)
            str = tr("保养期还有%1天到期,请及时保养,否则喷码机容易损坏").arg(num);
        else
            str = tr("保养期已超过%1天,请进行保养以恢复喷码机的正常使用").arg(num*(-1));
        msgtest->setText(str);
        msgtest->show();
//        m_MainWidget->setRunStatus(str);
        LogInfo::setRunStatusText(str);
        qDebug()<<str;
    }
}
/**
 * @brief 创建新的工作文件
 * 
 */
void InkJetPrinter::createNewJobFile()
{
    auto currentFile = m_TestPrintWidget->currentFile();
    if(!currentFile.isEmpty()) {
        QFileInfo fileInfo(currentFile);
        auto ret = QMessageBox::information(nullptr, "", tr("当前正在使用\r\n %1 \r\n确定要新建文件吗?").arg(fileInfo.baseName()), 
                                            QMessageBox::Ok, QMessageBox::Cancel);
        if(ret == QMessageBox::Cancel) {
            LogInfo::setRunStatusText("Canceled create new job file.");
            return;
        }
    }

    LogInfo::setRunStatusText("Create new job file...");
    qInfo() << "Switch to job edit widget...";
    m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
    m_TestPrintWidget->on_newfileButton_pressed();
}

int InkJetPrinter::dateTimeElasped(int type,QString str){
    QFile file;
    if(type == 1)
        file.setFileName("/home/plg/inkRFIDTime.txt");
    else if(type == 2)
        file.setFileName("/home/plg/solventRFIDTime.txt");
    if(!file.exists()){
        qDebug()<<"刷卡倒计时起始时间文件不存在";
        LogInfo::setRunStatusText(tr("刷卡倒计时起始时间文件不存在"));
        return -1;
    }
    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            // 读取文件内容
            QTextStream in(&file);
            QString starTime = in.readAll();
            // 关闭文件
            file.close();
            QDateTime startDateTime = QDateTime::fromString(starTime,"yyyy-MM-dd HH::mm::ss");
            QDateTime curDateTime = QDateTime::fromString(str,"yyyy-MM-dd HH::mm::ss");
            int dateTimeDiff = startDateTime.secsTo(curDateTime);
            return dateTimeDiff;

        } else {
            qDebug() << "Failed to open file for reading:";
            return -1;
    }
}

bool InkJetPrinter::cardTouchConfirm(QString msgTxt, QString variableMsgTxt)
{
    QMessageBox box(QMessageBox::Warning, tr("警告"), 
            msgTxt, QMessageBox::Ok | QMessageBox::Cancel,
            this);

    int rfidCountDown = sysPara->para.rfidCountDown;
    QTimer msgTimer;
    QString boxTxt = variableMsgTxt;
    connect(&msgTimer, &QTimer::timeout, [this, &box, &rfidCountDown, boxTxt]() {
        box.setText(boxTxt.arg(rfidCountDown));
        box.update();
        rfidCountDown--;
        if(rfidCountDown == 0) {
            box.accept();
        }
    });

    if(sysPara->para.rfidCountDown > 0) {
        box.setText(boxTxt.arg(sysPara->para.rfidCountDown));
        msgTimer.start(1000);
    }

    box.exec();

    return box.result() == QMessageBox::Ok || box.result() == QMessageBox::Accepted;
}

void InkJetPrinter::initRunTimeCtrl()
{
    if (ctrl_runTime == nullptr) {
        ctrl_runTime = RunTimeCtrl::instance();
#ifdef __RFID_CARD
        connect(ctrl_runTime, &RunTimeCtrl::sig_updateTimeoutDay, this, [=](int days) {
            // timeoutDay：仅适用于原来月份的处理
            this->timeoutDay = days;
            if(timeoutDay <= 30)
                sysPara->status.needMaintenanceRemind = true;
        });
        connect(ctrl_runTime, &RunTimeCtrl::sig_saveRunTime, this, [=]() {
            // 运行时间处理
            sysPara->RFIDPara.runTime += 30;
            sysPara->saveRFIDPara();
        });
        // 弹窗提示
        connect(ctrl_runTime, &RunTimeCtrl::sig_alertTimeout,
                this, &InkJetPrinter::slt_warningMaintenance);

        curPowerOnDateTime = QDateTime::currentDateTime();
        if (sysPara)
            ctrl_runTime->loadConfig(&sysPara->RFIDPara);
        ctrl_runTime->start();
#endif

    }
}

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

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