#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 "LogInfo.h"
#include<string>
#include<iostream>
#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);
	timeDia.hide();
    setPumpValveBottonEnable(false);
    ui->pushButtonCompressPump->setEnabled(false);
    ui->pushButtonMainInkPump->setEnabled(false);
    ui->pushButtonReleaseValve->setEnabled(false);
    ui->pushButtonReclaimPump->setEnabled(false);
    ui->pushButtonGearPump->setEnabled(false);
    ui->pushButtonGearPumpOff->setEnabled(false);

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

    toAutoControl = new QTimer(this);
    connect(toAutoControl,SIGNAL(timeout()),this,SLOT(changeToAutoControl()));
    manualControl = new QTimer(this);
    connect(manualControl,SIGNAL(timeout()),this,SLOT(changeToManualControl()));


/***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()));
 //   MainnkCmpSepetalTimer->start(100);
/***2019/10/23 *****/

#ifdef MIMA
       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();

#endif
       connect(ui->spinBoxGearPumpValue,SIGNAL(valueChanged(int)),this,SLOT(updateGearPumpValue(int)));
#if 0
            dialogAutoClean = new QProgressDialog(this);

            dialogAutoClean->setWindowModality(Qt::WindowModal);
            dialogAutoClean->setMinimumDuration(2);
            dialogAutoClean->setCancelButtonText(tr("Cancel"));
            dialogAutoClean->setWindowTitle(tr("(1/2) Cleaning, please wait...  "));
            dialogAutoClean->setRange(0, AUTOCLEAN_STATUS_STEP1_TIME);
            dialogAutoClean->setAutoClose(true);
            dialogAutoClean->setAutoReset(true);
#endif
       //ui->pushButtonCleanUP->hide();
       ui->pushButtonExportConfToUDisk->setDisabled(true);
       ui->pushButtonImportConfFromUdisk->setDisabled(true);
       ui->pushButtonFactorySetting->setDisabled(true);
       ui->labelControlByHand->setText(tr("自动"));
       ui->pushButtonMotorTest->hide();
       getCurrentScrennType();
}

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

SystemManage::~SystemManage()
{
    delete ui;
    delete timer2;
    delete timer;
    delete autoCleanTimer;
    /***2019/10/22 start*****/
    delete inkcloseCountTimer;
    /****2019/10/22 end****/

    /***2019/10/23 start*****/
    delete MainnkCmpSepetalTimer;
}

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();
    if(sysPara->para.flagOfReclaimPumEnable)
        manualControl->start(1000);
    ui->pushButtonGearPumpOff->setEnabled(true);
}

void SystemManage::changeToManualControl(){
    if(sysPara->status.PRESSURE > sysPara->para.pressure*1.1){
        sysPara->para.gearPumpValue = 0;
        sysPara->devOp->WriteMoterPump();
    }
    else if(sysPara->status.PRESSURE < sysPara->para.pressure*0.9){
        sysPara->para.gearPumpValue = ui->spinBoxGearPumpValue->value();
        sysPara->devOp->WriteMoterPump();
    }
}

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

static int num = 0;
static int controlTime = 30;
void SystemManage::on_pushButtonControlByHand_pressed()
{
	if(sysPara){

#ifdef DEBUG1
                sysPara->status.statWarn =0| WARN_STATUS_HDINT;//sysPara->status.statWarn;
#endif

        if(!sysPara->status.isPumpValveControledByHand){
#if 0
            if(!(sysPara->status.statWarn & WARN_STATUS_HDINT)){
                QMessageBox::warning(this, tr("警告"),
                                     tr("请先移开喷头盖!"));
                return ;
            }
#endif
            QMessageBox::StandardButton ret;
            ret = QMessageBox::warning(this, tr("警告"),
                                       tr("是否确认进入手动模式?"),
                                       QMessageBox::Ok | QMessageBox::Cancel);
            if (ret != QMessageBox::Ok){
                return;
            }else
            {
                num = controlTime;
               //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
            {
                if(manualControl->isActive())
                    manualControl->stop();
                if(sysPara->para.flagOfReclaimPumEnable)
                    toAutoControl->start(1000);
                else{
                    num = controlTime;
                    inkcloseCountTimer->start(1000);
                }
            }
        }

        if(num == controlTime){
            num = 0;
            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()<<"手动控制泵阀";
        }
	}
}

void SystemManage::changeToAutoControl(){
    float coefficient;
    if(sysPara->para.pressure <= 600)
        coefficient = 1.3;
    else if(sysPara->para.pressure <= 700)
        coefficient = 1.2;
    else
        coefficient = 1.15;
    num++;
    sysPara->para.gearPumpValue = 230;
    sysPara->devOp->WriteMoterPump();
    if(num >= controlTime || sysPara->status.PRESSURE >= sysPara->para.pressure * coefficient){
        toAutoControl->stop();
        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);
        num = 0;
    }
}

void SystemManage::on_pushButtonReclaimTankOpen_pressed()
{
	if(sysPara){
#ifdef DEBUG1
                sysPara->status.statWarn =0| WARN_STATUS_HDINT;//sysPara->status.statWarn;
#endif
        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){
#ifdef DEBUG1
                sysPara->status.statWarn =0| WARN_STATUS_HDINT;//sysPara->status.statWarn;
#endif
                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);

#ifdef SYS_LINUX
    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;
	}

}

void SystemManage::on_pushButtonTimeSetting_clicked()
{
	dialogTimeSetAuthorization->clearAuth();
	dialogTimeSetAuthorization->show();
//	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()));
}

void SystemManage::onTimeSettingDone(){
	adjustdate(timeDia.getYear(), timeDia.getMonth(), timeDia.getDay(), timeDia.getHour(), timeDia.getMinute(), timeDia.getSecond());
	system("hwclock --systohc");
       // 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){
            snprintf(cmd,sizeof(cmd),"rm /usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/fonts/*.ttf");
            system(cmd);
            snprintf(cmd,sizeof(cmd),"rm /usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/fonts/*.ttc");
            system(cmd);
            QDir FontsFile("/usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/fonts/");
            if(FontsFile.exists("/usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/fonts/"))//2451
            {
                snprintf(cmd,sizeof(cmd),"cp /udisk/*.qpf2 /udisk/*.qpf /udisk/*.ttf /udisk/*.ttc /usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/fonts/");
                system(cmd);
            }
            if(FontsFile.exists("/usr/lib/fonts/"))//am335x
            {
                snprintf(cmd,sizeof(cmd),"cp /udisk/*.qpf2 /udisk/*.qpf /udisk/*.ttf /udisk/*.ttc /usr/lib/fonts/");
                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),"mkdir /opt/zk/");
            system(cmd);
            snprintf(cmd,sizeof(cmd),"cp -f /udisk/zk/* /opt/zk/");
            system(cmd);            
            snprintf(cmd,sizeof(cmd),"cp -rf /udisk/*_utf8.txt /home/plg/");
            system(cmd);

            QDir dir("/udisk/");
            QStringList filter;
            filter<<"*.qpf2"<<"*.qpf"<<"*.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::warning(this,tr("提示"),tr(+"密码不正确！"),QMessageBox::Ok);
        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->pushButtonImportConfFromUdisk->setEnabled(0);
    ui->pushButtonExportConfToUDisk->setEnabled(0);
    ui->pushButtonTimeSetting->setEnabled(0);
    ui->pushButtonScreenAdjust->setEnabled(0);
    ui->pushButtonUpdateCharLib->setEnabled(0);
     ui->pushButtonUpdateSoftware->setEnabled(0);
     ui->pushButtonReclaimTankOpen->setEnabled(0);
     ui->pushButtonReclaimTankClose->setEnabled(0);
     ui->pushButtonControlByHand->setEnabled(0);


    if (ret == QMessageBox::Ok){
//            if(!file.open(QIODevice::WriteOnly)){//怀疑是QIODevice::Truncate 引起参数错误，去掉试试看
//                    QMessageBox::warning(0,tr("警告"),tr("无法生成脚本 "));
//                    return ;
//            }
//            else {
//                    file.write(buf,(long long int)sizeof(buf));
//#if defined(__CONVERTERBOARD__)|| defined(__VX__)
#if 1
//                    fsync(file.handle());
#endif
//                    file.close();
                    system("chmod a+x ./calibrate");
                    system("./calibrate &");
//            }
    }

    ui->pushButtonFactorySetting->setEnabled(1);
    ui->pushButtonGhost->setEnabled(1);
    ui->pushButtonImportConfFromUdisk->setEnabled(1);
    ui->pushButtonExportConfToUDisk->setEnabled(1);
    ui->pushButtonTimeSetting->setEnabled(1);
    ui->pushButtonScreenAdjust->setEnabled(1);
    ui->pushButtonUpdateCharLib->setEnabled(1);
     ui->pushButtonUpdateSoftware->setEnabled(1);
     ui->pushButtonReclaimTankOpen->setEnabled(1);
     ui->pushButtonReclaimTankClose->setEnabled(1);
     ui->pushButtonControlByHand->setEnabled(1);
}

void SystemManage::on_pushButtonUpdateSoftware_pressed()
{
#ifdef MIMA
   if(sysPara->status.updateSoftEN==0){
      dialogUpateMm->clearAuth();
       dialogUpateMm->show();
   }
   else  ondialogAuthorizationAccepted();

#else
     ondialogAuthorizationAccepted();
#endif

}
void SystemManage::ondialogAuthorizationAccepted()
 {
#ifdef MIMA
    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;
    }

#endif
   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;
                    }

                    //qDebug()<<"update Software."<<res;//<<cmd;

//                    if(!QDir("/home/plg/r_conf/").exists())
//                    {
////                        QDir("/home/plg/r_conf/").mkdir("/home/plg/r_conf/");
////                        snprintf(cmd,sizeof(cmd),"cp /udisk/r_conf/* /home/plg/r_conf/");
////                        system(cmd);

//                        //snprintf(cmd,sizeof(cmd),"cp /home/plg/r_conf/*.bin  /home/plg/r_conf/UP.dpn  /home/plg/conf/");
//                        //system(cmd);
//                        //snprintf(cmd,sizeof(cmd),"cp /home/plg/r_conf/UP.png /home/plg/r_conf/UP.h*  /home/plg/doc/ ");
//                        //system(cmd);
//                    }
//                    else
//                    {
//                        //snprintf(cmd,sizeof(cmd),"cp /udisk/r_conf/* /home/plg/r_conf/");   system(cmd);
//                    }

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

//                            snprintf(cmd,sizeof(cmd),"cp /udisk/rcS /etc/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");
                            res = system(cmd);
                            //qDebug()<<cmd;
                            //qDebug()<<"update qt4"<<res;
                    }

                    snprintf(cmd,sizeof(cmd),"cp /udisk/emergency  /home/plg/");
                    res = system(cmd);
                    //qDebug()<<"update emergency"<<res;
                    //qDebug()<<cmd;
                    snprintf(cmd,sizeof(cmd),"chmod a+x /udisk/ss");
                    res = system(cmd);
                    //qDebug()<<"update ss"<<res;

                    //qDebug()<<cmd;
                    snprintf(cmd,sizeof(cmd),"/udisk/ss");
                    res = system(cmd);
                    //qDebug()<<"update ss"<<res;
                    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();

//    QMessageBox::StandardButton ret;
//    ret = QMessageBox::information(this, tr("警告"),
//                                                       tr("是否确认备份系统文件?"),
//                                                       QMessageBox::Ok | QMessageBox::Cancel);
//    if (ret == QMessageBox::Ok){
//            QFile file("/home/plg/conf/sysPara.bin");
//            if(file.exists()){
//                Public::backupPara();
//                QMessageBox::information(this, tr("系统备份"),
//                                             tr("系统备份成功!"));
//            }
//            else {
//                    QMessageBox::critical(this, tr("错误"), tr("备份操作失败!"));
//            }
//    }
}

void SystemManage::on_dialogSysUpdateAuthorizationAccepted()
{

#ifdef MIMA
    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;
     }

#endif

    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);
                //qDebug()<<tr("start");
        } else if (msgBox.clickedButton() == cancleCleanButton) {
                //sysPara->devOp->controlCycleValve(false);
                //sysPara->devOp->controlViscosityPump(false);
                timerHandler2();
                //emit timer2->timeout();


        }
    }
}


void SystemManage::updateSysStatusToUI(){
	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(((PRODUCT_VERSION(sysPara->status.fpgaVersionNum) == JETV3)
            || (PRODUCT_VERSION(sysPara->status.fpgaVersionNum) >= JETV23) //20170830修改主板硬件版本号，以便与主板硬件版本编号对应
            //|| (PRODUCT_VERSION(sysPara->status.fpgaVersionNum) == JETV32)
            )&& (!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();
                //sysPara->SysPara.showDebug(" 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 1
                   //打开粘度泵,循环阀,墨水阀,主墨泵
                   {
                       //sysPara->devOp->controlCompressPump(false);
						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->controlMixValve(false);
                       //sysPara->devOp->controlReclaimPump(false,true);
                       sysPara->devOp->controlViscosityPump(true);
                       //sysPara->devOp->controlReleaseValve(false);
                       sysPara->devOp->mainInkCtrl();
                    }
#endif
                }

            }
            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"));
#if 1
                   //打开粘度泵,混合阀
                    {
                        //--sysPara->devOp->controlCompressPump(false);
                        sysPara->devOp->controlCycleValve(false);  //关循环阀,墨水阀,主墨泵
//LogInfo::setRunStatusText(tr("混合阀打开3:")+QString::number(sysPara->status.viscosity));
                        sysPara->devOp->controlInkValve(false);
                        sysPara->devOp->controlInkValvePWM(false);
                        sysPara->devOp->controlMainInkPump(false);
                        //--sysPara->devOp->controlReclaimPump(false,true);
                        //--sysPara->devOp->controlReleaseValve(false);
                        sysPara->devOp->controlMixValve(true);  //开混合阀
                        sysPara->devOp->controlViscosityPump(true);//开粘度泵
                        sysPara->devOp->mainInkCtrl();
                    }
#endif
#if 0
                    if(sysPara->status.currReclaimTankPos<45){
                        sysPara->devOp->controlReclaimTankOpen(1);  // 开回收槽,下一个定时器(1s后)进来的时候会停止，
                    }
                    else
                    {
                        sysPara->devOp->controlReclaimTankClose(1);  // 关回收槽,下一个定时器(1s后)进来的时候会停止
                    }
#endif

                }
            }
            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/")).toAscii().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/ ")).toAscii().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()
{
    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) {
#if 1
            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);
#endif

            emit autoCleanStart();
            autoCleanTimer->start(1000); // 1000 ms

            dialogAutoClean->show();
            /*
            if(dialogAutoClean->wasCanceled())
            {
                if(autoCleanTimer->isActive())
                    autoCleanTimer->stop();
                dialogAutoClean->hide();
                sysPara->status.autoCleanStatus=AUTOCLEAN_STATUS_NONE;
                sysPara->status.autoCleanTime=0;
                qDebug()<<tr("autoclean stop");
                qDebug()<<tr("autoclean stop")<<"status:"<<sysPara->status.autoCleanStatus;
                return;
            }
            */
        }
    }
}


void SystemManage::on_pushButtonFontToUdisk_pressed()
{
    //
    QMessageBox::StandardButton ret;
    ret = QMessageBox::information(this, tr("警告"),
                           tr("是否确认导出字库到U盘?"),
                           QMessageBox::Ok | QMessageBox::Cancel);
    if (ret == QMessageBox::Ok)
    {
    QFile file("/udisk");
    if(!file.exists()){
        QMessageBox::warning(this,  tr("错误"),
                                     tr("U盘不可识别!"));
        return;
    }

    system((char *)((QString("cp /usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib/fonts/* /udisk/.")).toAscii().data()));
    system((char *)((QString("cp /usr/lib/fonts/* /udisk/.")).toAscii().data()));//am335x
    system((char *)((QString("cp /usr/lib/fonts/* /udisk/.")).toAscii().data()));
    system((char *)((QString("mkdir /udisk/zk")).toAscii().data()));
    system((char *)((QString("cp /opt/zk/* /udisk/zk/ ")).toAscii().data()));
    QMessageBox::information(this, tr("提示"),
                                   tr("字库导出完成!"));
    //emit configChanged();
    }

}

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

#ifdef __AIR_RELEASE_OLD__
    // 粘度泵跟随循环阀动作
    sysPara->devOp->controlViscosityPump(true);
#else
    sysPara->devOp->controlViscosityPump(true);//关闭粘度泵
    sysPara->devOp->controlMixValve(false);
#endif

    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);
    if(manualControl->isActive())
        manualControl->stop();
}


void SystemManage::on_pushButtonChangeScreen_clicked()
{
    QMessageBox::StandardButton ret;
    ret = QMessageBox::information(NULL,tr("提示"), tr("是否确认切换屏幕!"),
                                   QMessageBox::Ok | QMessageBox::Cancel);
    if(ret == QMessageBox::Ok){
        QFile fileIn;
        QString fileName;
        QString fileName2;
        LogInfo::setRunStatusText(tr("flagOfTouchScreenType: %1").arg(flagOfTouchScreenType));
        if(flagOfTouchScreenType){
            fileName = ":/TouchScreenConf/qtui_Resistance";
            fileName2 = ":/TouchScreenConf/calibrate_Resistance";
        }else{
            fileName = ":/TouchScreenConf/qtui_Capacitance";
            fileName2 = ":/TouchScreenConf/calibrate_Capacitance";
        }
        fileIn.setFileName(fileName);
        if(!fileIn.open(QIODevice::ReadOnly)){
            qDebug()<<"open failed"<<fileName;
            LogInfo::setRunStatusText(tr("open %1 failed").arg(fileName));
            return;
        }
        //    QTextStream in(&fileIn);
        //    QString str = in.readAll();
        QByteArray str = fileIn.readAll();
        fileIn.close();

        fileIn.setFileName(fileName2);
        if(!fileIn.open(QIODevice::ReadOnly)){
            qDebug()<<"open failed"<<fileName2;
            LogInfo::setRunStatusText(tr("open %1 failed").arg(fileName2));
            return;
        }
        QByteArray str2 = fileIn.readAll();
        //  std::cout<<"str2:"<<QString(str2).toStdString()<<std::endl;
        fileIn.close();

        QFile fileOut("/etc/init.d/qtui.sh");
        if(!fileOut.open(QIODevice::WriteOnly)){
            qDebug()<<"open /etc/init.d/qtui.sh failed";
            LogInfo::setRunStatusText(tr("open /etc/init.d/qtui.sh failed"));
        }
        //    QTextStream out(&fileOut);
        //    out<<str;
        int len = fileOut.write(str);
        if(len<0){
            qDebug()<<"write /etc/init.d/qtui.sh failed";
            LogInfo::setRunStatusText(tr("write /etc/init.d/qtui.sh failed"));
        }
        fileOut.close();

        fileOut.setFileName("/home/plg/calibrate");
        if(!fileOut.open(QIODevice::WriteOnly)){
            qDebug()<<"open /home/plg/calibrate";
            LogInfo::setRunStatusText(tr("open /home/plg/calibrate failed"));
        }
        int len2 = fileOut.write(str2);
        if(len2<0){
            qDebug()<<"write /home/plg/calibrate failed";
            LogInfo::setRunStatusText(tr("write /home/plg/calibrate failed"));
        }
        fileOut.close();
        QMessageBox::information(this,tr("提示"),tr("切换成功"));
        ui->pushButtonChangeScreen->setEnabled(false);
    }
}

void SystemManage::getCurrentScrennType(){
 //   std::cout<<"std getCurrentScrennType"<<std::endl;
    QFile file("/etc/init.d/qtui.sh");
    if(!file.open(QIODevice::ReadOnly)){
    //    std::cout<<"std open /etc/init.d/qtui.sh failed"<<std::endl;
        qDebug()<<"open /etc/init.d/qtui.sh failed";
        LogInfo::setRunStatusText(tr("open /etc/init.d/qtui.sh failed"));
        ui->pushButtonChangeScreen->setEnabled(false);
        return;
    }
    QTextStream in(&file);
    QString str = in.readAll();
   int index =  str.indexOf("event0");
   if(index != -1){
       //       电阻屏
       flagOfTouchScreenType = 0;
       ui->pushButtonChangeScreen->setText(tr("切换电容屏"));
   }
   else{
       //电容屏
       flagOfTouchScreenType = 1;
       ui->pushButtonChangeScreen->setText(tr("切换电阻屏"));
   }
   file.close();

}