#include "InkJetPrinter.h"

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

#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);
    m_dlgFileOperation = new DialogFileOperation(this);

    connect(m_dlgFileOperation, &DialogFileOperation::openFile, this, &InkJetPrinter::onDlgFileOpen);

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

    // 初始文件名为 空
    ui.label_currWorkFile->setText("");
    ui.label_currEditFile->setText("");

    // 信号槽连接（原逻辑完全不变）
    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_updatePrintContent, this, &InkJetPrinter::slt_updatePrintContent);
    
    #ifndef FPGA_TEST
    // 调入文件喷印时，主动重启打印
    // connect(m_TestPrintWidget, &TestPrintWidget::sig_currentFileChanged, this, [this](){

    //     ui.label_currWorkFile->setText(m_TestPrintWidget->currentFile());

    //     auto isPrinting = sysPara->status.isPrinting;
    //     if(isPrinting) {
    //         m_MainWidget->on_m_StopBtn_clicked();

    //         QTimer::singleShot(500, [this](){

    //             m_PrintSetting->applyPrintSettingsToSysPara(false);

    //             m_MainWidget->on_m_StartBtn_clicked();
    //             LogInfo::setRunStatusText("Restarting the print because the work file was switched.");
    //         });
    //     }
    //     else {
    //         QTimer::singleShot(300, [this](){
    //             m_PrintSetting->applyPrintSettingsToSysPara(false);
    //         });
    //     }
    // });
    #endif

    // 班时元素与编辑 连接
    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_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_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_FontSetWidget->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);


    // 创建 32 线程和 FPGA 线程，并初始化串口
    m_serialThreadFPGA = new QThread;
    m_serialThreadSTM32 = new QThread();
    initSerialPorts();

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

    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_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);
    connect(m_SystemUpdate,&SystemUpdate::sig_reboot,this,&InkJetPrinter::rebootApp);

    // 原注释的默认页面设置（按需启用）
    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()
{
    // 距离维护时间结束大于30天，判断运行时间的检测
    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();
        LogInfo::setRunStatusText(str);
        return;
    } else {
        warningHandler(CARD_TYPE::MAINTENANCE); // 距离维护时间结束大于30天，判断运行时间的检测
        return;
    }

}

void InkJetPrinter::showEvent(QShowEvent *e)
{
    static bool firstShow = true;

    QWidget::showEvent(e);

    if(firstShow) {
        loadLastWorkAndPreparePrint();
        firstShow = false;
    }
}

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：Δu = Kp*(e[k]-e[k-1]) + Ki*e[k]
    pid.Kp = 0.15f;
    pid.Ki = 0.02f;
    pid.Kd = 0.0f;
    pid.SetSpeed    = speed;
    pid.ActualSpeed = act;
    pid.err         = pid.SetSpeed - pid.ActualSpeed;

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

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

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

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

    if(!sysPara->para.gearPumpEnable)
    {
        if(u > 0 || ((sysPara->para.pressure - sysPara->status.PRESSURE) > 0))
            u = PID_realize((float)sysPara->para.pressure, (float)sysPara->status.PRESSURE);
        sysPara->para.gearPumpValue = (u > 0) ? (unsigned short)u : 0;
        if(sysPara->para.gearPumpValue > 800)
            sysPara->para.gearPumpValue = 800;
        sysPara->devOp->WriteMoterPump();
        return;
    }

    int maxValue = sysPara->para.flagOfReclaimPumEnable ? 420 : 800;
    if(maxValue < 60) maxValue = 60;

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

    auto clampU = [&]() {
        if(u < 60.0f)           u = 60.0f;
        if(u > (float)maxValue) u = (float)maxValue;
    };

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

    // 每次进入都更新滑动平均缓冲（软启动用瞬时值，闭环用平均值）
    m_pressureBuf[m_bufIdx] = actual;
    m_bufIdx = (m_bufIdx + 1) % 10;
    int avgPressure = 0;
    for(int i = 0; i < 10; i++) avgPressure += m_pressureBuf[i];
    avgPressure /= 10;

    // ---------------------------------------------------------------
    // 硬保护：压力超过目标+50，立即强制减速，优先级最高
    // 覆盖自检、软启动、闭环所有阶段
    // ---------------------------------------------------------------
    if(actual > target + 50)
    {
        float overErr = (float)(actual - (target + 50));
        float delta   = -0.1f * overErr;
        if(delta < -15.0f) delta = -15.0f;
        u += delta;
        clampU();
        m_lastPressure = actual;
        sysPara->para.gearPumpValue = (unsigned short)(int)u;
        sysPara->devOp->WriteMoterPump();
        return;
    }

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

        int err = target - actual;

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

        clampU();

        // 转速上限保护
        if(sysPara->para.flagOfReclaimPumEnable &&
                sysPara->status.gearPumpRunSpeed >= maxSpeed)
        {
            u -= 3.0f;
            clampU();
        }

        cur = (int)u;

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

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

    // ---------------------------------------------------------------
    // 闭环：等压力稳定后再调速，自适应管路响应时间
    //
    // 每100ms采样一次，连续3次压力变化<15认为稳定，才执行调速
    // 最长等待5s（50次）兜底，防止管路持续抖动导致永远不调
    //
    // 调速后立即重置稳定计数，重新等待下一次稳定
    //
    // 分区Kp：误差大步子大，误差小步子小
    //   |err| > 100 → Kp=0.05，限幅±5
    //   |err| 50~100→ Kp=0.04，限幅±4
    //   |err| < 50  → Kp=0.03，限幅±3
    // ---------------------------------------------------------------
    {
        // 稳定检测用平均值，滤掉传感器噪声
        int pressureChange = avgPressure - m_lastPressure;
        if(pressureChange < 0) pressureChange = -pressureChange;
        m_lastPressure = avgPressure;
        m_adjSkip++;  // 复用为超时计数

        bool stable  = (pressureChange < 10);
        bool timeout = (m_adjSkip >= 50);  // 5s兜底

        if(stable)
            m_stableCount++;
        else
            m_stableCount = 0;

        bool readyToAdj = (m_stableCount >= 15) || timeout;

        if(!readyToAdj)
        {
            sysPara->para.gearPumpValue = (unsigned short)(int)u;
            sysPara->devOp->WriteMoterPump();
            return;
        }

        // 平均压力已稳定（或超时兜底），执行调速，重置计数
        m_adjSkip     = 0;
        m_stableCount = 0;

        // 误差用平均值计算，避免瞬时噪声影响调速幅度
        float absErr = (float)(target - avgPressure);
        if(absErr < 0.0f) absErr = -absErr;

        float kp, capDelta;
        if(absErr > 100.0f)      { kp = 0.05f; capDelta = 5.0f; }
        else if(absErr > 50.0f)  { kp = 0.04f; capDelta = 4.0f; }
        else                     { kp = 0.03f; capDelta = 3.0f; }

        float err     = (float)(target - avgPressure);
        float delta_u = kp * err;

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

        // 转速上限软限制：转速已达上限时禁止继续加速
        if(sysPara->para.flagOfReclaimPumEnable &&
                sysPara->status.gearPumpRunSpeed >= maxSpeed)
        {
            if(delta_u > 0.0f) delta_u = 0.0f;
        }

        u += delta_u;
        clampU();
        cur = (int)u;

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


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->setReclaimOpenBtnStatus(false);
                m_MainWidget->setReclaimCloseBtnStatus(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) {
                    // 确保开机时控制字从 0 开始，让 pressureAdj 软启动从 0 爬坡，避免突变到高转速
                    if(sysPara->para.gearPumpValue != 0) {
                        sysPara->para.gearPumpValue = 0;
                        u = 0.0f;
                        sysPara->devOp->WriteMoterPump();
                    }
                    gearPumpStartFlag = true;
                }
            }
        }

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

                    pulse_5s++;
                }
                if( pulse_5s == 5)
                {
                    pulse_5s = 0;
                    gearPumpRunNormalFlag = true;
                    gearPumpRunNormalValue = u;
                }
            }
        }
        if(sysPara->status.isPumpValveControledByHand)
        {
            gearPumpRunNormalFlag = false;
            ControledSwitchFlag = false;
            pulse_3s = 0;
        }
        // 检测手动→自动边沿，直接恢复压力控制，不走 gearPumpStartFlag 的 3s 等待
        if(m_lastByHand && !sysPara->status.isPumpValveControledByHand)
        {
            ControledSwitchFlag = true;
            u              = (float)sysPara->para.gearPumpValue; // 同步当前转速，避免突变
            m_rampDone     = false;  // 重新软启动，适应切换后的压力状态
            m_adjSkip      = 0;
            m_lastPressure = 0;
            m_stableCount  = 0;
            for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
            m_bufIdx = 0;
        }
        m_lastByHand = sysPara->status.isPumpValveControledByHand;
        if(!(sysPara->status.statWarn & WARN_STATUS_INK_SWINT)){//墨线开关,压力抖动
            InkSwintFlag = true;
        }
        else
        {
            InkSwintFlag = false;
        }
        if(lastInkSwintFlag != InkSwintFlag)
        {
            lastInkSwintFlag = InkSwintFlag;
            gearPumpRunNormalFlag = false;
        }
        if(gearPumpRunNormalFlag && !sysPara->status.isPumpValveControledByHand && sysPara->para.gearPumpEnable)
        {
            static int 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(m_lastReclaimMode != sysPara->para.flagOfReclaimPumEnable)
            {
                m_lastReclaimMode      = sysPara->para.flagOfReclaimPumEnable;
                gearPumpRunNormalFlag  = false;
                gearPumpRunNormalValue = 0.0f;
                m_rampDone     = false;
                m_adjSkip      = 0;
                m_lastPressure = 0;
                m_stableCount  = 0;
                for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
                m_bufIdx = 0;
            }
            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日
            // byons: 变量类图元现在优化为局部更新，避免每次都要把整个打印内容发送给FPGA，现在只发送被更新的列区间 2026年7月16日
            auto updateAreas = m_MainWidget->variableItemsUpdate();
            if(sysPara->status.isPrinting && !updateAreas.isEmpty()){
                for(const auto& area : updateAreas) {
                    m_MainWidget->SendPrintDataToFpga(0, area.left(), area.width());
                }
            }

            if (!updateAreas.isEmpty() && m_StackedWidget->currentWidget() == m_MainWidget) {
                // // 统计追踪更新频率
                // 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;
                // }
                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()<<"打印过程中死机了!!!";
                    
                    m_MainWidget->on_m_StopBtn_clicked();
                }

                if(!sysPara->status.selfCheckDone)
                {
                    /*开机自检*/
                    autoControlValvePump();
                      if(pulse_100ms){
                        pressureAdj();
                      }
                    /*-----------------------------------------------------*/
                    if(!sysPara->status.selfCheckCnt) {
                        LogInfo::setRunStatusText(tr("开始自检,请等待60秒..."));
                        
                        m_MainWidget->setReclaimOpenBtnStatus(false);
                        m_MainWidget->setReclaimCloseBtnStatus(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));
                    }
#ifdef QT_DEBUG
                    if(sysPara->status.selfCheckCnt >= 1500) // 测试自检改为15s
#else
                    if(sysPara->status.selfCheckCnt >= MAX_SELF_CHECK_CNT)
#endif
                    {
                        sysPara->status.selfCheckDone = 1;
                        // 自检完成后管道恢复正常阻力，重置软启动让压力重新平稳收敛
                        // 不清零 u，从当前控制字开始，避免突变
                        u = (float)sysPara->para.gearPumpValue;
                        m_rampDone     = false;
                        m_adjSkip      = 0;
                        m_lastPressure = 0;
                        m_stableCount  = 0;
                        for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
                        m_bufIdx = 0;
                        
                        m_MainWidget->setReclaimOpenBtnStatus(true);
                        m_MainWidget->setReclaimCloseBtnStatus(false);

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

                        // 自检完成后，关闭高电压，不知道为什么，有时候开机自检都有高压
                        sysPara->devOp->highVoltageCtrl(0);

                        // 自检完成后，写入一遍打印设置和内容，不然好像直接开始打印不行
                        if(m_PrintSetting)
                            m_PrintSetting->applyPrintSettingsToSysPara(false);

                        m_MainWidget->SendPrintDataToFpga(0);

                        m_MainWidget->on_m_StopBtn_clicked();

                        LogInfo::setRunStatusText(tr("自检完成!!!"));
                        m_MainWidget->setRunStatus(tr("自检完成!!!"));
                        qDebug()<<"自检完成!!!";

                        if(sysPara->para.Reciclar)
                            test_flag = 1;
                    }
                    else {
                        if((sysPara->status.selfCheckCnt % 200) == 0)
                            m_MainWidget->setReclaimOpenBtnStatus(false);
                            m_MainWidget->setReclaimCloseBtnStatus(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);
//            }
//            LogInfo::setRunStatusText(tr("处理警告:%1").arg(QDateTime::currentDateTime()));

            handleWarnInk(); // 处理墨水警告
            handleWarnSolvent(); // 处理溶剂警告
#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);
        ui.label_currEditFile->setText("");
        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::slt_updatePrintContent(const QString &filename)
{
    loadWorkFileAndPreparePrint(filename);
}

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_TestPrintWidget->openWorkFile(sysPara->para.lastOpenedFileName);
        QFileInfo fileInfo(sysPara->para.lastOpenedFileName);
        ui.label_currEditFile->setText(QString("E: %1").arg(fileInfo.baseName()));
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
        break;
    }
    case 2: // 调入文件喷印
        m_dlgFileOperation->setWindowModality(Qt::WindowModal);
        m_dlgFileOperation->refreshListView(SCENE);
        m_dlgFileOperation->show();
        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){
    if (m_isDefaultPrintSettingMode) {
        exitDefaultPrintSettingMode();
        m_StackedWidget->setCurrentWidget(m_MainInstruction);  // 修改完默认设置后，回到MainInstruction
        return;
    }

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

void InkJetPrinter::enterDefaultPrintSettingMode()
{
    m_savedPrintSettingModel = m_PrintSetting->model();
    m_PrintSetting->setDefaultSettingMode(true);
    m_PrintSetting->setModel(PrintSettingModel::defPrintSettingModel());
    m_isDefaultPrintSettingMode = true;
    m_StackedWidget->setCurrentWidget(m_PrintSetting);
}

void InkJetPrinter::exitDefaultPrintSettingMode()
{
    m_PrintSetting->setModel(m_savedPrintSettingModel);
    m_PrintSetting->setDefaultSettingMode(false);
    m_isDefaultPrintSettingMode = false;
}

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_SystemSetting->updateSysParaToUI();
        m_StackedWidget->setCurrentWidget(m_SystemSetting);
        break;
    }
    case 4:
    {
        m_StackedWidget->setCurrentWidget(m_OtherInfo);
        break;
    }
    case 5:
    {
        m_StackedWidget->setCurrentWidget(m_SystemUpdate);
        break;
    }
    case 6:
    {
        enterDefaultPrintSettingMode();
        break;
    }
    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];
    }

    QString hexStr = QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue, 16);
    bool ok;
    // sysPara->para.cnt1CurrValue = hexStr.toUInt(&ok, 10);

    hexStr = QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue, 16);
    // sysPara->para.cnt2CurrValue = hexStr.toUInt(&ok, 10);
}

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;
    int len = data[3];
    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();

    initSerialPorts();
}

void InkJetPrinter::initSerialPorts()
{
    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));
    });

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

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

        m_MainWidget->stopFlashReclaimOpenBtn();
    }
    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);

        m_MainWidget->stopFlashReclaimOpenBtn();

//        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;

        LogInfo::setRunStatusText("reclaimTankOpenDone currReclaimTankPos:"+QString::number(sysPara->status.currReclaimTankPos));
    }
    else  if(sysPara->status.reclaimTankstatus == 0x11 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        sysPara->devOp->controlReclaimTankOpen(false);		//卡住，关闭
        m_MainWidget->stopFlashReclaimOpenBtn();
//        ui->tabMainWindow->setRunStatus(tr("回收槽卡住或者回收槽开关时间设置错误"));
    }
    else  if(sysPara->status.reclaimTankstatus == 1 || sysPara->status.reclaimTankstatus == 2)//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        auto recliamTime = (sysPara->para.reclaimTankTime != 0 ? sysPara->para.reclaimTankTime : 15.0f) * 10.0f;
        int rate = qBound(0, 100, int((sysPara->status.currReclaimTankPos / recliamTime) * 100));

        // 不知道为什么会有rate为0，且 sysPara->status.reclaimTankstatus == 2 ，也就是 关的状态。 回收槽位置在0处，而状态却是 关 ，很奇怪
        if(sysPara->status.reclaimTankstatus != 2 && rate != 0) {
            m_MainWidget->setReclaimStatus(sysPara->status.reclaimTankstatus == 1, rate);
        }

        m_MainWidget->setReclaimOpenBtnStatus(sysPara->status.reclaimTankstatus == 2);
        m_MainWidget->setReclaimCloseBtnStatus(sysPara->status.reclaimTankstatus == 1);

        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);
        m_MainWidget->stopFlashReclaimOpenBtn();
        //sysPara->status.currReclaimTankPos = 0;				//将回收槽的时间置为零
//        emit reclaimTankCloseDone();
        sysPara->status.lastRecycleWarn = 0;
        sysPara->status.HVFaultCloseEn=0;
        sysPara->status.reclainCloseAppending=false;
        sysPara->status.canRunAirPushing = true; //下次开回收槽就执行排气程序
    }
    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("回收槽卡住或者回收槽开关时间设置错误"));
    }
    else  if(sysPara->status.reclaimTankstatus == 4 ) 
    {
        m_MainWidget->setReclaimOpenBtnStatus(true);
        m_MainWidget->setReclaimCloseBtnStatus(true);
        LogInfo::setRunStatusText("Reclaim tank hold on "+QString::number(sysPara->status.currReclaimTankPos));
    }
}

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


bool InkJetPrinter::loadLastWorkAndPreparePrint()
{
    // 打开最后一次作业文件
    qDebug() << sysPara->sysFile;
    qDebug() << sysPara->para.lastOpenedFileName;
    QString lastFilename = QString(sysPara->para.lastOpenedFileName);

    QFileInfo fileInfo(lastFilename);
    if (!(fileInfo.exists() && fileInfo.isFile())) {
        LogInfo::setRunStatusText(QString("Last work file not found: %1").arg(lastFilename));
        return false;
    }

    return loadWorkFileAndPreparePrint(lastFilename);
}

bool InkJetPrinter::loadWorkFileAndPreparePrint(const QString &filename)
{
    auto u8Filename = filename.toUtf8();
    if(u8Filename.size() > int(ARRAY_SIZE(sysPara->para.lastOpenedFileName) - 1)) {
        LogInfo::setRunStatusText(QString("File name is too long: %1").arg(filename));
        return false;
    }

    PicScene* scene = new PicScene();
    PrintSettingModel model;
    auto ret = PicSceneLoader::loadSceneFromFile(filename, scene, &model);
    if(!ret) {
        LogInfo::setRunStatusText(QString("Failed to load work file: %1").arg(filename));
        delete scene;
        return false;
    }

    bool rePrint = false;
    if(sysPara->status.isPrinting && sysPara->status.selfCheckDone) {
        m_MainWidget->on_m_StopBtn_clicked();
        rePrint = true;
    }

    PrintSettingModel::applyToSysPara(model, sysPara);

    // 应用完数据之后，将当前值编辑标志位清除，避免下次读取时为 true
    model.cnt1Settings.editCurrValue = false;
    model.cnt2Settings.editCurrValue = false;
    PicSceneLoader::saveSceneToXmlFile(filename, scene, &model);

    ret = m_MainWidget->generatePrintContent(scene);
    if(!ret) {
        LogInfo::setRunStatusText(QString("Failed to generate print content from work file: %1").arg(filename));
        delete scene;
        return false;
    }
    
    LogInfo::setRunStatusText(QString("Work file loaded: %1").arg(filename));

    ui.label_currWorkFile->setText(QFileInfo(filename).baseName());

    strncpy(sysPara->para.lastOpenedFileName, u8Filename.constData(), sizeof(sysPara->para.lastOpenedFileName) - 1);
    sysPara->para.lastOpenedFileName[sizeof(sysPara->para.lastOpenedFileName) - 1] = '\0';
    sysPara->saveParaToFile();

    if(rePrint) {
        m_MainWidget->on_m_StartBtn_clicked();
    }

    return true;
}


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_AFTER48H   5

void InkJetPrinter::warningHandler(int type){
    static bool flagOfWarning = true;
    static bool flagOfmtWarning = true;
    static int i = 1;
    int elasped = curPowerOnDateTime.secsTo(QDateTime::currentDateTime());// 本次开机运行秒数
    if(elasped >= 60*60*i){ //开机后1小时提醒一次,测试时可以缩短
    // if (elasped > 10*i) {//test
        i++;
        flagOfmtWarning = true;
        flagOfWarning = true;
        LogInfo::setRunStatusText("Next Hour Warning");
    }
    int inkTime = 0, solventTime = 0;
    if (type == CARD_TYPE::INK) {
        // 只有当报警标志为true时，文件的时间才会更新，此时才读取
        if(sysPara->para.flagOfInkWarning) {
            int dateTimeDiff = updateWarningTime(type);
            if (dateTimeDiff > 60*60*24*2) {
                sysPara->RFIDPara.inkCardTimeOut = true;
            }
            if (!sysPara->RFIDPara.inkCardTimeOut)
                inkTime = 48- dateTimeDiff/60/60;
        }
        if(sysPara->RFIDPara.inkCardTimeOut && flagOfWarning){
            if(++sysPara->status.showInkWarningNumber >= INTERVAL_AFTER48H){
                warningShow(CARD_TYPE::INK,49);
                sysPara->status.showInkWarningNumber = 0;//是否有必要保存?
                sysPara->saveRFIDPara();
                flagOfWarning = false;
                return;
            }
        }
        sysPara->saveRFIDPara();
    }
    else if(type == CARD_TYPE::SOLVENT) {
        //只有当报警标志为true时，文件的时间才会更新，此时才读取
        if (sysPara->para.flagOfSolventWarning) {
            int dateTimeDiff = updateWarningTime(type);
            if (dateTimeDiff > 60*60*24*2) {
                sysPara->RFIDPara.solventCardTimeOut = true;
            }

            if (!sysPara->RFIDPara.solventCardTimeOut)
                solventTime = 48- dateTimeDiff / 60 / 60;
        }

        if(sysPara->RFIDPara.solventCardTimeOut  && flagOfWarning){
            if(++sysPara->status.showSolventWarningNumber >= INTERVAL_AFTER48H){
                warningShow(CARD_TYPE::SOLVENT,49);
                sysPara->status.showSolventWarningNumber = 0;
                sysPara->saveRFIDPara();
                flagOfWarning = false;
                return;
            }
        }

        sysPara->saveRFIDPara();
    }
    /***********处理保养到期提示start******************/
    else if(type == CARD_TYPE::MAINTENANCE){
        if(sysPara->RFIDPara.needMaintenance){//保养到期,喷码机禁用
            warningShow(CARD_TYPE::MAINTENANCE,timeoutDay);
        }
        //needMaintenanceRemind:保养到期提前一个月提示标志
        else if(sysPara->status.needMaintenanceRemind){
            if(flagOfmtWarning){
                warningShow(CARD_TYPE::MAINTENANCE,timeoutDay);
                flagOfmtWarning = false;
            }
        }
        return;
    }
    /***********处理保养到期提示end******************/

    // 超过48小时后，不会执行这一段
    if(flagOfWarning){
        //48小时后禁用，小时=第一次提示时间到当前时间的间隔秒数/60/60
        if (type == INK && sysPara->para.flagOfInkWarning)
            warningShow(type,inkTime);
        else if (type == SOLVENT && sysPara->para.flagOfSolventWarning)
            warningShow(type,solventTime);

        flagOfWarning = false;
    }
}

// 1:Ink 2:Solvent 3:Maintenance
void InkJetPrinter::warningShow(int type,int num){
    QString str = "";
    if(type == CARD_TYPE::INK && sysPara->RFIDPara.needInkCard){
        if(num < 49)
            str = tr("请刷墨水卡,请使用原厂墨水耗材,否则机器将在%1小时后禁止使用!").arg(num);
        else if(num == 49)
            str = tr("墨水液位报警超过48小时,机器无法正常打印,请先添加原厂墨水再刷墨水卡,以恢复喷码机的正常工作!");
        slt_showMsg(str);
//        m_MainWidget->setRunStatus(str);
        LogInfo::setRunStatusText(str);
        qDebug()<<str;
    }
    else if(type == CARD_TYPE::SOLVENT && sysPara->RFIDPara.needSolventCard){
        if(num < 49)
            str = tr("请刷溶剂卡,请使用原厂溶剂耗材,否则机器将在%1小时后禁止使用!").arg(num);
        else if(num == 49)
            str = tr("溶剂液位报警超过48小时,机器无法正常打印,请先添加溶剂再刷溶剂卡以恢复喷码机的正常工作!");
        slt_showMsg(str);
//        m_MainWidget->setRunStatus(str);
        LogInfo::setRunStatusText(str);
        qDebug()<<str;
    }
    else if(type == CARD_TYPE::MAINTENANCE){
        if(timeoutDay >= 0)
            str = tr("保养期还有%1天到期,请及时保养,否则喷码机容易损坏").arg(num);
        else
            str = tr("保养期已超过%1天,请进行保养以恢复喷码机的正常使用").arg(num*(-1));
        slt_showMsg(str);
        LogInfo::setRunStatusText(str);
        qDebug()<<str;
    }
}
/**
 * @brief 创建新的工作文件
 * 
 */
void InkJetPrinter::createNewJobFile()
{
    LogInfo::setRunStatusText("Create new job file...");
    qInfo() << "Switch to job edit widget...";
    ui.label_currEditFile->setText(("E: (New file)"));
    m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
    m_TestPrintWidget->on_newfileButton_pressed();
}

int InkJetPrinter::updateWarningTime(int type){
    QFile file;
    if(type == 1)
        file.setFileName("/home/plg/inkRFIDTime.txt");
    else if(type == 2)
        file.setFileName("/home/plg/solventRFIDTime.txt");
    else 
        return -1;
        
    if(!file.exists()){
        LogInfo::setRunStatusText(tr("刷卡倒计时起始时间文件不存在"));
        return -1;
    }

    QDateTime curDateTime = QDateTime::currentDateTime();
    int dateTimeDiff = -1;
    if (type == 1) {
        if (inkWarnTime == QDateTime()) {
            if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
                // 读取文件内容
                QTextStream in(&file);
                QString starTime = in.readAll(); // 第一次提示的时间
                starTime = starTime.trimmed();
                // 关闭文件
                file.close();
                inkWarnTime = QDateTime::fromString(starTime,"yyyy-MM-dd HH::mm::ss");
                qDebug() << inkWarnTime;
            } else {
                qDebug() << "Failed to open file for reading:";
                LogInfo::setRunStatusText("Failed to open file for reading");
                return -1;
            }
        }
        dateTimeDiff = inkWarnTime.secsTo(curDateTime);

    } else if (type == 2) {
        if (solventWarnTime == QDateTime()) {
            if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
                // 读取文件内容
                QTextStream in(&file);
                QString starTime = in.readAll(); // 第一次提示的时间
                starTime = starTime.trimmed();
                // 关闭文件
                file.close();
                solventWarnTime = QDateTime::fromString(starTime,"yyyy-MM-dd HH::mm::ss");
            } else {
                qDebug() << "Failed to open file for reading:";
                LogInfo::setRunStatusText("Failed to open file for reading");
                return -1;
            }
        }
        dateTimeDiff = solventWarnTime.secsTo(curDateTime);
    }
    return dateTimeDiff;
}

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

        auto checkReclaimOpenBtn = [this]() {
            if(sysPara->status.selfCheckDone && (sysPara->status.reclaimTankstatus == 2 || sysPara->status.reclaimTankstatus == 6)) {
                m_MainWidget->setReclaimOpenBtnStatus(true);
            }
        };

        connect(manager_rfid, &RFIDManager::sig_inkCardProgressFinished, this, checkReclaimOpenBtn);
        connect(manager_rfid, &RFIDManager::sig_solventProgressFinished, this, checkReclaimOpenBtn);
    }
}

void InkJetPrinter::handleWarnInk()
{
    static bool logFlag_inkCard = 1; // 每次启动提示一次即可
    if(!sysPara->para.flagOfInkWarning){
        if(sysPara->status.statWarn & WARN_STATUS_INK_WARN)
            sysPara->status.inkWarningCnt++; // 累计警报10次就提示
        else {
            sysPara->status.inkWarningCnt = 0;
        }

        if(sysPara->status.inkWarningCnt >= DETECT_WARNING_TIME){
            sysPara->para.flagOfInkWarning = true;
            manager_rfid->setInkCardFirstPrompt(true);
            QString strCurDateTime = QDateTime::currentDateTime().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();
            }

            warningShow(1, 48);

            sysPara->saveParaToFile();
        }
    }
    else{

        if(logFlag_inkCard){
            logFlag_inkCard = 0;
            QString strDate = QString::number(sysPara->para.inkWarnDate);
            QString strTime = QString::number(sysPara->para.inkWarnTime);
            QString str1 = QString::number(strDate.mid(0,2).toInt()).rightJustified(2,'0');
            QString str2 = QString::number(strDate.mid(2,2).toInt()).rightJustified(2,'0');
            QString str3 = QString::number(strDate.mid(4,2).toInt()).rightJustified(2,'0');
            QString str4 = QString::number(strTime.mid(0,2).toInt()).rightJustified(2,'0');
            QString str5 = QString::number(strTime.mid(2,2).toInt()).rightJustified(2,'0');
            QString str6 = QString::number(strTime.mid(4,2).toInt()).rightJustified(2,'0');
            QString strDateTime = str1 + "-" + str2 + "-" + str3 + " " + str4 + ":" + str5 + ":" + str6;
            LogInfo::setRunStatusText(tr("ink Warning at: %1").arg(strDateTime));
            qDebug()<<"ink Warning at:"<<strDateTime;
        }
    }

    if(sysPara->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 | QIODevice::Truncate)){
                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(CARD_TYPE::INK);
        // 状态正常但是需要刷卡，说明此时先加的墨水，后面再刷卡
        if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN)
                && sysPara->RFIDPara.needInkCard){

            sysPara->RFIDPara.addedInk = true;

            sysPara->saveRFIDPara();
        }
    }

}

void InkJetPrinter::handleWarnSolvent()
{
    static bool logFlag_solventCard = 1; // 每次启动提示一次即可
    if(!sysPara->para.flagOfSolventWarning){
        if(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN)
            sysPara->status.solventWarningCnt++;
        else{
            sysPara->status.solventWarningCnt = 0;
        }

        if(sysPara->status.solventWarningCnt >= DETECT_WARNING_TIME){
            sysPara->para.flagOfSolventWarning = true;
            manager_rfid->setSolventCardFirstPrompt(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();
            }

            warningShow(2, 48);

            sysPara->saveParaToFile();
        }
    }
    else{
        if(logFlag_solventCard){
            logFlag_solventCard = 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.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 | QIODevice::Truncate)){
                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(CARD_TYPE::SOLVENT);
        // 如果溶剂报警，说明此时先加的溶剂，后面再刷卡
        if(!(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN)
                && sysPara->RFIDPara.needSolventCard){

            sysPara->RFIDPara.addedSolvent = true;
            sysPara->saveRFIDPara();
        }
    }

}
#endif

void InkJetPrinter::slt_showMsg(QString msg)
{
    static QList<QMessageBox*> msgPool;

    QMessageBox * msgBox = new QMessageBox(QMessageBox::NoIcon, tr("提示"), msg, QMessageBox::StandardButton::Ok);
    msgPool.push_back(msgBox);
    connect(msgBox, &QMessageBox::finished, [this, msgBox, &msgPool](){
        auto idx = msgPool.lastIndexOf(msgBox);
        if(idx != -1) {
            msgPool.removeAt(idx);
        }

        msgBox->deleteLater();
    });

    msgBox->show();

    if(msgPool.size() > 3) {
        msgPool.takeFirst()->deleteLater();
    }

    LogInfo::setRunStatusText(msg);
}

void InkJetPrinter::onDlgFileOpen(const QString& filename)
{
    QFileInfo fileInfo(filename);
    if(!fileInfo.exists() || !fileInfo.isFile()) {
        LogInfo::setRunStatusText(tr("File not found: %1").arg(filename));
        return;
    }

    loadWorkFileAndPreparePrint(filename);
}