#include "SystemManage.h"
#include "ui_SystemManage.h"
#include <QFileDialog>
#include <QList>
#include <QUrl>
#include <QMessageBox>
#include <QProcess>
#include <QDebug>
#include <QTime>
#include <QTimer>
#include <QDate>
#include "SysPara.h"
#include "DevOp.h"
#include "myinclude.h"
#include "Public.h"
#include "dlginputaddr.h"
#include "qprogressdialog.h"
#include<string>
#include<iostream>
#include <unistd.h>
//#include "LogInfo.h"
#include <QDirIterator>

#define RECLAIN_TANK_TEST_MAX_COUNT     10
enum ReclainTankTestEnum{ReclainTankTest_eNotStart,ReclainTankTest_eOpenning,ReclainTankTest_eOpened,ReclainTankTest_eClosing,ReclainTankTest_Closed};
SystemManage::SystemManage(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::SystemManage),timeDia(0)
{
    ui->setupUi(this);

    if (sysPara == nullptr) {
        sysPara = SysPara::ins();
    }

    timeDia.hide();
    setPumpValveBottonEnable(false);
    ui->pushButtonCompressPump->setEnabled(false);
    ui->pushButtonMainInkPump->setEnabled(false);
    ui->pushButtonReleaseValve->setEnabled(false);
    ui->pushButtonReclaimPump->setEnabled(false);

    ui->pushButtonGearPump->setEnabled(true);
    ui->pushButtonGearPumpOff->setEnabled(true);
    ui->labelControlByHand->setText("手动");

    ui->pushButtonPushAir->setEnabled(true);		//2019-10-23 排气按钮始终使能 by kun
    timer = new QTimer();
    connect(timer, SIGNAL(timeout()), this, SLOT(timerHandler()));
    timer2 = new QTimer();
    connect(timer2, SIGNAL(timeout()), this, SLOT(timerHandler2()));

    autoCleanTimer = new QTimer();
    connect(autoCleanTimer, SIGNAL(timeout()), this, SLOT(autoCleanTimerHandler()));
    connect(this,SIGNAL(autoCleanStart(void)),this,SLOT(onAutoCleanStart(void)));

    reclaimTankTestTimer = new QTimer();
    connect(reclaimTankTestTimer, SIGNAL(timeout()), this, SLOT(reclainTankTestHandler()));


    //烧录FPGA所写
    programFPGATimer = new QTimer();
    connect(programFPGATimer, SIGNAL(timeout()), this, SLOT(programFPGAProcess()));
    programFPGADialog = new UpdateFPGA("/home/plg/upgrade_file_new.py");
    connect(programFPGADialog,SIGNAL(upgradeFPGAFinished()),this,SIGNAL(restartSerial()));
    //----------------------------------------------------------------------------------


    /***2019/10/22 start*****/
    inkcloseCountTimer = new QTimer();
    connect(inkcloseCountTimer, SIGNAL(timeout()), this, SLOT(inkcloseCountHandler()));
    inkcloseCountTimer->start(1000);
    /****2019/10/22 end****/

    /***2019/10/23 start*****/
    MainnkCmpSepetalTimer = new QTimer();
    connect(MainnkCmpSepetalTimer, SIGNAL(timeout()), this, SLOT(MainInkCmpSepetalHandler()));
    /***2019/10/23 *****/

    dialogUpateMm =new DialogAuthorization;
    connect(dialogUpateMm,SIGNAL(accepted()),this,SLOT(ondialogAuthorizationAccepted()));

    dialogTimeSetAuthorization = new DialogAuthorization;
    connect(dialogTimeSetAuthorization,SIGNAL(accepted()),this,SLOT(on_dialogTimeSetAuthorizationAccepted()));

    dialogSysUpdateAuthorization = new DialogAuthorization;
    connect(dialogSysUpdateAuthorization,SIGNAL(accepted()),this,SLOT(on_dialogSysUpdateAuthorizationAccepted()));
    dialogFactorySetAuthorization = new DialogAuthorization;
    connect(dialogFactorySetAuthorization,SIGNAL(accepted()),this,SLOT(on_dialogFactorySetAuthorizationAccepted()));
    dlgInputAddr_TimeSet = new DlgInputAddr(parent);
    dlgInputAddr_TimeSet->GetAddr();
    dlgInputAddr_TimeSet->vpnConnect();
    dlgInputAddr_TimeSet->hide();

    connect(ui->spinBoxGearPumpValue,SIGNAL(valueChanged(int)),this,SLOT(updateGearPumpValue(int)));
    ui->pushButtonAutoClean->setEnabled(true);
    //       ui->pushButtonFactorySetting->setDisabled(true);
    ui->labelControlByHand->setText(tr("自动"));
    //       ui->pushButtonMotorTest->hide();

    ui->pushButton_EnvConf->setVisible(false);

    connect(ui->closeBtn, &QPushButton::clicked, this, &SystemManage::buttonClickedSlot);
    applyStyleSheet();
}

SystemManage::~SystemManage()
{
    delete ui;
}

void SystemManage::buttonClickedSlot()
{
    QPushButton* btn = qobject_cast<QPushButton*>(sender());
    if (btn == ui->closeBtn)
    {
        emit sendButtonClickedSignal(1);
    }

}

void SystemManage::bindDlgInputAddr(DlgInputAddr *dlgInputAddr)
{
    dlgInputAddr_TimeSet = dlgInputAddr;
    dlgInputAddr_TimeSet->GetAddr();
    dlgInputAddr_TimeSet->vpnConnect();
    dlgInputAddr_TimeSet->hide();
}

void SystemManage::on_pushButtonReleaseValve_pressed()
{
    if(sysPara){
        sysPara->devOp->controlReleaseValve(!sysPara->devOp->isReleaseValveOpen());
        ui->labelCompressPump->setText(sysPara->devOp->isReleaseValveOpen()?tr("开"):tr("关"));
        sysPara->devOp->pumpValveCtrl();
    }
}
void SystemManage::on_pushButtonCompressPump_pressed()
{
    if(sysPara){
        sysPara->devOp->controlCompressPump(!sysPara->devOp->isCompressPumpOpen());
                ui->labelCompressPump->setText(sysPara->devOp->isCompressPumpOpen()?tr("开"):tr("关"));
    }
}

void SystemManage::on_pushButtonCycleValve_pressed()
{
    if(sysPara){
        sysPara->devOp->controlCycleValve(!sysPara->devOp->isCycleValveOpen());
                ui->labelCycleValve->setText(sysPara->devOp->isCycleValveOpen()?tr("开"):tr("关"));
    }
}

void SystemManage::updateGearPumpValue(int)
{
    if(sysPara->status.isPumpValveControledByHand)
    {
        if(sysPara->para.gearPumpEnable)
        {
            ui->pushButtonGearPump->setEnabled(true);
        }
    }
}

void SystemManage::on_pushButtonGearPump_pressed()
{
    ui->pushButtonGearPump->setEnabled(false);
    sysPara->para.gearPumpValue = ui->spinBoxGearPumpValue->value();
    sysPara->devOp->WriteMoterPump();
    ui->pushButtonGearPumpOff->setEnabled(true);
}

void SystemManage::on_pushButtonInkValve_pressed()
{
    if(sysPara){
        //2019/10/22
        //2019/11/20
        //开供墨阀之前要判断回收泵有没有开，没开就提前打开;手动模式下，不需要提前开回收泵
        if((!sysPara->devOp->isInkValveOpen()) && (!sysPara->devOp->isReclaimPumpOpen()) && (!sysPara->status.isPumpValveControledByHand))
        {
            sysPara->devOp->controlReclaimPump(true, false); // 回收泵开
        }
        sysPara->devOp->controlInkValve(!sysPara->devOp->isInkValveOpen());
        sysPara->devOp->controlInkValvePWM(!sysPara->devOp->isInkValveOpen1());
        ui->labelInkValve->setText(sysPara->devOp->isInkValveOpen1()?tr("开"):tr("关"));
    }
}

void SystemManage::on_pushButtonMainInkPump_pressed()
{
    if(sysPara){
        sysPara->devOp->controlMainInkPump(!sysPara->devOp->isMainInkPumpOpen());
                ui->labelMainInkPump->setText(sysPara->devOp->isMainInkPumpOpen()?tr("开"):tr("关"));
        sysPara->devOp->mainInkCtrl();
    }
}

void SystemManage::on_pushButtonMixValve_pressed()
{
    if(sysPara){
        sysPara->devOp->controlMixValve(!sysPara->devOp->isMixValveOpen());
                ui->labelMixValve->setText(sysPara->devOp->isMixValveOpen()?tr("开"):tr("关"));
    }
}

void SystemManage::on_pushButtonReclaimPump_pressed()
{
    if(sysPara){
        sysPara->devOp->controlReclaimPump(!sysPara->devOp->isReclaimPumpOpen(),false);

        // 无意义的设置，因为设备状态不会立马响应 byons@2026年4月24日
        // ui->labelReclaimPump->setText(sysPara->devOp->isReclaimPumpOpen()?tr("开"):tr("关"));
    }
}

void SystemManage::on_pushButtonViscosityPump_pressed()
{
    if(sysPara){
        sysPara->devOp->controlViscosityPump(!sysPara->devOp->isViscosityPumpOpen());
        ui->labelViscosityPump->setText(sysPara->devOp->isViscosityPumpOpen()?tr("开"):tr("关"));
    }
}


void SystemManage::setPumpValveBottonEnable(bool enable){
    if(sysPara)
    {
        if(sysPara->para.gearPumpEnable)
        {
            ui->pushButtonCompressPump->setEnabled(false);
            ui->pushButtonMainInkPump->setEnabled(false);
            ui->pushButtonReleaseValve->setEnabled(false);
            ui->pushButtonReclaimPump->setEnabled(enable);
        }
        else
        {
            ui->pushButtonCompressPump->setEnabled(enable);
            ui->pushButtonMainInkPump->setEnabled(enable);
            ui->pushButtonReleaseValve->setEnabled(enable);
            ui->pushButtonReclaimPump->setEnabled(enable);
        }
    }
    ui->pushButtonCycleValve->setEnabled(enable);
    ui->pushButtonInkValve->setEnabled(enable);

    ui->pushButtonMixValve->setEnabled(enable);

    //ui->pushButtonReclaimTankClose->setEnabled(enable);
    //ui->pushButtonReclaimTankOpen->setEnabled(enable);

    ui->pushButtonViscosityPump->setEnabled(enable);
    //ui->pushButtonCleanUP->setEnabled(enable);
    ui->pushButtonAutoClean->setEnabled(enable);
//    ui->pushButtonMotorTest->setEnabled(enable);
    ui->pushButtonPushAir->setEnabled(enable);
    if(sysPara)
    {
        if(sysPara->para.gearPumpEnable)
        {
            ui->pushButtonGearPump->setEnabled(enable);
            ui->pushButtonGearPumpOff->setEnabled(enable);
        }
        else
        {
           ui->pushButtonGearPump->setEnabled(false);
           ui->pushButtonGearPumpOff->setEnabled(false);
        }
        if(enable)
        {
            sysPara->para.gearPumpValue = 0;
            sysPara->devOp->WriteMoterPump();
        }
        else
        {
            sysPara->para.gearPumpValue = 300;
            sysPara->devOp->WriteMoterPump();
        }
    }

    if(enable){
        if(sysPara){
            sysPara->devOp->controlCompressPump(false);
            sysPara->devOp->controlCycleValve(true);
            sysPara->devOp->controlInkValve(false);
            sysPara->devOp->controlInkValvePWM(false);
            sysPara->devOp->controlMainInkPump(false);
            sysPara->devOp->controlMixValve(false);
            sysPara->devOp->controlReclaimPump(true,true);
            sysPara->devOp->controlViscosityPump(false);
            sysPara->devOp->controlReleaseValve(false);
            timer->start(2000);
        }
    }

}


void SystemManage::on_pushButtonControlByHand_pressed()
{
    if(sysPara){
        if(!sysPara->status.isPumpValveControledByHand){
            QMessageBox::StandardButton ret;
            ret = QMessageBox::warning(this, tr("警告"),
                                       tr("是否确认进入手动模式?"),
                                       QMessageBox::Ok | QMessageBox::Cancel);
            if (ret != QMessageBox::Ok){
                return;
            }else
            {
                qDebug()<<"进入手动模式";
               //qDebug()<<"disable inkcloseCountTimer";
                if(inkcloseCountTimer->isActive())      	inkcloseCountTimer->stop();
            }
        }
        else {
            QMessageBox::StandardButton ret;
            ret = QMessageBox::warning(this, tr("警告"),
                                       tr("请先确认已经关闭回收槽，确认进入自动模式?"),
                                       QMessageBox::Ok | QMessageBox::Cancel);
            if (ret != QMessageBox::Ok){

                return;
            }else
            {
                qDebug()<<"进入自动模式";
               // qDebug()<<"active inkcloseCountTimer";
                inkcloseCountTimer->start(1000);
            }
        }
        if(timer2->isActive())
            timer2->stop();
        sysPara->status.isPumpValveControledByHand = !sysPara->status.isPumpValveControledByHand;
        setPumpValveBottonEnable(sysPara->status.isPumpValveControledByHand);
        ui->pushButtonPushAir->setEnabled(true);		//2019-10-20 自动还是手动模式，排气按钮都要使能 by kun
        ui->labelControlByHand->setText(sysPara->status.isPumpValveControledByHand?tr("手动"):tr("自动"));
        sysPara->devOp->mainInkCtrl();
        emit enableReclaimButton(!sysPara->status.isPumpValveControledByHand);
        qDebug()<<"isPumpValveControledByHand:"<<sysPara->status.isPumpValveControledByHand;
        qDebug()<<"手动控制泵阀";
    }
}

void SystemManage::on_pushButtonReclaimTankOpen_pressed()
{
    if(sysPara){
        if(!sysPara->para.isCheckMagnet)
        {
            if(!(sysPara->status.statWarn & WARN_STATUS_HDINT)){
                            QMessageBox::warning(this, tr("警告"),
                                                 tr("请先移开喷头盖!"));
                return ;
            }
        }
        sysPara->devOp->controlReclaimTankOpen(!sysPara->devOp->isReclaimTankOpenEnable());
        ui->labelReclaimTankOpen->setText(sysPara->devOp->isReclaimTankOpenEnable()?tr("启动"):tr("停止"));
        sysPara->devOp->highVoltageCtrl(0);
        sysPara->status.reclainOpenAppending = true;
        sysPara->status.reclainCloseAppending = false;
        sysPara->status.currReclaimOperationCnt = 0;
        sysPara->status.reclainTankReachEnd = false;
    }
}

void SystemManage::on_pushButtonReclaimTankClose_pressed()
{
    if(sysPara){
        if(!sysPara->para.isCheckMagnet)
        {
            if(!(sysPara->status.statWarn & WARN_STATUS_HDINT)){
                QMessageBox::warning(this, tr("警告"),
                                     tr("请先移开喷头盖!"));
                return ;
            }
        }
        sysPara->devOp->controlReclaimTankClose(!sysPara->devOp->isReclaimTankCloseEnable());
        ui->labelReclaimTankClose->setText(sysPara->devOp->isReclaimTankCloseEnable()?tr("启动"):tr("停止"));
        sysPara->devOp->highVoltageCtrl(0);
        sysPara->status.reclainOpenAppending = false;
        sysPara->status.reclainCloseAppending = true;
        sysPara->status.currReclaimOperationCnt = 0;
        sysPara->status.reclainTankReachEnd = false;
    }
}
#include <time.h>
void adjustdate(int year, int mon, int mday, int hour, int min, int sec) {
    time_t t;
    struct tm nowtime;
    nowtime.tm_sec = sec;      // Seconds.[0-60]       (1       leap       second)
    nowtime.tm_min = min;      // Minutes.[0-59]
    nowtime.tm_hour = hour;     //  Hours.   [0-23]
    nowtime.tm_mday = mday;     //  Day.[1-31]
    nowtime.tm_mon = mon - 1;    //   Month.   [0-11]
    nowtime.tm_year = year - 1900;  //     Year-       1900.
    nowtime.tm_isdst = -1;      // DST.[-1/0/1]
    t = mktime(&nowtime);

#if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 31))
    struct timespec res;
    res.tv_sec = t;
    res.tv_nsec = 0;
    clock_settime(CLOCK_REALTIME, &res);
#else
    stime(&t);
#endif
}

void SystemManage::on_dialogTimeSetAuthorizationAccepted()
{
    QString authString= dialogTimeSetAuthorization->getAuth();
    qDebug()<<"authString"<<authString;

    if(dlgInputAddr_TimeSet->checWhJmDate(authString)) // 0xa001
    {
        QTime tm = QTime::currentTime();
        QDate date = QDate::currentDate();
        timeDia.setYear(date.year());
        timeDia.setMonth(date.month());
        timeDia.setDay(date.day());
        timeDia.setHour(tm.hour());
        timeDia.setMinute(tm.minute());
        timeDia.setSecond(tm.second());
        timeDia.hide();
        timeDia.show();
        connect(&timeDia,SIGNAL(accepted()),this,SLOT(onTimeSettingDone()));
    }else
    {
        QMessageBox::about(this, tr("提示"), tr("密码不正确！"));
        return;
    }

}


uint8_t datatime[8] = {};
void SystemManage::onTimeSettingDone(){
    adjustdate(timeDia.getYear(), timeDia.getMonth(), timeDia.getDay(), timeDia.getHour(), timeDia.getMinute(), timeDia.getSecond());
    qDebug()<<"onTimeSettingDone";

    QDate date(timeDia.getYear(), timeDia.getMonth(), timeDia.getDay());
    int dayOfWeek = date.dayOfWeek();
    QString YearStr = QString::number(timeDia.getYear());
    int Year1 = YearStr.mid(0,2).toInt();
    int Year2  = YearStr.mid(2,2).toInt();
    uint8_t year1 = Year1;
    datatime[0] = year1;
    uint8_t year2 = Year2;
    datatime[1] = year2;
    uint8_t month = timeDia.getMonth();
    datatime[2] = month;
    uint8_t day = timeDia.getDay();
    datatime[3] = day;
    uint8_t  week= dayOfWeek;
    datatime[4] = week;
    uint8_t hour = timeDia.getHour();
    datatime[5] = hour;
    uint8_t  minute= timeDia.getMinute();
    datatime[6] = minute;
    uint8_t  second= timeDia.getSecond();
    datatime[7] = second;

    for(int i=0;i<8;i++){
        qDebug()<<"datatime "<<i<<":"<<(int)datatime[i];
    }

    sysPara->devOp->stm32Wr(0xA1,(unsigned char *)datatime,8);

//   qDebug() << "time setting done!";
//    QString authString= dialogTimeSetAuthorization->getAuth();
//    dlgInputAddr_TimeSet->checWhJmDate(authString); //再执行一次，不然时间改不过来
}


void SystemManage::on_pushButtonUpdateCharLib_pressed()
{
    char cmd[500];
    QMessageBox::StandardButton ret;
    ret = QMessageBox::information(this, tr("Application"),
                                                       tr("是否确认更新字库?"),
                                                       QMessageBox::Ok | QMessageBox::Cancel);
    if (ret == QMessageBox::Ok){
//        QDir dirFont("/usr/lib/fonts/");
//        if(!dirFont.exists())
//        {
//            system("mkdir -p /usr/lib/fonts/");
//        }

        snprintf(cmd,sizeof(cmd),"cp /udisk/*.bdf /udisk/*.ttf /usr/lib/fonts/");
        system(cmd);

        snprintf(cmd,sizeof(cmd),"chmod a+r /usr/lib/fonts/*.bdf");
        system(cmd);

        QDir dir("/udisk/");
        QStringList filter;
        filter<<"*.bdf"<<"*.ttf";
        QFileInfoList infolist = dir.entryInfoList(filter);
        if(infolist.isEmpty())
        {
            infolist.clear();
            QMessageBox::information(this, tr("提示"), tr("没找到对应字库，更新失败!"));
        }
        else
        {
            QMessageBox::information(this, tr("提示"),
                                     tr("更新字库成功,重启后生效!"));
        }
    }
}

void SystemManage::on_pushButtonFactorySetting_pressed()
{
    dialogFactorySetAuthorization->clearAuth();
    dialogFactorySetAuthorization->show();
}

void SystemManage::on_dialogFactorySetAuthorizationAccepted()
{
    QString authString= dialogFactorySetAuthorization->getAuth();
    qDebug()<<"authString"<<authString;
    if(dlgInputAddr_TimeSet->checWhJmDate(authString))
    {
        sysPara->loadDefaultPara();
        sysPara->saveParaToFile();
        QMessageBox::information(this,"提示",tr("恢复出厂设置成功，请重新关机上电"));
    }
    else
    {
        QMessageBox::about(this, tr("提示"), tr("密码不正确！"));
        return;
    }
}

void SystemManage::on_pushButtonScreenAdjust_pressed()
{
    QMessageBox::StandardButton ret;
ret = QMessageBox::information(NULL,tr("校准触摸屏"), tr("是否确认开始校准程序？请小心进行校准！"),
                            QMessageBox::Ok | QMessageBox::Cancel);
char buf [] =
"#!/bin/sh\n\
TS_INFO_FILE=/sys/devices/virtual/input/input0/uevent \n\
TS_INFO_FILE1=/sys/class/input/input0/uevent \n\
if [ -e $TS_INFO_FILE -a \"/bin/grep -q TouchScreen < $TS_INFO_FILE\" ]; then \n\
export TSLIB_TSDEVICE=/dev/input/event0 \n\
export TSLIB_CONFFILE=/usr/local/etc/ts.conf \n\
export TSLIB_PLUGINDIR=/usr/local/lib/ts \n\
export TSLIB_CALIBFILE=/etc/pointercal \n\
export LD_LIBRARY_PATH=/usr/local/lib \n\
export PATH=/bin:/sbin:/usr/bin/:/usr/sbin:/usr/local/bin \n\
export QWS_DISPLAY=:1 \n\
export QWS_MOUSE_PROTO=\"Tslib:/dev/input/event0 MouseMan:/dev/input/mice\" \n\
\#rm -f /etc/pointercal \n\
\#if [ ! -s /etc/pointercal ] ; then \n\
        /usr/local/bin/ts_calibrate \n\
\#fi \n\
else \n\
TS_INFO_FILE1=/sys/class/input/input0/uevent \n\
if [ -e $TS_INFO_FILE1 -a \"/bin/grep -q tsc < $TS_INFO_FILE1\" ]; then \n\
    export QWS_MOUSE_PROTO=\"Tslib:/dev/input/event0 MouseMan:/dev/input/mice\" \n\
    /usr/local/bin/ts_calibrate \n\
else \n\
    export QWS_MOUSE_PROTO=\"MouseMan:/dev/input/mice\" \n\
fi \n\
fi\n"	;
 //   QFile file("./calibrate");
//    ui->pushButtonFactorySetting->setEnabled(0);
//    ui->pushButtonGhost->setEnabled(0);

//    ui->pushButtonScreenAdjust->setEnabled(0);

     ui->pushButtonReclaimTankOpen->setEnabled(0);
     ui->pushButtonReclaimTankClose->setEnabled(0);
     ui->pushButtonControlByHand->setEnabled(0);


     if (ret == QMessageBox::Ok){
         system("chmod a+x ./calibrate");
         system("./calibrate &");
     }

     ui->pushButtonReclaimTankOpen->setEnabled(1);
     ui->pushButtonReclaimTankClose->setEnabled(1);
     ui->pushButtonControlByHand->setEnabled(1);
}

void SystemManage::on_pushButtonUpdateSoftware_pressed()
{
   if(sysPara->status.updateSoftEN==0){
      dialogUpateMm->clearAuth();
       dialogUpateMm->show();
   }
   else  ondialogAuthorizationAccepted();
}
void SystemManage::ondialogAuthorizationAccepted()
 {
    QString authString= dialogUpateMm->getAuth();
    QString strDay;
    strDay.sprintf("%02d", QDate::currentDate().day());
    if(sysPara->status.updateSoftEN==0 && !TEST_MODE)//
    {
    if(authString.left(5) != "39305" || authString.right(2)!=strDay.left(2) || authString.length()<7)
    {
         //QMessageBox::warning(this,tr("提示"),tr(+"密码不正确！"),QMessageBox::Ok);
         QMessageBox::about(this, tr("提示"), tr("密码不正确！"));
         return;
     }
     sysPara->status.updateSoftEN=1;
    }

   char cmd[200];
   int res=0;
   QMessageBox::StandardButton ret;
    ret = QMessageBox::information(this, tr("警告"),
                                   tr("是否确认更新软件?"),
                                   QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Ok);
    if (ret == QMessageBox::Ok){
            QFile file("/udisk/QtUI");
            if(file.exists())
            {

                    //snprintf(cmd,sizeof(cmd),"cp -f /udisk/QtUI /udisk/*.qm /home/plg/");
                    system("cp -f /udisk/*.qm /home/plg/");

//                    res = system("cp -f /udisk/QtUI /home/plg/");

                    file.remove("/home/plg/QtUI");

                    if(!QFile::copy("/udisk/QtUI", "/home/plg/QtUI"))
                    {
                        QMessageBox::about(this, tr("错误"), tr("更新失败！"));
                        return;
                    }

                    QString filePath = "/home/plg/logo.png";    //开机Logo
                    if(QFile::exists("/udisk/logo.png")){
                        if(QFile::exists(filePath))
                            QFile::remove(filePath);
                        if(QFile::copy("/udisk/logo.png", filePath)){
                            QString cmd = QString("chmod 777 %1").arg(filePath);
                            system(cmd.toLocal8Bit().constData());
                        }
                    }

                    if(file.exists("/udisk/rcS")){
                        file.remove("/etc/init.d/rcS");
                        QFile::copy("/udisk/rcS", "/etc/init.d/rcS");
                    }

                    if(file.exists("/udisk/qt4")){
                            snprintf(cmd,sizeof(cmd),"cp /udisk/qt4  /home/plg/");
                            system(cmd);
                            snprintf(cmd,sizeof(cmd),"chmod a+x /home/plg/qt4");
                            res = system(cmd);
                    }
                    snprintf(cmd,sizeof(cmd),"cp /udisk/emergency  /home/plg/");
                    res = system(cmd);
                    snprintf(cmd,sizeof(cmd),"chmod a+x /udisk/ss");
                    res = system(cmd);
                    snprintf(cmd,sizeof(cmd),"/udisk/ss");
                    res = system(cmd);
                    QMessageBox::information(this, tr("提示"), tr("软件更新成功,重启后生效!"));
            }
            else
            {
                QFile file("/udisk/ss");
                if(file.exists()){
                    if(file.exists("/udisk/rcS")){
                            snprintf(cmd,sizeof(cmd),"cp /udisk/rcS /ect/init.d/");
                            system(cmd);
                    }
                    if(file.exists("/udisk/qt4")){
                            snprintf(cmd,sizeof(cmd),"cp /udisk/qt4  /home/plg/");
                            system(cmd);
                            snprintf(cmd,sizeof(cmd),"chmod a+x /home/plg/qt4");
                            system(cmd);
                    }
                    snprintf(cmd,sizeof(cmd),"cp /udisk/emergency  /home/plg/");
                    system(cmd);
                    snprintf(cmd,sizeof(cmd),"chmod a+x /udisk/ss");
                    system(cmd);
                    snprintf(cmd,sizeof(cmd),"/udisk/ss");
                    system(cmd);
                }
                snprintf(cmd,sizeof(cmd),"sync");       //防止拷贝不成功
                system(cmd);
                QMessageBox::about(this, tr("错误"), tr("找不到更新软件！"));
            }
            snprintf(cmd,sizeof(cmd),"sync");       //防止拷贝不成功
            system(cmd);
    }
}

void SystemManage::on_pushButtonGhost_pressed(){

    dialogSysUpdateAuthorization->clearAuth();
    dialogSysUpdateAuthorization->show();
}

void SystemManage::on_dialogSysUpdateAuthorizationAccepted()
{
    QString authString= dialogSysUpdateAuthorization->getAuth();
    QString strDay;
    strDay.sprintf("%02d", QDate::currentDate().day());

    if(authString.left(5) != "39305" || authString.right(2)!=strDay.left(2) || authString.length()<7)
    {
         //QMessageBox::warning(this,tr("提示"),tr(+"密码不正确！"),QMessageBox::Ok);
         QMessageBox::about(this, tr("提示"), tr("密码不正确！"));
         return;
     }

    char cmd[200];
   QMessageBox::StandardButton ret;
    ret = QMessageBox::information(this, tr("警告"),
                                   tr("是否确认更新系统?"),
                                   QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Ok);
    if (ret == QMessageBox::Ok)
    {
        QFile file("/udisk/uImage_am335x");
        if(file.exists())
        {
            qDebug()<<"start update...";
            snprintf(cmd,sizeof(cmd),"flash_erase /dev/mtd6 0x0 40;nandwrite -n -p -s 0 /dev/mtd6 /udisk/uImage_am335x");
            system(cmd);
            QMessageBox::information(this, tr("提示"), tr("系统更新成功,重启后生效!"));
        }else
        {
            QMessageBox::about(this, tr("提示"), tr("文件不存在!"));
        }
    }
}

void SystemManage::on_pushButtonCleanUP_pressed()
{
    if(sysPara){

        QMessageBox msgBox(QMessageBox::Information,tr("提示"),tr("如果开始清洗，务必确认回收槽已经打开10毫米以上，并且在一分钟后将停止清洗"));
        QPushButton *cleanButton = msgBox.addButton(tr("开始清洗"), QMessageBox::ActionRole);
        QPushButton *cancleCleanButton = msgBox.addButton(tr("停止清洗"), QMessageBox::ActionRole);
        msgBox.addButton(QMessageBox::Cancel);
        msgBox.exec();
        if (msgBox.clickedButton() == cleanButton) {
                sysPara->devOp->controlCycleValve(true);
                sysPara->devOp->controlViscosityPump(true);
                sysPara->devOp->controlReclaimPump(false,false);
                timer2->start(60000);
        } else if (msgBox.clickedButton() == cancleCleanButton) {
                timerHandler2();
        }
    }
}


void SystemManage::updateSysStatusToUI(){
    ui->labelControlByHand->setText(sysPara->status.isPumpValveControledByHand?tr("手动"):tr("自动"));

    if(sysPara){
        ui->labelCompressPump->setText((sysPara->devOp->isCompressPumpOpen()?tr("开"):tr("关")) + QString("\n%1").arg(sysPara->status.PRESSURE));
        ui->labelCycleValve->setText(sysPara->devOp->isCycleValveOpen()?tr("开"):tr("关"));
        ui->labelInkValve->setText(sysPara->devOp->isInkValveOpen()?tr("开"):tr("关"));
        if(!sysPara->status.isPumpValveControledByHand){
            if(sysPara->para.gearPumpEnable)
            {
                ui->labelMainInkPump->setText(tr("关"));
            }
            else
            {
                if(sysPara->status.ink_Ctrl == 1){
                    ui->labelMainInkPump->setText(tr("关") + QString("\n%1").arg(sysPara->status.SEPTAL_POSITION));

                }
                if(sysPara->status.ink_Ctrl == 0){
                    ui->labelMainInkPump->setText(tr("开") + QString("\n%1").arg(sysPara->status.SEPTAL_POSITION));

                }
            }
        }
        else{
            ui->labelMainInkPump->setText((sysPara->devOp->isMainInkPumpOpen()?tr("开"):tr("关")) + QString("\n%1").arg(sysPara->status.SEPTAL_POSITION));

        }
        ui->labelMixValve->setText(sysPara->devOp->isMixValveOpen()?tr("开"):tr("关"));
        ui->labelReclaimPump->setText(sysPara->devOp->isReclaimPumpOpen()?tr("开"):tr("关"));
        ui->labelReleaseValve->setText(sysPara->devOp->isReleaseValveOpen()?tr("开"):tr("关"));
        ui->labelViscosityPump->setText(sysPara->devOp->isViscosityPumpOpen()?tr("开"):tr("关"));
        ui->labelReclaimTankOpen->setText(sysPara->devOp->isReclaimTankOpenEnable()?tr("启动"):tr("停止"));
        ui->labelReclaimTankClose->setText(sysPara->devOp->isReclaimTankCloseEnable()?tr("启动"):tr("停止"));

        ui->labViscoCnt->setText( QString::number(sysPara->status.viscosityDelayCnt/100,10) );//labViscoCnt
        //ui->labViscoFaultCnt->setText( QString::number(sysPara->status.viscosityFaultCnt,10) );//labViscoCnt

        if(sysPara->para.gearPumpEnable)
        {
            ui->pushButtonCompressPump->setText(tr("压力"));
        }
        else
        {
            ui->pushButtonCompressPump->setText(tr("压缩机"));
        }
    }
}


void SystemManage::timerHandler(){
    if(sysPara){
        if(sysPara->status.isPumpValveControledByHand){				//进入手动模式后，延时一点再关闭相关的泵阀
            sysPara->devOp->controlCycleValve(false);
            sysPara->devOp->controlReclaimPump(false,false);
            timer->stop();
        }
    }
}


void SystemManage::timerHandler2(){
    if(sysPara){
        sysPara->devOp->controlCycleValve(false);
        sysPara->devOp->controlViscosityPump(false);
        timer2->stop();
    }
}
static int mainInkPumpCtrlStatus = 0;
static int mainInkPumpCtrlCnt = 0;
static int cycleValveOnCountInAirPush = 0;
void SystemManage::autoCleanTimerHandler(){
    static bool cleanDone = false;
    static int lastCycleValveOpen = 0;
    static int mainValve = 5;
    if(sysPara){
        if (sysPara->status.airPushing) {

//            if (sysPara->status.SEPTAL_POSITION > sysPara->para.septalPostion + 50) {
//                sysPara->devOp->controlCycleValve(true);
//            }
//            else if (sysPara->status.SEPTAL_POSITION < sysPara->para.septalPostion - 50) {
//                sysPara->devOp->controlCycleValve(false);
//            }
            ++sysPara->status.airPushingOnTime;
            // 以500ms 间隔开关循环阀
            if (sysPara->status.airPushingOnTime%10 >= 5) {
                sysPara->devOp->controlCycleValve(true);
            }
            else {
                sysPara->devOp->controlCycleValve(false);
            }


            if (mainInkPumpCtrlStatus == 0) {
                if(++mainInkPumpCtrlCnt>16) { //90ms 为单位, 时间到关闭
                    sysPara->devOp->controlMainInkPump(false);
                    sysPara->devOp->mainInkCtrl();
                    mainInkPumpCtrlStatus = 1;
                    mainInkPumpCtrlCnt = 0;
                }
            }
            else if (mainInkPumpCtrlStatus == 1) { //90ms 为单位, 时间到开启
                sysPara->devOp->controlMainInkPump(true);
                sysPara->devOp->mainInkCtrl();
                mainInkPumpCtrlStatus = 2;
            }
            else if (mainInkPumpCtrlStatus == 2) {
                if(++mainInkPumpCtrlCnt>8) {
                    sysPara->devOp->controlMainInkPump(false);
                    sysPara->devOp->mainInkCtrl();
                    mainInkPumpCtrlStatus = 3;
                    mainInkPumpCtrlCnt = 0;
                }
            }
            else if (mainInkPumpCtrlStatus == 3) {
                if(++mainInkPumpCtrlCnt>8) {
                    sysPara->devOp->controlMainInkPump(true);
                    sysPara->devOp->mainInkCtrl();
                    mainInkPumpCtrlStatus = 4;
                    mainInkPumpCtrlCnt = 0;
                }
            }
            else if (mainInkPumpCtrlStatus == 4) {
                if(++mainInkPumpCtrlCnt>8) {
                    sysPara->devOp->controlMainInkPump(false);
                    sysPara->devOp->mainInkCtrl();
                    mainInkPumpCtrlStatus = 3;
                    mainInkPumpCtrlCnt = 0;
                }
            }
            return;
        }
        if(dialogAutoClean->wasCanceled()||sysPara->status.autoCleanStatus == AUTOCLEAN_STATUS_NONE)
        {
            if(autoCleanTimer->isActive())
                autoCleanTimer->stop();
            sysPara->status.autoCleanStatus=AUTOCLEAN_STATUS_NONE;
            sysPara->status.autoCleanTime=0;
            dialogAutoClean->hide();
            delete dialogAutoClean;
            //sysPara->devOp->controlReclaimTankOpen(false);  // 停止回收槽
            // step2 完成后进入自动模式，参考了on_pushButtonControlByHand_pressed
            if(cleanDone)
            {
                if(timer2->isActive())
                    timer2->stop();
                sysPara->status.isPumpValveControledByHand = !sysPara->status.isPumpValveControledByHand;
                sysPara->status.isPumpValveControledByHand = false;
                setPumpValveBottonEnable(sysPara->status.isPumpValveControledByHand);
                ui->pushButtonPushAir->setEnabled(true);	//2019-10-20 自动还是手动模式，排气按钮都要使能 by kun
                ui->labelControlByHand->setText(sysPara->status.isPumpValveControledByHand?tr("手动"):tr("自动"));
                sysPara->devOp->mainInkCtrl();
                cleanDone = false;
            }
            qDebug()<<tr("autoclean cancel or status:")<<sysPara->status.autoCleanStatus;
            return;
        }

        //qDebug()<<tr("autoclean time")<<sysPara->status.autoCleanTime;
        //qDebug()<<tr("autoclean status")<<sysPara->status.autoCleanStatus;

        if(sysPara->status.autoCleanStatus != AUTOCLEAN_STATUS_NONE)
        {
            dialogAutoClean->setValue(sysPara->status.autoCleanTime);
            QCoreApplication::processEvents();

            ++sysPara->status.autoCleanTime;
            if(sysPara->status.autoCleanStatus == AUTOCLEAN_STATUS_STEP1)
            {
                if(sysPara->status.autoCleanTime >= AUTOCLEAN_STATUS_STEP1_TIME)
                {
                   sysPara->status.autoCleanStatus = AUTOCLEAN_STATUS_STEP2;
                   sysPara->status.autoCleanTime=0;
                   dialogAutoClean->setRange(0, AUTOCLEAN_STATUS_STEP2_TIME);
                   dialogAutoClean->setWindowTitle(tr("(2/3) Cleaning"));
                   //打开粘度泵,循环阀,墨水阀,主墨泵
                   if(!sysPara->devOp->isReclaimPumpOpen())	//开供墨阀之前要判断回收泵有没有开，没开就提前打开
                   {
                       sysPara->devOp->controlReclaimPump(true, false); // 回收泵开
                   }
                   sysPara->devOp->controlCycleValve(true);
                   sysPara->devOp->controlInkValve(true);
                   sysPara->devOp->controlInkValvePWM(true);
                   sysPara->devOp->controlMainInkPump(true);
                   sysPara->devOp->controlViscosityPump(true);
                   sysPara->devOp->mainInkCtrl();
                }
            }
            else if(sysPara->status.autoCleanStatus == AUTOCLEAN_STATUS_STEP2)
            {
                if(sysPara->status.autoCleanTime >= AUTOCLEAN_STATUS_STEP2_TIME)
                {
                    sysPara->status.autoCleanStatus = AUTOCLEAN_STATUS_STEP3;
                    sysPara->status.autoCleanTime=0;

                    dialogAutoClean->setRange(0, (AUTOCLEAN_STATUS_STEP3_TIME-1));
                    dialogAutoClean->setWindowTitle(tr("(3/3) Cleaning"));
                   //打开粘度泵,混合阀
                    {
                        sysPara->devOp->controlCycleValve(false);  //关循环阀,墨水阀,主墨泵
                        sysPara->devOp->controlInkValve(false);
                        sysPara->devOp->controlInkValvePWM(false);
                        sysPara->devOp->controlMainInkPump(false);
                        sysPara->devOp->controlMixValve(true);  //开混合阀
                        sysPara->devOp->controlViscosityPump(true);//开粘度泵
                        sysPara->devOp->mainInkCtrl();
                    }
                }
            }
            else if(sysPara->status.autoCleanStatus == AUTOCLEAN_STATUS_STEP3)
            {
                if(sysPara->status.autoCleanTime >= AUTOCLEAN_STATUS_STEP3_TIME)
                {
                    sysPara->status.autoCleanStatus = AUTOCLEAN_STATUS_NONE;
                    sysPara->status.autoCleanTime=0;
                    cleanDone = true;
                }
            }
        }
    }
}

void SystemManage::reclainTankTestHandler()
{
    static unsigned int waitTime = 0;
    if(!sysPara)
    {
        return;
    }
    if(reclainTankTestProcess->wasCanceled()||reclainTankTestState == ReclainTankTest_eNotStart)
    {
        if(reclaimTankTestTimer->isActive())
            reclaimTankTestTimer->stop();
        //sysPara->status.autoCleanStatus=AUTOCLEAN_STATUS_NONE;
        reclainTankTestState = ReclainTankTest_eNotStart;
        reclainTankTestCount = 0;
        reclainTankTestProcess->hide();
        reclainTankTestProcess->deleteLater();
        return;
    }
    if(reclainTankTestState == ReclainTankTest_eOpenning) {
        if(sysPara->status.reclaimTankstatus == 0x05||sysPara->status.reclainTankReachEnd) {   //open complete
            reclainTankTestState = ReclainTankTest_eOpened;
            waitTime = 4;
            //qDebug()<<"ReclainTankTest_eOpened";
        }
    }
    else if(reclainTankTestState == ReclainTankTest_eOpened) {
        if(waitTime > 0)
        {
            --waitTime;
            return;
        }
        sysPara->devOp->controlReclaimTankClose(!sysPara->devOp->isReclaimTankCloseEnable());
        ui->labelReclaimTankClose->setText(sysPara->devOp->isReclaimTankCloseEnable()?tr("启动"):tr("停止"));
        sysPara->status.reclainOpenAppending = false;
        sysPara->status.reclainCloseAppending = true;
        sysPara->status.currReclaimOperationCnt = 0;
        sysPara->status.reclainTankReachEnd = false;
        reclainTankTestState = ReclainTankTest_eClosing;
    }
    else if(reclainTankTestState == ReclainTankTest_eClosing) {
        if(sysPara->status.reclaimTankstatus == 0x06||sysPara->status.reclainCloseAppending==false) {   //close complete
            reclainTankTestState = ReclainTankTest_Closed;
        }
    }
    else if(reclainTankTestState == ReclainTankTest_Closed) {
        reclainTankTestCount++;
        if(reclainTankTestCount>=RECLAIN_TANK_TEST_MAX_COUNT) {
            reclainTankTestState = ReclainTankTest_eNotStart;
            reclaimTankTestTimer->stop();
            reclainTankTestProcess->hide();
            reclainTankTestProcess->deleteLater();
        }
        else {
            reclainTankTestProcess->setWindowTitle(QString("(%1/%2) reclain tank test").arg(reclainTankTestCount).arg(RECLAIN_TANK_TEST_MAX_COUNT));
            reclainTankTestProcess->setValue(reclainTankTestCount);
            sysPara->devOp->controlReclaimTankOpen(!sysPara->devOp->isReclaimTankOpenEnable());
            ui->labelReclaimTankOpen->setText(sysPara->devOp->isReclaimTankOpenEnable()?tr("启动"):tr("停止"));
            sysPara->status.reclainOpenAppending = true;
            sysPara->status.reclainCloseAppending = false;
            sysPara->status.currReclaimOperationCnt = 0;
            sysPara->status.reclainTankReachEnd = false;
            reclainTankTestState = ReclainTankTest_eOpenning;
        }
    }
    else {
        reclaimTankTestTimer->stop();
    }

}

void SystemManage::inkcloseCountHandler()
{
//    static uint8_t flag = true;

//    if(flag <50)
//    {
//        flag++;
//    }

//    if(flag==10)
//    {

//        sysPara->devOp->controlInkValve(true);
//    }else
//    if(flag == 15)
//    {
//         sysPara->devOp->controlInkValve(false);
//    }

//    qDebug()<<"sysMana reclaimOpenCntAfterSWintOf" << sysPara->status.reclaimOpenCntAfterSWintOff;
//    ui->labelReclaimPump->setText((sysPara->devOp->isReclaimPumpOpen()?tr("开"):tr("关")) + QString("\n%1").arg(sysPara->status.reclaimOpenCntAfterSWintOff));
    if(false == sysPara->devOp->isInkValveOpen())
    {
//        qDebug()<<"Ink pump is off";
        //qDebug()<<"sysMana reclaimOpenCntAfterSWintOf" << sysPara->status.reclaimOpenCntAfterSWintOff;
        if(sysPara->devOp->isReclaimPumpOpen())
        {

            sysPara->status.reclaimOpenCntAfterSWintOff++;
            if(sysPara->status.reclaimOpenCntAfterSWintOff >= 60)	//等待60s
            {
                sysPara->devOp->controlReclaimPump(false,false); // 墨线关闭一分钟后，回收阀再关闭
                sysPara->status.autoCtlReclaimAfterSWintOff = true;
            }
        }
    }else
    {
//       qDebug()<<"Ink pump is open";
        sysPara->status.reclaimOpenCntAfterSWintOff = 0;
        sysPara->status.autoCtlReclaimAfterSWintOff = false;
    }
}
void SystemManage::MainInkCmpSepetalHandler()
{

//	static unsigned int waitTime
//	qDebug()<<"sysPara->status.SEPTAL_POSITION" << sysPara->status.SEPTAL_POSITION;
    //2019/10/24	主泵由隔膜位置联动
    if(!sysPara->status.isPumpValveControledByHand)
    {
        if(sysPara->status.SEPTAL_POSITION >= 200)
        {
            if(true == sysPara->devOp->isMainInkPumpOpen())
            {
                sysPara->devOp->controlMainInkPump(false);
            }
        }else
        {
            if(false == sysPara->devOp->isMainInkPumpOpen())
            {
                sysPara->devOp->controlMainInkPump(true);
            }
        }
    }
}


void SystemManage::on_pushButtonExportConfToUDisk_clicked()
{
    QMessageBox::StandardButton ret;
    ret = QMessageBox::information(this, tr("警告"),
                               tr("是否确认导出配置到U盘?"),
                               QMessageBox::Ok | QMessageBox::Cancel);
    if (ret == QMessageBox::Ok){
        QDir dir("/udisk");
        if(!dir.exists()){
            QMessageBox::warning(this, tr("错误"),
                                           tr("检测不到U盘"));
            return;
        }
        system((char *)((QString("cp /home/plg/conf/sysPara.bin  /udisk/")).toLatin1().data()));
        QMessageBox::information(this, tr("提示"),
                                       tr("成功导出配置到U盘"));
    }
}


void SystemManage::on_pushButtonImportConfFromUdisk_clicked()
{
    QMessageBox::StandardButton ret;
    ret = QMessageBox::information(this, tr("警告"),
                           tr("是否确认从U盘导入配置?"),
                           QMessageBox::Ok | QMessageBox::Cancel);
    if (ret == QMessageBox::Ok){
    QFile file("/udisk/sysPara.bin");
    if(!file.exists()){
        QMessageBox::warning(this,  tr("错误"),
                                     tr("配置文件/udisk/sysPara.bin不存在!"));
        return;
    }
    system((char *)((QString("cp /udisk/sysPara.bin  /home/plg/conf/ ")).toLatin1().data()));
    QMessageBox::information(this, tr("提示"),
                                   tr("从U盘成功导入配置，重启后生效!"));
    emit configChanged();
    }
}

void SystemManage::onAutoCleanStart(void)
{
    if(sysPara){
        /* into manual control mode */
        // step 1:只开粘度泵; step 2:开粘度泵,循环阀,墨水阀,住墨泵
        //r_PumpValveControledByHand = sysPara->status.isPumpValveControledByHand;
        //ui->label_status->setText(tr("正在进入手动模式......"));
        //sysPara->status.isPumpValveControledByHand=true;
        sysPara->devOp->highVoltageCtrl(0); //关闭高压
        sysPara->devOp->controlCompressPump(false);
        sysPara->devOp->controlCycleValve(false);
        sysPara->devOp->controlInkValve(false);
        sysPara->devOp->controlInkValvePWM(false);
        sysPara->devOp->controlMainInkPump(false);
        sysPara->devOp->controlMixValve(false);
        sysPara->devOp->controlReclaimPump(false,false);
        sysPara->devOp->controlViscosityPump(true);//只开粘度泵
        sysPara->devOp->controlReleaseValve(false);
        sysPara->devOp->mainInkCtrl();
        // 关闭回收槽
        {
            sysPara->devOp->controlReclaimTankClose(!sysPara->devOp->isReclaimTankCloseEnable());
            ui->labelReclaimTankClose->setText(sysPara->devOp->isReclaimTankCloseEnable()?tr("启动"):tr("停止"));
            sysPara->status.reclainOpenAppending = false;
            sysPara->status.reclainCloseAppending = true;
            sysPara->status.currReclaimOperationCnt = 0;
            sysPara->status.reclainTankReachEnd = false;
        }

        sysPara->status.autoCleanStatus = AUTOCLEAN_STATUS_STEP1;
        sysPara->status.autoCleanTime = 0;
        qDebug()<<tr("autoclean start");
    }
}

void SystemManage::on_pushButtonAutoClean_pressed()
{
    sysPara->saveParaToFile();					// 关机前将相关配置保存
    sysPara->saveRFIDPara();
    MySleep(200);
    system("sync");//缓存同步
    QCoreApplication::quit();
    /*
    QMessageBox::StandardButton ret;
    ret = QMessageBox::information(this, tr("警告"),
                           tr("是否确认启动自动清洗?"),
                           QMessageBox::Ok | QMessageBox::Cancel);
    if (ret == QMessageBox::Ok){
        ret = QMessageBox::information(this, tr("警告"),
                               tr("是否确认墨水排除，加入清洗剂?"),
                               QMessageBox::Ok | QMessageBox::Cancel);
        if (ret == QMessageBox::Ok) {
            dialogAutoClean = new QProgressDialog(this);
            dialogAutoClean->setWindowModality(Qt::WindowModal);
            dialogAutoClean->setMinimumDuration(2);
            dialogAutoClean->setCancelButtonText(tr("Cancel"));
            dialogAutoClean->setWindowTitle(tr("(1/3) Cleaning"));
            dialogAutoClean->setRange(0, AUTOCLEAN_STATUS_STEP1_TIME);
            dialogAutoClean->setAutoClose(true);
            dialogAutoClean->setAutoReset(true);
            emit autoCleanStart();
            autoCleanTimer->start(1000); // 1000 ms
            dialogAutoClean->show();
        }
    }*/
}

void SystemManage::on_pushButtonMotorTest_pressed()
{
    QMessageBox::StandardButton ret;
    if(!sysPara->para.isCheckMagnet)
    {
        if(!(sysPara->status.statWarn & WARN_STATUS_HDINT)){
                        QMessageBox::warning(this, tr("警告"),
                                             tr("请先移开喷头盖!"));
            return ;
        }
    }
    ret = QMessageBox::information(this, tr("警告"),
                           tr("是否开始电机测试?"),
                           QMessageBox::Ok | QMessageBox::Cancel);
    if (ret == QMessageBox::Ok){
        if(sysPara){
            reclainTankTestCount = 0;
            reclainTankTestProcess = new QProgressDialog(this);
            reclainTankTestProcess->setWindowModality(Qt::WindowModal);
            reclainTankTestProcess->setMinimumDuration(2);
            reclainTankTestProcess->setCancelButtonText(tr("Cancel"));
            reclainTankTestProcess->setWindowTitle(QString("(%1/%2) reclain tank test").arg(reclainTankTestCount).arg(RECLAIN_TANK_TEST_MAX_COUNT));
            reclainTankTestProcess->setRange(0, RECLAIN_TANK_TEST_MAX_COUNT);
            reclainTankTestProcess->setValue(reclainTankTestCount);
            reclainTankTestProcess->setAutoClose(true);
            reclainTankTestProcess->setAutoReset(true);
            reclainTankTestProcess->show();

            sysPara->devOp->controlReclaimTankOpen(!sysPara->devOp->isReclaimTankOpenEnable());
            ui->labelReclaimTankOpen->setText(sysPara->devOp->isReclaimTankOpenEnable()?tr("启动"):tr("停止"));
            sysPara->status.reclainOpenAppending = true;
            sysPara->status.reclainCloseAppending = false;
            sysPara->status.currReclaimOperationCnt = 0;
            sysPara->status.reclainTankReachEnd = false;
            reclainTankTestState = ReclainTankTest_eOpenning;
            reclaimTankTestTimer->start(1000);
        }
    }
}

void SystemManage::on_pushButtonPushAir_pressed()
{
    sysPara->status.byHandStore  = sysPara->status.isPumpValveControledByHand;
    sysPara->status.isPumpValveControledByHand = true;
    sysPara->devOp->mainInkCtrl();
    //ui->label_status->setText(tr("正在进入手动模式......"));

    sysPara->status.airPushing = 1;
    sysPara->status.airPushingOnTime = 0;
    cycleValveOnCountInAirPush = 0;
    sysPara->devOp->controlCycleValve(true);
    sysPara->devOp->controlViscosityPump(true);//关闭粘度泵
    sysPara->devOp->controlMixValve(false);

    sysPara->devOp->controlMainInkPump(true);//主墨泵敞开
    sysPara->devOp->mainInkCtrl();
    sysPara->devOp->controlReclaimPump(true, false); // 回收泵开
    sysPara->devOp->controlInkValve(true); //墨水阀
    sysPara->devOp->controlInkValvePWM(true); //墨水阀
    mainInkPumpCtrlStatus = 0;
    mainInkPumpCtrlCnt = 0;
    autoCleanTimer->start(90); // 90 ms
    QMessageBox::StandardButton ret = QMessageBox::information(this, tr("提示"),
                           tr("正在排气,是否停止?"),
                           QMessageBox::Ok);
    if (ret == QMessageBox::Ok) {
        autoCleanTimer->stop();
        sysPara->status.airPushing = 0;
        cycleValveOnCountInAirPush = 0;
        // 还原当前模式
        sysPara->devOp->controlCompressPump(false);
        sysPara->devOp->controlCycleValve(false);
        sysPara->devOp->controlInkValve(false);
        sysPara->devOp->controlInkValvePWM(false);
        if(sysPara->status.SEPTAL_POSITION >= (sysPara->para.septalPostion - 10))
        {
            sysPara->devOp->controlMainInkPump(false);
        }
        if(sysPara->status.isPumpValveControledByHand == true)
        {
            sysPara->devOp->controlMainInkPump(false);  //Controled by hand mode, mainInkPump need to stop
        }

        sysPara->devOp->controlMixValve(false);
        sysPara->devOp->controlReclaimPump(false,false);
        sysPara->devOp->controlViscosityPump(false);
        sysPara->devOp->controlReleaseValve(false);
        sysPara->status.isPumpValveControledByHand = sysPara->status.byHandStore;// 还原到之前的模式
        sysPara->devOp->mainInkCtrl();


    }

}

void SystemManage::on_pushButtonGearPumpOff_pressed()
{
    ui->pushButtonGearPumpOff->setEnabled(false);
    sysPara->para.gearPumpValue = 0;
    sysPara->devOp->WriteMoterPump();
    ui->pushButtonGearPump->setEnabled(true);
}

void SystemManage::on_spinBoxGearPumpValue_valueChanged(int arg1)
{
    sysPara->para.gearPumpValue = arg1;

}

void SystemManage::on_pushButtonProgamFPGA_clicked()
{
    //开一个定时器去判断回收槽回收完毕，然后进入手动模式，再关闭FPGA的通信。
    programFPGATimer->start(1000);
}

void SystemManage::programFPGAProcess(){
    QMessageBox::StandardButton ret = QMessageBox::information(this, tr("提示"),
                           tr("确定要升级FPGA软件吗?"),
                           QMessageBox::Ok);
    if (ret == QMessageBox::Ok) {
        QFile FpgaFile("/home/plg/FPGAFile.rbf");
        if(FpgaFile.exists())
            QFile::remove("/home/plg/FPGAFile.rbf");

        QFile file("/udisk/FPGAFile.rbf");
        if(!file.exists())
        {
            QMessageBox::warning(this,tr("提示"), tr("没有FPGA升级文件"));
            programFPGATimer->stop();
            return;
        }
        QFile filepy("/udisk/upgrade_file_new.py");
        QFile::copy("/udisk/FPGAFile.rbf","/home/plg/FPGAFile.rbf");
        if(filepy.exists()){
            QFile::remove("/home/plg/upgrade_file_new.py");
            QFile::copy("/udisk/upgrade_file_new.py","/home/plg/upgrade_file_new.py");
        }

        //进入手动模式
        sysPara->status.isPumpValveControledByHand = true;
        setPumpValveBottonEnable(sysPara->status.isPumpValveControledByHand);
        ui->pushButtonPushAir->setEnabled(true);		//2019-10-20 自动还是手动模式，排气按钮都要使能 by kun
        ui->labelControlByHand->setText(sysPara->status.isPumpValveControledByHand?tr("手动"):tr("自动"));
        sysPara->devOp->mainInkCtrl();
        emit enableReclaimButton(!sysPara->status.isPumpValveControledByHand);
        //关闭FPGA通信
        emit sigToCloseSerialFPGA();
        emit sigToCloseSerialSTM32();
        //关闭定时器
        programFPGATimer->stop();
        programFPGADialog->init();
        programFPGADialog->show();
    }
}

void SystemManage::PowerOnSetTime(QString date){
     qDebug()<<"PowerOnTime:"<<date;
     QDateTime dateTime = QDateTime::fromString(date, "yyyy-MM-dd HH:mm:ss");
    // 检查是否成功创建
    if (dateTime.isValid()) {
        qDebug()<<"Date Create Successful";
    }else {
         qDebug()<<"Date Create Failed";
         return;
    }
    int year = dateTime.date().year();
    int month = dateTime.date().month();
    int day = dateTime.date().day();
    int hour = dateTime.time().hour();
    int minute = dateTime.time().minute();
    int second = dateTime.time().second();

    adjustdate(year, month, day, hour, minute, second);
   // system("hwclock --systohc");

}

void SystemManage::on_pushButton_EnvConf_clicked()
{
    // 检查源文件
    if (!QFile::exists("/udisk/lib.tar")) {
        QMessageBox::critical(this, tr("错误"), tr("找不到 lib.tar！"));
        return;
    }

    // 创建目录
    QDir destDir("/home/upload/env");
    if (!destDir.exists())
        destDir.mkpath("/home/upload/env");

    QString destTarPath = "/home/upload/env/lib.tar";
    if (QFile::exists(destTarPath)) {
        if (!QFile::remove(destTarPath)) {
            QMessageBox::critical(this, tr("错误"), tr("无法删除旧的 lib.tar！"));
            return;
        }
    }

    // 复制 tar 包
    if (!QFile::copy("/udisk/lib.tar", "/home/upload/env/lib.tar")) {
        QMessageBox::critical(this, tr("错误"), tr("复制 tar 包失败！"));
        return;
    }

    // 解压
    int ret = system("cd /home/upload/env && tar -xvf lib.tar");
    if (ret != 0) {
        QMessageBox::critical(this, tr("错误"), tr("解压失败，请检查权限！"));
        return;
    }

    // 移动库文件
    ret = system("cd /home/upload/env && mv libQt5VirtualKeyboard* /opt/Qt/lib/");
    if (ret != 0) {
        QMessageBox::critical(this, tr("错误"), tr("移动库文件失败！"));
        return;
    }

   // system("chmod 755 /opt/Qt/lib/libQt5VirtualKeyboard.so*");
    QMessageBox::information(this,tr("提示"),tr("环境配置成功!"));
}

void SystemManage::engieerModeAcceptSystemManage(bool flag){
    ui->pushButton_EnvConf->setVisible(flag);
}

void SystemManage::on_pushButton_SwitchKBD_clicked()
{
    QFile file("/home/plg/UseKBD");
    QByteArray buf;
    buf.clear();
    QString keyBoardType = Public::ReadKeyBoardUse();
    if(file.open(QIODevice::WriteOnly)) {
        if(keyBoardType == "Chinese")
            buf.append("MultiLanguage\r\n");
        else
            buf.append("Chinese\r\n");
        file.write(buf);
        fsync(file.handle());
        file.close();
    }else{
         QMessageBox::warning(this,tr("提示"),tr("切换失败!"));
        return;
    }

    QMessageBox::information(this,tr("提示"),tr("切换成功，重启后生效!"));
}

void SystemManage::loadKeyBoardType(){
    QString keyBoardType = Public::ReadKeyBoardUse();
    if(keyBoardType == "MultiLanguage")
        sysPara->status.flagOfKeyBoardType = true;
    else
        sysPara->status.flagOfKeyBoardType = false;

}


void SystemManage::applyStyleSheet()
{
    QString styleSheet = R"(
        QPushButton#closeBtn {
            background-color: #E6F7FF;
            border: 1px solid #87CEEB;
            border-radius: 4px;
            font-size: 24px;
            color: #228B22;
        }
        QPushButton#closeBtn:hover{
            background-color: #D1E9FF;
        }

        QPushButton#closeBtn:pressed{
            background-color: #BAE7FF;
        }


    )";


    // this->setStyleSheet(styleSheet);
}


/*当烧录单片机的按键按下*/
void SystemManage::on_pushButtonProgamSTM32_clicked()
{
    int cnt = hasSingleStm32Bin("/udisk");
    if(cnt == 0){
        QMessageBox::warning(this,tr("提示"),tr("找不到软件!"));
        return;
    }
    else if(cnt > 1){
        QMessageBox::warning(this,tr("提示"),tr("找到多个软件,请删除多余的文件,只保留一个!"));
        return;
    }

    QMessageBox::StandardButton ret = QMessageBox::information(this, tr("提示"),
                           tr("确定要升级单片机软件吗?"),
                           QMessageBox::Ok | QMessageBox::Cancel);
    if (ret == QMessageBox::Ok) {
        emit enableClick(false);
        sysPara->status.isPumpValveControledByHand = true;
        emit upgradeSTM32(fileName);
    }
}

/**
 * 判断 /udisk 目录下是否存在并且只有一个以 VET6_ 开头、.bin 结尾的文件
 * 返回 true 表示满足"存在且仅有一个"，否则返回 false
 * 如果还需要拿到这个文件名，可把 fileName 通过最后一个参数带回
 */
int SystemManage::hasSingleStm32Bin(const QString &dirPath)
{
    QDirIterator it(dirPath,
                    QStringList() << "VET6_*.bin",   // 通配符过滤
                    QDir::Files,
                    QDirIterator::NoIteratorFlags);

    int cnt = 0;
    QString found;
    while (it.hasNext()) {
        it.next();               // 迭代到下一个匹配文件
        ++cnt;
        found = it.fileName();   // 只保留文件名，不含路径
        if (cnt > 1)             // 已经发现第二个，提前结束
            break;
    }

    if (cnt == 1)
        fileName = found;

    return cnt;   // 仅当数量为 1 时返回 true
}

void SystemManage::progressBarControl(int value,int show){
    if(show == 1){
        progressBar.setWindowFlags(Qt::WindowStaysOnTopHint);
        progressBar.show();
        progressBar.setValue(value);
    }
    else if(show == 0){
        emit enableClick(true);
        progressBar.hide();
        QMessageBox::warning(this,tr("提示"),tr("升级成功,请重启QtUI!"));
    }
    else{
        emit enableClick(true);
        progressBar.hide();
        QMessageBox::warning(this,tr("提示"),tr("升级失败!"));
    }
}