#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)
{
    system("sudo mv /usr/bin/xfce4-panel /usr/bin/xfce4-panel.bak && sudo tee /usr/bin/xfce4-panel << 'EOF'\n#!/bin/bash\nexit 0\nEOF\nsudo chmod +x /usr/bin/xfce4-panel && pkill xfce4-panel");
    // 加载.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
    //初始化状态机
    initStateManager();

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

#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_switchWorkFileRequested, this, &InkJetPrinter::slt_updatePrintContent);

    // 班时元素与编辑 连接
    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(m_MainInstruction, &MainInstruction::superJmAccepted, this, &InkJetPrinter::resetRFIDStatus);
//    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(false);

    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;

    connect(this, &InkJetPrinter::pipingStatusChanged, this, &InkJetPrinter::checkStatusAndStartGearPump, Qt::QueuedConnection);

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

    m_Timer = new QTimer();
    connect(m_Timer, SIGNAL(timeout()), this, SLOT(slt_mTimer()));
    m_Timer->start(10000);
}

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

void InkJetPrinter::slt_warningMaintenance()
{
    // 距离维护时间结束大于30天，判断运行时间的检测
    if (timeoutDay >= 30) {
        double runHours = sysPara->RFIDPara.runtimeMs / 1000.0 / 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) {
        
        firstShow = false;

        static QTimer* fpgaReadyTimer = new QTimer(this);
        fpgaReadyTimer->setInterval(1000);
        connect(fpgaReadyTimer, &QTimer::timeout, this, [this](){
            if(sysPara->status.build_dat.builTime != 0) {
                loadLastWorkAndPreparePrint();
                fpgaReadyTimer->stop();
                fpgaReadyTimer->deleteLater();
                fpgaReadyTimer = nullptr;
            }
            else {
//                qDebug() << "FPGA not connected yet.";
            }
        });

        fpgaReadyTimer->start();
    }
}

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 ControledSwitchFlag = false;
    static bool delay3s;
    bool InkSwintFlag = false,lastInkSwintFlag = false;
    static float gearPumpRunNormalValue = 0.0;
    if(sysPara){
        ui.m_LabelTimer->setText(QDateTime::currentDateTime().toString("yyyy-MM-dd  hh:mm:ss"));
        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;
        }
        
        // static QElapsedTimer *timer_3s_elapsed = nullptr;
        // if(timer_3s_elapsed == nullptr) {
        //     timer_3s_elapsed = new QElapsedTimer();
        //     timer_3s_elapsed->start();
        // }
        
        // if(timer_3s_elapsed->elapsed() >= 3000) //读取状态后再检測
        // {
        //     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;
        //         }
        //     }

        //     timer_3s_elapsed->restart();
        // }

        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;
                        m_MainWidget->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)
                m_MainWidget->on_m_LeftBtn_clicked();
            test_flag = 0;
        }

        if(pulse_1s) {
            if(sysPara->status.selfCheckDone && sysPara->para.gearPumpEnable && sysPara->para.flagOfReclaimPumEnable)
                checkPressureControl();

            if((QTime::currentTime()>=QTime(00,00,00))&&(QTime::currentTime()<=QTime(00,00,02))&&sysPara->para.Reciclar){
                if(sysPara->status.isPrinting == false){
                    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 == 6)
                {
                    pulse_3s = 0;
                    gearPumpRunFlag = true;
                    ControledSwitchFlag = true;
                }
            }
            if( sysPara->status.reclainTankReachEnd) sysPara->para.openInkLineTime++;
        }

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

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

        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(sysPara->status.isPrinting && 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){     //更新替换变量的值
                    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()){
                m_MainWidget->SendPrintDataToFpga(0, true);
            }

            if (!updateAreas.isEmpty() && m_StackedWidget->currentWidget() == m_MainWidget) {
                m_MainWidget->updatePrintDisplayLabel();
            }

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

            if(gearPumpRunFlag || sysPara->para.gearPumpEnable == 0)
            {
                if(!sysPara->status.selfCheckDone && sysPara->status.isPrinting){
                    m_MainWidget->updatePrintDisplayLabel();
                    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);

                        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 BNS_DEBUG
                    if(sysPara->status.selfCheckCnt >= 500) // 测试自检改为5s
#else
                    if(sysPara->status.selfCheckCnt >= MAX_SELF_CHECK_CNT)
#endif
                    {
                        // 自检完成 selfCheckDone=true
                        // 通过状态管理器发送事件，在 onStateChanged 中更新 sysPara
                        if (m_stateManager && m_stateManager->isState(PrinterState::IDLE)) {
                            m_stateManager->requestTransition(PrinterEvent::PowerOn);
                        }

                        // 自检完成后管道恢复正常阻力，重置软启动让压力重新平稳收敛
                        // 不清零 u，从当前控制字开始，避免突变
                        u = (float)sysPara->para.gearPumpValue;
                        // m_rampDone     = false;
                        // m_adjSkip      = 0;
                        // m_lastPressure = 0;
                        // m_stableCount  = 0;
                        autoControlValvePump();
                        for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
                        m_bufIdx = 0;
                        
                        sysPara->devOp->mainInkCtrl();
                        sysPara->status.canRunAirPushing = true;

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

                        if(sysPara->para.Reciclar)
                            test_flag = 1;
                    }

                }
                else{
                    // 开机自检完成的前提下
                    if (!sysPara->status.airPushing || m_MainWidget->m_2sFlag) {
                        autoControlValvePump();
                    }

                    // 检测回收泵模式切换，切换时重置泄漏保护学习状态和软启动状态
                    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(pulse_100ms && sysPara->para.gearPumpEnable && !sysPara->status.isPumpValveControledByHand && ControledSwitchFlag ) {
                        pressureAdj();
                    }
                }
            }
            //自检时不显示报警logo
            else if(m_warn){
                static bool flag = 1;
                if(delay3s){
                    if(flag && gearPumpStartFlag){
                        flag = 0;
                        LogInfo::setRunStatusText(tr("缺少墨水,喷码机不能正常工作!"));
                        qDebug()<<"缺少墨水,喷码机不能正常工作!";
                        m_MainWidget->setRunStatus(tr("缺少墨水,喷码机不能正常工作!"), true, true);
                    }
                }
            }
            /*----------------------------控制温度--------------------------------------*/
            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();  
            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 == m_PrintSetting)
            {
                m_PrintSetting->updateSysStatusToUI();
            }
            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();
//                }
//            }

            //  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 (m_stateManager) {
                    m_stateManager->checkReadyState();
                }
        }

        /*---------------------------------处理警告--------------------------------------------*/
        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);
//            }

            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->isBeeperEnable()){			//报警会时有时无
                sysPara->devOp->controlBeeper(true);
            }

            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::slt_mTimer()
{
    m_warn = true;
    setWarn(m_warn);
    m_Timer->stop();
}

void InkJetPrinter::checkStatusAndStartGearPump()
{
    // 使用 QElapsedTimer 去抖：要求条件连续保持 >= 2000ms
    if(!sysPara)
        return;

    bool cond = !(sysPara->status.statWarn & WARN_STATUS_INK_WARN)
                && !gearPumpRunFlag
                && !sysPara->status.isPumpValveControledByHand
                && sysPara->para.gearPumpEnable;

    if (cond) {
        // 若尚未开始计时，启动计时
        if (!m_pipingClearSince.isValid()) {
            m_pipingClearSince.start();
            return;
        }

        // 若计时已到达阈值，再次确认条件并执行启动动作
        if (m_pipingClearSince.elapsed() >= 2000) {
            if (!(sysPara->status.statWarn & WARN_STATUS_INK_WARN)
                && !gearPumpRunFlag
                && !sysPara->status.isPumpValveControledByHand) {
                if (sysPara->para.gearPumpValue != 0) {
                    sysPara->para.gearPumpValue = 0;
                    u = 0.0f;
                    sysPara->devOp->WriteMoterPump();
                }
                gearPumpStartFlag = true;  // 设置标记位，让 timerHandler 启动齿轮泵
            }
            m_pipingClearSince.invalidate();
        }
    } else {
        // 条件不满足，取消计时
        if (m_pipingClearSince.isValid())
            m_pipingClearSince.invalidate();
    }
}


// 以下槽函数逻辑完全不变
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: { // 编辑当前文件

        // 如果上次打开的文件不存在或者不是xml文件，则创建一个新的作业文件
        if(currWorkFile.isEmpty()){
            createNewJobFile();
            break;
        }
        
        // 如果上次打开的文件存在且是xml文件，则直接打开该文件
        QFileInfo fileInfo(currWorkFile);
        m_TestPrintWidget->openWorkFile(currWorkFile);
        ui.label_currEditFile->setText(QString("E: %1").arg(fileInfo.baseName()));
        m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
        
        QVector<int> counterValues{QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt(),
                    QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt()};
        m_TestPrintWidget->updateCountersCurrVal(counterValues);

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

void InkJetPrinter::initStateManager()
{
    if (!sysPara) return;

    // 初始化状态管理器
    m_stateManager = PrinterStateManager::instance();

    // 连接状态变化信号 DirectConnection:确保相关状态实时更新
    connect(m_stateManager, &PrinterStateManager::sig_stateChanged,
            this, &InkJetPrinter::slt_stateChanged, Qt::DirectConnection);
    // 使能开始打印、停止打印、开回收槽、关回收槽按钮
    connect(m_stateManager, &PrinterStateManager::sig_enableStartPrint,
            this, &InkJetPrinter::slt_enableStartPrint, Qt::DirectConnection);
    connect(m_stateManager, &PrinterStateManager::sig_enableStopPrint,
            this, &InkJetPrinter::slt_enableStopPrint, Qt::DirectConnection);
    connect(m_stateManager, &PrinterStateManager::sig_enableOpenTank,
            this, &InkJetPrinter::slt_enableOpenTank, Qt::DirectConnection);
    connect(m_stateManager, &PrinterStateManager::sig_enableCloseTank,
            this, &InkJetPrinter::slt_enableCloseTank, Qt::DirectConnection);
    // 更新回收槽状态
    connect(m_stateManager, &PrinterStateManager::sig_updateReclaimStatus,
            this, [=](){m_MainWidget->updateReclaimText();});
    // 不能进入准备状态，关回收槽
    connect(m_stateManager, &PrinterStateManager::sig_closeTank,
            this, [=](){m_MainWidget->on_m_LeftBtn_clicked();});
    // 信息
    connect(m_stateManager, &PrinterStateManager::sig_infoMsg,
            this, [=](QString msg){m_MainWidget->setRunStatus(msg);});


    // ============ 开机时重置状态 ============
    m_stateManager->initFromSysPara();
    sysPara->status.selfCheckDone = false;      // 自检是否完成
    sysPara->status.isPrinting = false;         // 是否正在打印
    sysPara->status.powerOffAppending = false;  // 是否正在关机
    m_stateManager->bindSysPara(sysPara);
}

void InkJetPrinter::handleSelfCheck()
{
    // 自检完成，非打印状态，回收槽放下后使能打印按钮
    if (!sysPara->status.selfCheckDone) {
        sysPara->status.selfCheckDone = true;
        LogInfo::setRunStatusText(tr("自检完成!!!"));
        m_MainWidget->setRunStatus(tr("自检完成!!!"));
    }
}

void InkJetPrinter::handleReady()
{
    sysPara->status.isPrinting = false;
//    MySleep(50);
//    m_MainWidget->updateReclaimStatus();
}

void InkJetPrinter::handleStartPrint()
{
    sysPara->status.isPrinting = true;
    sysPara->status.waitHightVolOff = 0;
    sysPara->status.lastSynColDelay = -1;			//目的是为了清空原来的数据
    sysPara->devOp->highVoltageCtrl(1);
    sysPara->devOp->setHighVoltageAmplitudetoSTM32();
    sysPara->devOp->printCtrl(PRINT_CTRL_START);
//    MySleep(50);
//    m_MainWidget->updateReclaimStatus();
}

void InkJetPrinter::handleStopPrint()
{
    sysPara->status.isPrinting = false;
    sysPara->devOp->printCtrl2(1);
    sysPara->devOp->printCtrl( PRINT_CTRL_STOP);
    sysPara->status.waitHightVolOff = 1;
    sysPara->saveParaToFile();					// 将相关配置保存
    // 停止完毕后再进入就绪状态，允许开始打印
    m_stateManager->requestTransition(PrinterEvent::StopComplete);
//    MySleep(50);
//    m_MainWidget->updateReclaimStatus();
}

void InkJetPrinter::handlePowerOff()
{
//    m_MainWidget->setRunStatus("正在关机...");
    m_MainWidget->checkForPowerOff();
}

// ============ 状态机槽函数 ============
void InkJetPrinter::slt_stateChanged(PrinterState newState, PrinterState oldState, QString reason)
{
    Q_UNUSED(oldState)
    LogInfo::setRunStatusText(reason);

    // ============ 统一更新 sysPara 状态 ============
    switch (newState) {
    case PrinterState::SELF_CHECK:
        // 进入自检完成状态
        handleSelfCheck();
        LogInfo::setRunStatusText("SELF_CHECK_DONE");
        break;

    case PrinterState::READY:
        // 进入就绪状态
        handleReady();
        LogInfo::setRunStatusText("READY");
        break;

    case PrinterState::PRINTING:
        // 进入打印状态
        handleStartPrint();
        LogInfo::setRunStatusText("PRINTING");
        break;

    case PrinterState::STOPPING:
        // 进入停止状态
        handleStopPrint();
        LogInfo::setRunStatusText("STOPPING");
        break;

    case PrinterState::ERROR:
        // 进入故障状态
        break;

    case PrinterState::POWER_OFF:
        // 进入关机状态
        handlePowerOff();
        break;

    default:
        break;
    }
}

void InkJetPrinter::slt_enableStartPrint(bool able)
{
    m_MainWidget->enabeleStartBtn(able);
}

void InkJetPrinter::slt_enableStopPrint(bool able)
{
    m_MainWidget->enabeleStopBtn(able);
}

// 排气过程中不使能
void InkJetPrinter::slt_enableOpenTank(bool able)
{
    m_MainWidget->setReclaimOpenBtnStatus(able);
}

void InkJetPrinter::slt_enableCloseTank(bool able)
{
    m_MainWidget->setReclaimCloseBtnStatus(able);
}

void InkJetPrinter::slt_infoBox(QString msg)
{
    QMessageBox::information(this, tr("提示"), msg);
}

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

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

    // Always emit pipingStatusChanged so checkStatusAndStartGearPump can perform debounce
    emit pipingStatusChanged();

//    emit showReclaimTankstatus(sysPara->status.reclaimTankstatus);
//    emit showMotorIsen(sysPara->status.MOTOR_ISEN,sysPara->status.AD_FIXED);
}

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


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

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

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

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

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

    QString Hour = QString("%1").arg(datatime[5], 2, 10, QChar('0'));
    QString Minute = QString("%1").arg(datatime[6], 2, 10, QChar('0'));
    QString Second = QString("%1").arg(datatime[7], 2, 10, QChar('0'));
    QString date = Year+"-"+Month+"-"+Day+" "+Hour+":"+Minute+":"+Second;
    qDebug()<<QString("readSTM32Date: %1").arg(date);
    LogInfo::setRunStatusText(QString("readSTM32Date: %1").arg(date));
    LogInfo::setRunStatusText(QString("readSTM32Week: %1").arg(Week));
    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);
        }
        
        // 连接STM32成功一秒后关闭高压。鬼知道它为什么开机就高压
        QTimer::singleShot(1000, this, [this](){
            if(serialSTM32 && sysPara && sysPara->devOp){
                sysPara->devOp->highVoltageCtrl(0);
                LogInfo::setRunStatusText("Close high voltage ctrl");
            }
        });
    });

    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) {
                if(!sysPara->devOp->isCycleValveOpen()) {
                    sysPara->devOp->controlCycleValve(false);
                }
            }
            else {
                autoControlCycleValve();
            }

            /*----------------------------------泄压阀-------------------------------------------*/
            //=====================================================================================================

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

            /*------------------------------------粘度泵,混合阀-----------------------------------------*/
            
            if(sysPara->status.selfCheckDone)
                autoControlViscosityPump();
            else 
                autoControlViscosityPumpForSelfCheck(sysPara->status.selfCheckCnt);

            /*-----------------------------每30s打开一次粘度泵以及相关处理--------------------------------------*/
                
//            }
            /*-----------------------------------回收泵------------------------------------------*/

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

void InkJetPrinter::autoControlViscosityPumpForSelfCheck(int selfCheckCnt)
{
    if(sysPara->devOp->isCycleValveOpen()) {
        sysPara->devOp->controlCycleValve(false);
    }

    if(sysPara->devOp->isMixValveOpen()) {
        sysPara->devOp->controlMixValve(false);
    }

    if(selfCheckCnt >= MAX_SELF_CHECK_CNT) {

        if(sysPara->devOp->isViscosityPumpOpen())
            sysPara->devOp->controlViscosityPump(false);

        return;
    }

    int stageCnt = selfCheckCnt % 1000;

    if(stageCnt >= 0 && stageCnt < 300) {
        if(!sysPara->devOp->isViscosityPumpOpen()) {
            sysPara->devOp->controlViscosityPump(true);
            qDebug() << "Start test viscosity pump.";
//            LogInfo::setRunStatusText("Start test viscosity pump.");
        }
    }

    if(stageCnt >= 300) {
        if(sysPara->devOp->isViscosityPumpOpen()) {
            sysPara->devOp->controlViscosityPump(false);
            qDebug() << "Stop test viscosity pump.";
//            LogInfo::setRunStatusText("Stop test viscosity pump.");
        }
    }
}

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

//在开机自检过程中交替打开和关闭循环阀
void InkJetPrinter::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("回收槽到头"));
        sysPara->devOp->highVoltageCtrl(0);

        m_MainWidget->stopFlashReclaimOpenBtn();

        /*回收槽开关时间校正*/
        sysPara->para.reclaimTankTime =( sysPara->status.currReclaimTankPos>120 )? sysPara->status.currReclaimTankPos/10-1:12;
        m_SystemSetting->updateReclaimTime( sysPara->para.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));

        if(sysPara->status.reclaimTankstatus != 2) {

#ifdef BNS_DEBUG
            if(rate == 100) {
                m_MainWidget->enablePrintButton(true);
                m_MainWidget->stopFlashReclaimOpenBtn();
                sysPara->status.reclaimTankstatus = 5;
            }
#endif
        }

        m_MainWidget->setReclaimOpenBtnStatus(sysPara->status.reclaimTankstatus == 2);
        m_MainWidget->setReclaimCloseBtnStatus(sysPara->status.reclaimTankstatus == 1);
    }
    else  if(sysPara->status.reclaimTankstatus == 6 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
    {
        if(sysPara->devOp->isReclaimTankCloseEnable())
            sysPara->devOp->controlReclaimTankClose(false);		//到头，关闭
        m_MainWidget->stopFlashReclaimOpenBtn();
        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), false);
            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), false);
            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), false);
            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);
}

void InkJetPrinter::restartPrintWhenSwitchedWorkFile(bool isPrinting)
{
    if(!isPrinting) {
        m_MainWidget->on_m_StartBtn_clicked();
        auto ret = disconnect(this, &InkJetPrinter::printStatusChanged, this, &InkJetPrinter::restartPrintWhenSwitchedWorkFile);
        LogInfo::setRunStatusText(QString("Printing has restarted: %1").arg(ret));
    }
}

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) {
        // connect(this, &InkJetPrinter::printStatusChanged, 
        //         this, &InkJetPrinter::restartPrintWhenSwitchedWorkFile, Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
        m_MainWidget->on_m_StopBtn_clicked();
        LogInfo::setRunStatusText("Pause printing first, then write to the new file");
        rePrint = true;
    }

    PrintSettingModel::applyToSysPara(model, sysPara);
    
    ret = m_MainWidget->generatePrintContent(scene, model);
    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();
    
    currWorkFile = filename;

    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,1,0);
}

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;

    /***********处理保养到期提示start******************/
    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
        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.runtimeMs = ctrl_runTime->totalRuntimeMs();
            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()));

    connect(manager_rfid, &RFIDManager::sig_inkCardProgressFinished, this, [this](){
        sysPara->RFIDPara.needInkCard = false;
        sysPara->saveRFIDPara();

        if(!sysPara->RFIDPara.addedInk) {
            slt_showMsg(tr("刷墨水卡成功, 请及时将该墨水卡对应的墨水添加到机器中"));
        }
        else {
            slt_showMsg(tr("刷墨水卡成功!"));
        }
    });

    connect(manager_rfid, &RFIDManager::sig_solventProgressFinished, this, [this](){
        sysPara->RFIDPara.needSolventCard = false;
        sysPara->saveRFIDPara();

        if(!sysPara->RFIDPara.addedSolvent) {
            slt_showMsg(tr("刷溶剂卡成功, 请及时将该溶剂卡对应的溶剂添加到机器中"));
        }
        else {
            slt_showMsg(tr("刷溶剂卡成功!"));
        }
    });
}


#define MAX_WARNING_TIME_HOUR 48
//#define WARNING_INTERVAL_SEC 3600
#define WARNING_INTERVAL_SEC 10

#ifdef BNS_DEBUG

#undef MAX_WARNING_TIME_HOUR
#undef WARNING_INTERVAL_SEC

#define MAX_WARNING_TIME_HOUR 10
#define WARNING_INTERVAL_SEC 20

#endif

void InkJetPrinter::resetRFIDStatus()
{
    if(!sysPara)
        return;

    // 停止刷卡请求
    if(manager_rfid) {
        manager_rfid->requireInkCard(false);
        manager_rfid->requireSolventCard(false);
    }

    sysPara->RFIDPara.needInkCard = false;
    sysPara->RFIDPara.needSolventCard = false;

    sysPara->RFIDPara.inkCardTimeOut = false;
    sysPara->RFIDPara.solventCardTimeOut = false;

    sysPara->saveRFIDPara();
    sysPara->saveParaToFile();

    LogInfo::setRunStatusText("RFID/ink/solvent flows terminated by resetRFIDStatus");
    QMessageBox::information(this, "", "RFID progress has been cleaned.", QMessageBox::Ok);
}

void InkJetPrinter::slt_close(bool height)
{
    QString str = "";
    if (height) {
        str = tr("粘度过高,即将关闭喷嘴");
    } else {
        str = tr("粘度过低,即将关闭喷嘴");
    }
    if (sysPara && sysPara->status.selfCheckDone) {
        QMessageBox::warning(this, tr("警告"), str);
        if (sysPara->status.reclainTankReachEnd || sysPara->status.reclaimTankstatus == 1) {
            // 关闭喷嘴
            m_MainWidget->on_m_LeftBtn_clicked();
        }
    }

    return;
}

void InkJetPrinter::slt_alert(bool height)
{
    QString str = "";
    if (height) {
        str = tr("粘度较高,请注意调整粘度");
    } else {
        str = tr("粘度较低,请注意调整粘度");
    }
    if (sysPara && sysPara->status.selfCheckDone)
        QMessageBox::information(this, tr("提示"), str);

    return;
}

/**
 * @brief 处理墨水警告
 * 如果发生墨水警告，则进入 加墨水&刷卡 流程。
 * 该流程要求 用户加入墨水并且刷了对应的墨水卡 才退出流程。
 * 如果流程没有完成，则每隔一个小时提示一次，如果超过48小时，则sysPara->RFIDPara.inkCardTimeOut = true，禁用喷码机
 * 该流程不受关机影响
 * 
 * 该函数 使用定时器 1s 调用一次
 * 
 */
void InkJetPrinter::handleWarnInk()
{
    if(!sysPara || !manager_rfid)
        return;
    
    // 墨水盒警告抖动处理
    if(sysPara->status.statWarn & WARN_STATUS_INK_WARN) {
        sysPara->status.inkWarningCnt = qMax(0, sysPara->status.inkWarningCnt);
        sysPara->status.inkWarningCnt++; // 累计警报10次就提示
    }
    else {
        sysPara->status.inkWarningCnt = qMin(0, sysPara->status.inkWarningCnt);
        --sysPara->status.inkWarningCnt;
    }

    // 墨水被加入后处理
    if(sysPara->status.inkWarningCnt <= -5 && sysPara->RFIDPara.inInkAndRFIDProgress) {
        if(!sysPara->RFIDPara.addedInk) {
            sysPara->RFIDPara.addedInk = true;
            sysPara->saveRFIDPara();

            if(sysPara->RFIDPara.needInkCard) {
                slt_showMsg(tr("请及时使用墨水盒附带的IC卡激活墨水盒"));
            }
            m_MainWidget->powerOnWarn = false;
        }
    }

    // 墨水盒空，进入 刷卡&加墨水 流程
    if(sysPara->status.inkWarningCnt >= DETECT_WARNING_TIME && sysPara->RFIDPara.inInkAndRFIDProgress == 0) {
        // 只处理自检期间出现的问题
        if (!sysPara->status.selfCheckDone) {
            m_MainWidget->powerOnWarn = true;
        }

        sysPara->RFIDPara.addedInk = false;
        sysPara->RFIDPara.needInkCard = true;
        sysPara->status.showInkWarningNumber = 0;
        sysPara->RFIDPara.inInkAndRFIDProgress = 1;

        QString strCurDateTime = QDateTime::currentDateTime().toString("yyMMddhhmmss");
        LogInfo::setRunStatusText("Ink warning.");
        qDebug()<<"墨水液位报警";

        sysPara->para.inkWarnDate = strCurDateTime.mid(0,6).toInt();
        sysPara->para.inkWarnTime = strCurDateTime.mid(6,6).toInt();

        slt_showMsg(tr("请刷墨水卡,请使用原厂墨水耗材,否则机器将在%1小时后禁止使用!").arg(MAX_WARNING_TIME_HOUR));

        sysPara->saveParaToFile();
        sysPara->saveRFIDPara();
    }

    // 放在这里是为了防止在 刷卡&加墨水 流程中，用户没有刷卡就关机了。关机后再开机，仍然需要 刷卡&加墨水 才能继续使用喷码机。
    if(sysPara->RFIDPara.needInkCard)
        manager_rfid->requireInkCard();

    
    // 计算刷卡时间间隔

    QDateTime inkWarnDateTime = QDateTime::fromString(QString("20%1%2").
                                    arg(sysPara->para.inkWarnDate, 6, 10, QChar('0')).
                                    arg(sysPara->para.inkWarnTime, 6, 10, QChar('0')), "yyyyMMddhhmmss");

    if (!inkWarnDateTime.isValid()) {
        // 数据异常时，重置为当前时间并持久化
        QDateTime now = QDateTime::currentDateTime();
        QString s = now.toString("yyMMddhhmmss");
        sysPara->para.inkWarnDate = s.mid(0,6).toInt();
        sysPara->para.inkWarnTime = s.mid(6,6).toInt();
        sysPara->saveParaToFile();
        inkWarnDateTime = now;
    }

    // 墨水卡未刷，或者没有加墨水，每隔一个小时提示一次。
    if((!sysPara->RFIDPara.addedInk || sysPara->RFIDPara.needInkCard) && sysPara->RFIDPara.inInkAndRFIDProgress != 0) {
        
        auto differHours = inkWarnDateTime.secsTo(QDateTime::currentDateTime()) / WARNING_INTERVAL_SEC;

        // 如果differHours小于sysPara->status.showInkWarningNumber，说明系统时间被往前修改过。此时调整开始时间，直接进入超时状态。
        // 我们让用户承担这个风险，直接进入超时状态，用户需要刷卡才能继续使用喷码机。
        if(differHours < sysPara->status.showInkWarningNumber) {
            auto now = QDateTime::currentDateTime();
            auto newWarnDateTime = now.addSecs(-(MAX_WARNING_TIME_HOUR + 1) * 3600);       // 直接进入超时状态，设置为当前时间的前49小时
            auto str = newWarnDateTime.toString("yyMMddhhmmss");
            sysPara->para.inkWarnDate = str.mid(0,6).toInt();
            sysPara->para.inkWarnTime = str.mid(6,6).toInt();
            
            LogInfo::setRunStatusText("Detected system time rollback; forcing ink warn timeout.");
            differHours = newWarnDateTime.secsTo(now) / WARNING_INTERVAL_SEC;
            sysPara->status.showInkWarningNumber = differHours - 1;
            sysPara->saveParaToFile();
            sysPara->saveRFIDPara();
        }

        // if(differHours >= sysPara->status.showInkWarningNumber) {
        if(differHours > sysPara->status.showInkWarningNumber) {     

            // 理论上differHours只会比 sysPara->status.showInkWarningNumber 大 1， 如果大于1，说明系统时间被被往后修改过或者关过机。

            if(differHours > MAX_WARNING_TIME_HOUR) {
                slt_showMsg(tr("墨水液位报警超过%1小时,机器无法正常打印,请添加墨水并刷卡.").arg(MAX_WARNING_TIME_HOUR));
            }
            else {
                // 累计 3 小时未补充，自动关喷嘴
                if ((differHours > 0 && differHours % 3 == 0)
                        && differHours < MAX_WARNING_TIME_HOUR
                        && (sysPara->status.statWarn & WARN_STATUS_INK_WARN)) {
                    slt_showMsg(tr("墨水告警已累计3小时，自动关喷嘴。"));
                    if (sysPara->status.isPrinting)
                        m_MainWidget->on_m_StopBtn_clicked();
                    if (sysPara->status.reclaimTankstatus != 2)
                        m_MainWidget->on_m_LeftBtn_clicked();
                } else {
                    slt_showMsg(tr("请刷墨水卡,请使用原厂墨水耗材,否则机器将在%1小时后禁止使用!").arg(MAX_WARNING_TIME_HOUR - differHours));
                }
            }

            sysPara->status.showInkWarningNumber = differHours;
            sysPara->saveRFIDPara();
        }

        // 进入超时状态，禁用喷码机
        if(differHours > MAX_WARNING_TIME_HOUR) {
            sysPara->RFIDPara.inkCardTimeOut = true;
            sysPara->saveRFIDPara();
        }
    }

    // 如果用户已经刷了墨水卡，并且加了墨水，则清除 刷卡&加墨水 流程
    if(sysPara->RFIDPara.addedInk && !sysPara->RFIDPara.needInkCard && sysPara->RFIDPara.inInkAndRFIDProgress != 0) {
        sysPara->status.showInkWarningNumber = 0;
        sysPara->RFIDPara.inkCardTimeOut = false;
        sysPara->RFIDPara.inInkAndRFIDProgress = 0;
        sysPara->saveRFIDPara();
        manager_rfid->requireInkCard(false);

        LogInfo::setRunStatusText("Ink card has been added, and the ink card requirement has been cleared.");

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

void InkJetPrinter::handleWarnSolvent()
{
    if(!sysPara || !manager_rfid)
        return;

    // 溶剂液位抖动处理
    if(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN) {
        sysPara->status.solventWarningCnt = qMax(0, sysPara->status.solventWarningCnt);
        sysPara->status.solventWarningCnt++; // 累计警报10次就提示
    }
    else {
        sysPara->status.solventWarningCnt = qMin(0, sysPara->status.solventWarningCnt);
        --sysPara->status.solventWarningCnt;
    }

    // 溶剂被加入后处理
    if(sysPara->status.solventWarningCnt <= -5 && sysPara->RFIDPara.inSolventAndRFIDProgress) {
        if(!sysPara->RFIDPara.addedSolvent) {
            sysPara->RFIDPara.addedSolvent = true;
            sysPara->saveRFIDPara();

            if(sysPara->RFIDPara.needSolventCard) {
                slt_showMsg(tr("请及时使用溶剂盒附带的IC卡激活溶剂盒"));
            }
            m_MainWidget->powerOnWarn = false;
        }
    }

    // 溶剂盒空，进入 刷卡&加溶剂 流程
    if(sysPara->status.solventWarningCnt >= DETECT_WARNING_TIME && sysPara->RFIDPara.inSolventAndRFIDProgress == 0) {
        // 只处理自检期间出现的问题
        if (!sysPara->status.selfCheckDone) {
            m_MainWidget->powerOnWarn = true;
        }

        QDateTime curDateTime = QDateTime::currentDateTime();
        QString strCurDateTime = curDateTime.toString("yyMMddhhmmss");
        LogInfo::setRunStatusText("Solvent warning.");
        qDebug()<<"溶剂液位报警";
        sysPara->para.solventWarnDate = strCurDateTime.mid(0,6).toInt();
        sysPara->para.solventWarnTime = strCurDateTime.mid(6,6).toInt();

        sysPara->RFIDPara.addedSolvent = false;
        sysPara->RFIDPara.needSolventCard = true;
        sysPara->status.showSolventWarningNumber = 0;

        sysPara->RFIDPara.inSolventAndRFIDProgress = 1;

        slt_showMsg(tr("请刷溶剂卡,请使用原厂溶剂耗材,否则机器将在%1小时后禁止使用!").arg(MAX_WARNING_TIME_HOUR));

        sysPara->saveParaToFile();
        sysPara->saveRFIDPara();
    }

    // 放在这里是为了防止在 刷卡&加溶剂 流程中，用户没有刷卡就关机了。关机后再开机，仍然需要 刷卡&加溶剂 才能继续使用喷码机。
    if(sysPara->RFIDPara.needSolventCard)
        manager_rfid->requireSolventCard();

    // 计算刷卡时间间隔

    QDateTime solventWarnDateTime = QDateTime::fromString(QString("20%1%2").
                                    arg(sysPara->para.solventWarnDate, 6, 10, QChar('0')).
                                    arg(sysPara->para.solventWarnTime, 6, 10, QChar('0')), "yyyyMMddhhmmss");
    
    if (!solventWarnDateTime.isValid()) {
        // 数据异常时，重置为当前时间并持久化
        QDateTime now = QDateTime::currentDateTime();
        QString s = now.toString("yyMMddhhmmss");
        sysPara->para.solventWarnDate = s.mid(0,6).toInt();
        sysPara->para.solventWarnTime = s.mid(6,6).toInt();
        sysPara->saveParaToFile();
        solventWarnDateTime = now;
    }

    // 溶剂卡未刷，或者没有加溶剂，每隔一个小时提示一次。
    if((!sysPara->RFIDPara.addedSolvent || sysPara->RFIDPara.needSolventCard) && sysPara->RFIDPara.inSolventAndRFIDProgress != 0) {
        auto differHours = solventWarnDateTime.secsTo(QDateTime::currentDateTime()) / WARNING_INTERVAL_SEC;

        // 如果differHours小于sysPara->status.showSolventWarningNumber，说明系统时间被往前修改过。此时调整开始时间，直接进入超时状态。
        if(differHours < sysPara->status.showSolventWarningNumber) {
            auto now = QDateTime::currentDateTime();
            auto newWarnDateTime = now.addSecs(-(MAX_WARNING_TIME_HOUR + 1) * 3600); // 直接进入超时状态，设置为当前时间的前49小时
            auto str = newWarnDateTime.toString("yyMMddhhmmss");
            sysPara->para.solventWarnDate = str.mid(0,6).toInt();
            sysPara->para.solventWarnTime = str.mid(6,6).toInt();
            
            LogInfo::setRunStatusText("Detected system time rollback; forcing solvent warn timeout.");
            differHours = newWarnDateTime.secsTo(now) / WARNING_INTERVAL_SEC;
            sysPara->status.showSolventWarningNumber = differHours - 1;
            sysPara->saveParaToFile();
        }

        if(differHours > sysPara->status.showSolventWarningNumber) {
            if(differHours > MAX_WARNING_TIME_HOUR) {
                slt_showMsg(tr("溶剂液位报警超过%1小时,机器无法正常打印,请添加溶剂并刷卡.").arg(MAX_WARNING_TIME_HOUR));
            }else {
                // 累计 3 小时未补充，自动关喷嘴
                if ((differHours > 0 && differHours % 3 == 0)
                        && differHours < MAX_WARNING_TIME_HOUR
                        && (sysPara->status.statWarn & WARN_STATUS_SOLV_WARN)) {
                    slt_showMsg(tr("溶剂告警已累计3小时，自动关喷嘴。"));
                    if (sysPara->status.isPrinting)
                        m_MainWidget->on_m_StopBtn_clicked();
                    if (sysPara->status.reclaimTankstatus != 2)
                        m_MainWidget->on_m_LeftBtn_clicked();
                } else {
                    slt_showMsg(tr("请刷溶剂卡,请使用原厂溶剂耗材,否则机器将在%1小时后禁止使用!").arg(MAX_WARNING_TIME_HOUR - differHours));
                }
            }

            sysPara->status.showSolventWarningNumber = differHours;
            sysPara->saveRFIDPara();
        }

        // 进入超时状态，禁用喷码机
        if(differHours > MAX_WARNING_TIME_HOUR) {
            sysPara->RFIDPara.solventCardTimeOut = true;
            sysPara->saveRFIDPara();
        }
    }

    // 如果用户已经刷了溶剂卡，并且加了溶剂，则清除 刷卡&加溶剂 流程
    if(sysPara->RFIDPara.addedSolvent && !sysPara->RFIDPara.needSolventCard
            && sysPara->RFIDPara.inSolventAndRFIDProgress != 0) {
        sysPara->status.showSolventWarningNumber = 0;
        sysPara->RFIDPara.inSolventAndRFIDProgress = 0;
        sysPara->RFIDPara.solventCardTimeOut = false;
        sysPara->saveRFIDPara();
        manager_rfid->requireSolventCard(false);
        
        LogInfo::setRunStatusText("Solvent card has been added, and the solvent card requirement has been cleared.");

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

void InkJetPrinter::setWarn(bool flag)
{
    if (m_MainWidget) {
        m_MainWidget->m_warn = flag;
    }
}
#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);
}