#include "TestService.h"
#include "pid.h"
#include "Modbus.h"
#include<QDateTime>
#include<QTime>
#include<QEventLoop>
#include<QMessageBox>
#include<cmath>
#include <QSignalSpy>
//#include <QAxObject>
//#include <QAxWidget>
#include <QDebug>
//#include <QFileDialog>
//#include <QTextCodec>
//#include <QtCore/QtMath>
#include <QFile>
#include <QDir>




TestService::TestService(QThread *parent)
    :QThread(parent)
    ,m_SerialUi3(nullptr)
    ,m_SerialUi4(nullptr)
    ,m_pTimer_1(nullptr)
    ,m_pTimer_2(nullptr)
    ,m_compartmentid(0)
{

    m_bRunning=false;

    for(int i=0; i<MAX_COMPARTMENT_NUM; i++ ){
        m_tank.m_comparts[i].m_id = i;
    }

    //moveToThread(&m_Thread);
    //connect(this, SIGNAL(operate()), this, SLOT(doTest()));

}
TestService::~TestService()
{

}

void TestService::init()
{
    m_pTimer_1 = new QTimer(this);
     connect(m_pTimer_1, SIGNAL(timeout()), this, SLOT(OnTimer1()));

     //m_pTimer_2 = new QTimer(this);
     // connect(m_pTimer_2, SIGNAL(timeout()), this, SLOT(OnTimer2()));


      if(!m_SerialUi3.serialConnect("COM3", "9600", "8", "0", "1")){
          QString str = "打开串口COM3失败";
          emit onNotice(str);
      }

#if 1
      if(!m_SerialUi4.serialConnect("COM4", "9600", "8", "2", "1")){
          QString str = "打开串口COM4失败";
          emit onNotice(str);
      }
#endif

      connect(&m_report, SIGNAL(onProgress(QString)), this, SLOT(receive_reportprogress(QString)));

}

bool TestService::setTankinfo(const QVariantList& list)
{
    QString  standard_name;
    QString  licenseplate_str;
    QString  companyname_str;
    int compartment_num = 0;
    int total_volume = 0;
    int volume[MAX_COMPARTMENT_NUM] ={0};

    for(int i=0; i<list.count(); i++){
        QString item_string = list[i].toString();
        if(0 == i){
            standard_name = item_string;
        }else if(1 == i){
           licenseplate_str = item_string;
        }else if(2 == i){
            companyname_str = item_string;
        }else if(3 == i){
            total_volume = item_string.toInt();
        }else if(4 == i){
            compartment_num = item_string.toInt();
        }else{
            if(i< (8+5))
                volume[i-5] = item_string.toInt();
        }
    }

     //check invalid
    bool ret_bool = true;

    if( compartment_num > 0 && compartment_num <= MAX_COMPARTMENT_NUM){
        int volume_sum =0;
        for(int i=0; i<compartment_num; i++){
            volume_sum += volume[i];
        }
        if(total_volume != volume_sum){
            ret_bool = false;
        }
    }else{
        ret_bool = false;
    }

    if(true == ret_bool){
        m_standardname = standard_name;
        qDebug("setTankinfo: standard_name:[%s]", standard_name.toStdString().c_str());
        m_tank.licenseplate_str = licenseplate_str;
        qDebug("setTankinfo: licenseplate:[%s]", licenseplate_str.toStdString().c_str());
        m_tank.companyname_str = companyname_str;
        qDebug("setTankinfo: companyname:[%s]", companyname_str.toStdString().c_str());
        m_tank.total_volume = total_volume;
        qDebug("setTankinfo: total_volume:[%d]", total_volume);
        m_tank.compartment_num = compartment_num;
        qDebug("setTankinfo: compartment_num:[%d]", compartment_num);

        Standard standard;
        g_StandardManager->getStandard(m_standardname, standard);
        for(int i=0; i<compartment_num; i++){
            m_tank.m_comparts[i].m_volume = volume[i];
            qDebug("setTankinfo: volume [%d]:[%d]", i, volume[i]);
            for(int j=0; j<standard.item_count; j++){
                if(volume[i] >= standard.item[j].oilcompartment_volume){
                    m_tank.m_comparts[i].m_standarditem = standard.item[j];
                    qDebug("setTankinfo: compart [%d]: volume[%d]", i, standard.item[j].oilcompartment_volume);
                    qDebug("setTankinfo: compart [%d]: sys[%f]", i, standard.item[j].system_threshold);
                    qDebug("setTankinfo: compart [%d]: valve[%f]", i, standard.item[j].valve_threshold);
                }
            }

        }
    }

    return ret_bool;

}


bool TestService::tstart(int compartmentid, int direction)
{
    if(m_bRunning){
        QString str = "当前有任务正在进行中...";
        emit onNotice(str);
        return false;
    }
    m_compartmentid = compartmentid-1;

    if(0 == direction)
        m_direction = Test_Direction_Positive;
    else
        m_direction = Test_Direction_Negative;

    m_stage = Test_Stage_SysTest;
    m_step = Test_Step_Start;

    m_pressuremutex.lock();
    m_pressurelist.clear(); //用来计算平均压力
    m_pressuremutex.unlock();

    QMessageBox::StandardButton result = QMessageBox::information(NULL, "提示：", "请对油气回收系统相关部件进行检查", QMessageBox::Ok|QMessageBox::Abort, QMessageBox::Ok);

    switch (result)
        {
        case QMessageBox::Ok:
            qDebug()<<"Ok";
            m_pTimer_1->start(1*1000);  // 1s
            m_bRunning = true;
            start();
            break;
        case QMessageBox::Abort:
            qDebug()<<"Abort";
             return false;
            break;
        default:
        qDebug()<<"default";
              return false;
            break;
        }

    return true;

}

bool TestService::tselfstart(int compartmentid, int direction)
{
    if(m_bRunning){
        QString str = "当前有任务正在进行中...";
        emit onNotice(str);
        return false;
    }

    m_compartmentid = compartmentid-1;

    if(0 == direction)
        m_direction = Test_Direction_Positive;
    else
        m_direction = Test_Direction_Negative;

    m_stage = Test_Stage_SysTest;
    m_step = Test_Step_Start;

    m_pressuremutex.lock();
    m_pressurelist.clear(); //用来计算平均压力
    m_pressuremutex.unlock();

    QMessageBox::StandardButton result = QMessageBox::question(NULL, "提示：", "系统即将自检，请确认所有部件都己接好", QMessageBox::Ok|QMessageBox::Abort, QMessageBox::Ok);

    switch (result)
    {
    case QMessageBox::Ok:
        qDebug()<<"Ok";
        m_pTimer_1->start(1*1000);  // 1s
        m_bRunning = true;
        start();
        break;
    case QMessageBox::Abort:
        qDebug()<<"Abort";
        return false;
        break;
    default:
        qDebug()<<"default";
          return false;
        break;
    }

    return true;

}

bool TestService::tstop(int compartmentid)
{
    if(m_compartmentid != compartmentid-1){
        return false;
    }

    if(m_pTimer_1->isActive())
        m_pTimer_1->stop();

    //if(m_pTimer_2->isActive())
     //   m_pTimer_2->stop();
    if(m_bRunning){
        //stop();
        m_bRunning = false;
    }

     return true;
}
bool TestService::reportpic_Ready(int compartmentid)
{
    Compartment& com = m_tank.get_compartment(compartmentid-1);
    com.m_bpicReady = true;
    return true;
}

bool TestService::check_alltest_ok()
{
    bool ret_flag = true;
    for(int i=0; i< m_tank.compartment_num; i++){
        Compartment& com = m_tank.get_compartment(i);
        if(com.m_bpicReady == false ){
            ret_flag = false;
            break;
        }
    }

    if(false == ret_flag){
        QMessageBox::StandardButton result = QMessageBox::question(NULL, "提示：", "有油仓还未进行检测，是否强制生成报告？", QMessageBox::Yes|QMessageBox::No, QMessageBox::No);

        switch (result)
            {
            case QMessageBox::Yes:
                ret_flag = true;
                break;
            case QMessageBox::No:
                break;
            default:
                break;
            }

    }

    return ret_flag;

}

void TestService::receive_reportprogress(QString qstr)
{
    qDebug() << "TestService::receive_reportprogress ";
    qDebug() << qstr;
    emit onGenreportProgress(qstr);
}

bool TestService::genReport(QString word_path, QString pic_dir)
{
    if(word_path.contains(".doc")){
        return m_report.make_Word(m_tank, word_path, pic_dir);
    }else if(word_path.contains(".pdf")){
        return m_report.make_PDF(m_tank, word_path, pic_dir);
    }

    QString str = "word_path invalid!";
    qDebug() << str;
    return false;
}

QJsonObject TestService::get_vrs_items()
{
    return m_tank.get_vrs_items();
}

QJsonObject TestService::get_bls_items()
{
    return m_tank.get_bls_items();
}

bool TestService::set_item_result(const QString& jsonStr )
{
    return m_tank.set_item_result(jsonStr);
}

unsigned short TestService::Calcrc(const unsigned char *ptr, int count)
{
    unsigned short crc;
    crc=CRC16_MODBUS((unsigned char *)ptr,count);

    return crc;
}


void TestService::SendCmd(QSerialPort* pSerial, QByteArray data)
{
    int crc;
    //unsigned char buf[128];

    crc=Calcrc((unsigned char *)data.data(),data.size());

    data.append((crc>>8)&0xff);
    data.append(crc&0xff);

    if(pSerial==nullptr)
        return;

    if (pSerial->isOpen())
    {
        pSerial->write(data);

        QString str = QString::fromUtf8("TX: ");
        str.append(data.toHex().toUpper());
        qDebug("[%s]", str.toStdString().c_str());
    }
}

bool TestService::check_crc(QByteArray data)
{
    int size = data.size();
    unsigned short crc1 =0, crc2= 0;
    unsigned char crc_h = data.at(size-2);
    //qDebug("crc_h: %x", crc_h);
    unsigned char crc_l = data.at(size-1);
   // qDebug("crc_l: %x", crc_l);
    crc1 = (crc_h <<8) |crc_l;
   // qDebug("crc1: %x", crc1);

    crc2 = Calcrc((unsigned char *)data.data(),data.size()-2);
    // qDebug("crc2: %x", crc2);

     if(crc1 == crc2){
        return true;
     }else{
         return false;
     }


}

bool TestService::Read_pressure(float& pressure)  //FROM  COM4
{
    QByteArray tx_buf;
    //bool ret_flag = true;
    char zero = 0x00;
    tx_buf.append(PRESSURESENSOR_ADDRESS);
    //tx_buf.append(0x03);
    tx_buf.append(0x04);
    tx_buf.append(zero);
    tx_buf.append(zero);
    tx_buf.append(zero);
    tx_buf.append(0x02);

    int crc;

    crc=Calcrc((unsigned char *)tx_buf.data(),tx_buf.size());

    tx_buf.append((crc>>8)&0xff);
    tx_buf.append(crc&0xff);

    QByteArray rx_buf;
    rx_buf = m_SerialUi4.serialWriteReponse(tx_buf);
    if(rx_buf.size() > 0){
        if(check_crc(rx_buf)){

            char value[4];
            value[3] = rx_buf.at(5);
            value[2] = rx_buf.at(6);
            value[1] = rx_buf.at(3);
            value[0] = rx_buf.at(4);

            float * p = (float*)value;
            pressure = *p;
            qDebug("read pressure , the pressure is [%f]", pressure);

            push_pressurelist(pressure);
            pressure = calculate_averagepressure();
            return true;
        }else{
            //pressure = calculate_averagepressure();
            qDebug("Read_pressure <<< check crc failed");
            return false;
        }
    }else{
        return false;
    }



#if 0
    m_Serial4mutex.lock();
    SendCmd(m_SerialPort4, tx_buf);
    /*
    if(!m_SerialPort4->waitForBytesWritten(200)){

        qDebug("waitForBytesWritten failed");
        m_Serial4mutex.unlock();
        return false;
    }
*/
    QSignalSpy spy(m_SerialPort4, SIGNAL(readyRead()));
    bool ret = spy.wait(650);
    if(ret == true){
        QByteArray buffer = m_SerialPort4->readAll();
        while (spy.wait(50) == true){
            buffer += m_SerialPort4->readAll();
        }

        if(buffer.size() == 9){

            //QString str = QString::fromUtf8("Read_pressure RX: ");
            //str.append(buffer.toHex().toUpper());
            //qDebug("[%s]", str.toStdString().c_str());

            if(!check_crc(buffer)){
                pressure = calculate_averagepressure();
                ret_flag = false;
            }else{

                char value[4];

                value[3] = buffer.at(5);
                value[2] = buffer.at(6);
                value[1] = buffer.at(3);
                value[0] = buffer.at(4);

                float * p = (float*)value;
                pressure = *p;
                qDebug("read pressure , the pressure is [%f]", pressure);

                push_pressurelist(pressure);
                pressure = calculate_averagepressure();
            }


        }else{
            QString str = QString::fromUtf8("Read_pressure less than 9 RX: ");
            str.append(buffer.toHex().toUpper());
            qDebug("[%s]", str.toStdString().c_str());
            pressure = calculate_averagepressure();
            ret_flag = false;
        }
    }
    else{
        qDebug()<<"Read_pressure  time out";
        pressure = calculate_averagepressure();
        ret_flag = false;
    }

    m_Serial4mutex.unlock();
    return ret_flag;
#endif
#if 0

    QEventLoop eventLoop;//局部事件循环，不卡
    QTimer::singleShot(2000, &eventLoop, &QEventLoop::quit);
    QObject::connect(m_SerialPort4, SIGNAL(readyRead()), &eventLoop, SLOT(quit()));
    eventLoop.exec();

   if(m_SerialPort4->bytesAvailable() > 0)
   {
       QByteArray buffer;
       int count = 2;
       while (1)
       {
           buffer += m_SerialPort4->readAll();

           QString str = QString::fromUtf8("Read_pressure RX: ");
           str.append(buffer.toHex().toUpper());
           qDebug("[%s]", str.toStdString().c_str());

           if(buffer.size() == 9){

               QString str = QString::fromUtf8("Read_pressure RX: ");
               str.append(buffer.toHex().toUpper());
               qDebug("[%s]", str.toStdString().c_str());

               if(!check_crc(buffer)){
                   return false;
               }

               char value[4];

               value[3] = buffer.at(5);
               value[2] = buffer.at(6);
               value[1] = buffer.at(3);
               value[0] = buffer.at(4);

               float * p = (float*)value;
               pressure = *p;
               qDebug("read pressure , the pressure is [%f]", pressure);

               push_pressurelist(pressure);
               pressure = calculate_averagepressure();


               return true;
           }else if(buffer.size() > 9){
               QString str = QString::fromUtf8("Read_pressure big than 9 RX: ");
               str.append(buffer.toHex().toUpper());
               qDebug("[%s]", str.toStdString().c_str());
               return false;

           }

           if(!m_SerialPort3->waitForReadyRead(5)){
               count--;
               if(count > 0){
                    break;
               }
           }

       }

       QString str = QString::fromUtf8("Read_pressure timeout  RX: ");
       str.append(buffer.toHex().toUpper());
       qDebug("[%s]", str.toStdString().c_str());

      return false;
   }
   else
   {
       qInfo()<<m_SerialPort4->portName()<<" no answer ";
       QObject::disconnect(m_SerialPort4, SIGNAL(readyRead()), &eventLoop, SLOT(quit()));
       return false;
   }
#endif
}

void TestService::push_pressurelist(float pressure)
{
    m_pressuremutex.lock();

    if(m_pressurelist.size() == AVERAGE_PRESSURE_COUNT){
        m_pressurelist.removeAt(0);
    }
    m_pressurelist.append(pressure);
    m_pressuremutex.unlock();
}
void TestService::clear_pressurelist()
{
    m_pressuremutex.lock();
    m_pressurelist.clear(); //用来计算平均压力
    m_pressuremutex.unlock();
}

float TestService::calculate_averagepressure()
{
    float average = 0.0;

    m_pressuremutex.lock();
    int n = m_pressurelist.size();

    if(n>0){

        float sum = 0.0;
        for(int i=0; i<n; i++){
            sum += m_pressurelist.at(i);
            //qDebug("push_pressurelist 333 size[%f]", m_pressurelist.at(i));
        }
        average = sum/n;
    }

    m_pressuremutex.unlock();

    return average;
}


bool TestService::Adjust_pressure(unsigned short voltage)
{
    QByteArray tx_buf;
    //bool ret_flag = true;

    //char zero = 0x00;

    tx_buf.append(ADJUSTVALVE_ADDRESS);
    tx_buf.append(0x06);
    tx_buf.append(0x20);
    tx_buf.append(0x01);

    char c_high = (voltage>>8)&0xff;
    char c_low = (voltage)&0xff;

    tx_buf.append(c_high);
    tx_buf.append(c_low);

    int crc;

    crc=Calcrc((unsigned char *)tx_buf.data(),tx_buf.size());

    tx_buf.append((crc>>8)&0xff);
    tx_buf.append(crc&0xff);

    QByteArray rx_buf;
    rx_buf = m_SerialUi3.serialWriteReponse(tx_buf);
    if(rx_buf.size() > 0){
        if(check_crc(rx_buf)){
            return true;
        }else{
            return false;
        }
    }else{
        return false;
    }

 #if 0
    m_Serial3mutex.lock();

    SendCmd(m_SerialPort3, tx_buf);
/*
    if(!m_SerialPort3->waitForBytesWritten(100)){

        qDebug("waitForBytesWritten failed");
        m_Serial3mutex.unlock();
        return false;
    }
    */
  #if 1

    QSignalSpy spy(m_SerialPort3, SIGNAL(readyRead()));
    bool ret = spy.wait(500);
    if(ret == true){
        QByteArray buffer;
        //while (m_SerialPort3->waitForReadyRead(5))
        //{
            buffer += m_SerialPort3->readAll();
            //QString str = QString::fromUtf8("adjust_pressure RX: ");
            //str.append(buffer.toHex().toUpper());
            //qDebug("[%s]", str.toStdString().c_str());

            if(!check_crc(buffer)){
                ret_flag = false;
            }
    }else
    {
        qInfo()<<m_SerialPort3->portName()<<" no answer ";
        ret_flag = true;
    }

    m_Serial3mutex.unlock();
    return ret_flag;

#else
    QEventLoop eventLoop;//局部事件循环，不卡界面
    QTimer::singleShot(2000, &eventLoop, &QEventLoop::quit);
    QObject::connect(m_SerialPort3, SIGNAL(readyRead()), &eventLoop, SLOT(quit()));
    eventLoop.exec();

   if(m_SerialPort3->bytesAvailable() > 0)
   {
       QByteArray buffer;
       //while (m_SerialPort3->waitForReadyRead(5))
       //{
           buffer += m_SerialPort3->readAll();
           QString str = QString::fromUtf8("adjust_pressure RX: ");
           str.append(buffer.toHex().toUpper());
           qDebug("[%s]", str.toStdString().c_str());

           if(check_crc(buffer)){
               return true;
           }else{
               return false;
           }
       //}

      //return true;
   }
   else
   {
       qInfo()<<m_SerialPort3->portName()<<" no answer ";
       QObject::disconnect(m_SerialPort3, SIGNAL(readyRead()), &eventLoop, SLOT(quit()));
       return false;
   }

#endif
#endif
}

bool TestService::Valve_op(Valve_ID id, Valve_OP op)
{
    QByteArray tx_buf;
    //bool ret_flag = true;

    char zero = 0x00;
    tx_buf.append(RELAY_ADDRESS);
    if(Valve_ID_All == id){
        tx_buf.append(0x0F);
        tx_buf.append(zero);
        tx_buf.append(zero);
        tx_buf.append(zero);
        tx_buf.append(0x10);
        tx_buf.append(0x02);
    }else{
        tx_buf.append(0x05);
        tx_buf.append(zero);
        tx_buf.append(static_cast<char>(id));
    }

    if(Valve_OP_Open == op){
        tx_buf.append(0xFF);
        tx_buf.append(zero);
     }
     else{
        tx_buf.append(zero);
        tx_buf.append(zero);
     }

    int crc;

    crc=Calcrc((unsigned char *)tx_buf.data(),tx_buf.size());

    tx_buf.append((crc>>8)&0xff);
    tx_buf.append(crc&0xff);

    QByteArray rx_buf;
    rx_buf = m_SerialUi3.serialWriteReponse(tx_buf);
    if(rx_buf.size() > 0){
        if(check_crc(rx_buf)){
            qDebug("Valve_op ok  valve_id[%d], op[%d] ", id, op);
            return true;
        }else{
            qDebug("Valve_op failed  valve_id[%d], op[%d] ", id, op);
            return false;
        }
    }else{
        qDebug("Valve_op failed  valve_id[%d], op[%d] ", id, op);
        return false;
    }

 #if 0
    m_Serial3mutex.lock();
    SendCmd(m_SerialPort3, tx_buf);

    /*
    if(!m_SerialPort3->waitForBytesWritten(100)){

        qDebug("waitForBytesWritten failed");
         m_Serial3mutex.unlock();
         return false;
    }
*/
#if 1

    QSignalSpy spy(m_SerialPort3, SIGNAL(readyRead()));
    bool ret = spy.wait(500);
    if(ret == true){
        QByteArray buffer;
        //while (m_SerialPort3->waitForReadyRead(5))
        //{
            buffer += m_SerialPort3->readAll();
            //QString str = QString::fromUtf8("adjust_pressure RX: ");
            //str.append(buffer.toHex().toUpper());
            //qDebug("[%s]", str.toStdString().c_str());

            if(!check_crc(buffer)){
                ret_flag =  false;
            }
    }else
    {
        qInfo()<<m_SerialPort3->portName()<<" no answer ";
        ret_flag =  false;
    }

    m_Serial3mutex.unlock();
    return ret_flag;

#else
    QEventLoop eventLoop;//局部事件循环，不卡界面
    QTimer::singleShot(2000, &eventLoop, &QEventLoop::quit);
    QObject::connect(m_SerialPort3, SIGNAL(readyRead()), &eventLoop, SLOT(quit()));
    eventLoop.exec();

   if(m_SerialPort3->bytesAvailable() > 0)
   {
       QByteArray ba;
       //while (m_SerialPort3->waitForReadyRead(5))
       //{
           ba += m_SerialPort3->readAll();

           QString str = QString::fromUtf8("adjust_pressure RX: ");
           str.append(ba.toHex().toUpper());
           qDebug("[%s]", str.toStdString().c_str());

           if(check_crc(ba)){
               return true;
           }else{
               return false;
           }

       //}

      //return true;
   }
   else
   {
       qInfo()<<m_SerialPort3->portName()<<" no answer ";
       QObject::disconnect(m_SerialPort3, SIGNAL(readyRead()), &eventLoop, SLOT(quit()));
       return false;
   }

#endif
#endif
}

void TestService::valve_open(Valve_ID id)
{
    qDebug("valve_open [%d]", id);

    Valve_op(id, Valve_OP_Open);
}

void TestService::valve_close(Valve_ID id)
{
    qDebug("valve_close [%d]", id);

    Valve_op(id, Valve_OP_Close);
}

QString TestService::read_PressureValue()
{
    float pressure = 0.0;
    static int timeout_count =0;
    if(Read_pressure(pressure)){
        //qDebug("Read_PressureValue [%f]", pressure);
        timeout_count=0;
    }else{

        pressure = calculate_averagepressure();
        qDebug("Read_PressureValue failed");
        timeout_count++;
        if(timeout_count >= AVERAGE_PRESSURE_COUNT){
            //data is to old, clear
            clear_pressurelist();
            qDebug("clear_pressurelist ");
        }

    }

    QString pressure_str = QString("%1").arg(pressure, 5,'f',3,QLatin1Char('0'));
    return pressure_str;

}


void TestService::adjust_Pressure(QString voltage_str)
{
    bool ok;
    ushort voltage = voltage_str.toUShort(&ok, 10);
    qDebug("Add_Pressure [%d]", voltage);
    Adjust_pressure(voltage);
}


bool TestService::OpenSerial3()
{
    m_SerialPort3 = new QSerialPort();
    m_SerialPort3->setPortName("COM3");
    m_SerialPort3->setBaudRate(9600, QSerialPort::AllDirections);
    m_SerialPort3->setDataBits(QSerialPort::Data8);
    m_SerialPort3->setParity(QSerialPort::NoParity);
    m_SerialPort3->setStopBits(QSerialPort::OneStop);
    //m_SerialPort3->setFlowControl(QSerialPort::NoFlowControl);//Set to no flow control

    if (m_SerialPort3->open(QIODevice::ReadWrite) == false){
        qDebug("open COM3 failed");
        //QMessageBox::warning(this, "警告", "打开串口COM3失败");

        QString str = "打开串口COM3失败";
        emit onNotice(str);
        return false;
    }
    else
    {
        //controlserial->close();
        //connect(m_SerialPort3,SIGNAL(readyRead()),this,SLOT(ReadSerialport3()));
        return true;
    }
}

bool TestService::OpenSerial4()
{
    m_SerialPort4 = new QSerialPort();
    m_SerialPort4->setPortName("COM4");
    m_SerialPort4->setBaudRate(9600, QSerialPort::AllDirections);
    m_SerialPort4->setDataBits(QSerialPort::Data8);
    m_SerialPort4->setParity(QSerialPort::EvenParity);
    m_SerialPort4->setStopBits(QSerialPort::OneStop);
    m_SerialPort4->setFlowControl(QSerialPort::NoFlowControl);//Set to no flow control

    if (m_SerialPort4->open(QIODevice::ReadWrite) == false){
        qDebug("open COM4 failed");
        //QMessageBox::warning(this, "警告", "打开串口COM4失败");

        QString str = "打开串口COM4失败，无法读取压力";
        emit onNotice(str);
        return false;
    }
    else
    {
        //readserial->close();
        //connect(m_SerialPort4,SIGNAL(readyRead()),this,SLOT(ReadSerialport4()));
        return true;
    }
}


void TestService::OnTimer1()
{
    float pressure = 0.001;
    static int timeout_count =0;
    if(Read_pressure(pressure)){
    //if(false){
        //qDebug("Read_PressureValue [%f]", pressure);
        timeout_count=0;
    }else{

        qDebug("Read_PressureValue failed");
        pressure = calculate_averagepressure();
        timeout_count++;
        if(timeout_count >= AVERAGE_PRESSURE_COUNT){
            //data is to old, clear
            clear_pressurelist();
            qDebug("clear_pressurelist ");
        }
    }
#if 0
    if(timeout_count < 180){
        m_stage =Test_Stage_SysTest;
        m_step = Test_Step_Start;
        //pressure = 0.1 * timeout_count;
        if(timeout_count > 60){
            m_step = Test_Step_KeepPressure;
            //pressure = 0.1 * timeout_count;
        }
    }else if(timeout_count < 360){
        if(timeout_count == 180){
            m_tank.m_comparts[m_compartmentid].m_result.sysstart_pressure = 4.5;
            m_tank.m_comparts[m_compartmentid].m_result.sysend_pressure = 4.3;
            m_tank.m_comparts[m_compartmentid].m_result.delta_sys_pressure = 0.2;
            m_tank.m_comparts[m_compartmentid].m_result.pass_sys_pressure = true;
            m_tank.m_comparts[m_compartmentid].m_result.sys_test_ok = true;
        }
        m_stage =Test_Stage_ValveTest;
        m_step = Test_Step_Start;
        //pressure = 0.1 * timeout_count;
        if(timeout_count > 240){
            m_step = Test_Step_KeepPressure;
            //pressure = 0.1 * timeout_count;
        }
    }else {

        if(timeout_count == 360){
            m_tank.m_comparts[m_compartmentid].m_result.valvestart_pressure = 4.5;
            m_tank.m_comparts[m_compartmentid].m_result.valveend_pressure = 3.3;
            m_tank.m_comparts[m_compartmentid].m_result.delta_valve_pressure = 1.2;
            m_tank.m_comparts[m_compartmentid].m_result.pass_valve_pressure = true;
            m_tank.m_comparts[m_compartmentid].m_result.valve_test_ok = true;
        }

        m_step = Test_Step_End;
    }

    //pressure = 0.1 * timeout_count;
    pressure = 3 + 3*sin(M_PI*timeout_count/60);
#endif

    int _ipressure = pressure*100;
    pressure = _ipressure/100.0;

    QString pressure_str = QString("%1").arg(pressure, 4,'f',2,QLatin1Char('0'));

    PressureItem item;
    //item.m_pressure = pressure_str;
    item.m_testDirection = m_direction;
    item.m_testStage = m_stage;
    item.m_testStep = m_step;

    QVariantMap map;
    map.clear();

    map.insert("pressure", pressure_str);
    map.insert("direction", item.m_testDirection);
    map.insert("stage", item.m_testStage);
    map.insert("step", item.m_testStep);


    //QString pressure_str = QString("%1").arg(pressure, 5,'f',3,QLatin1Char('0'));
    //m_tank.m_comparts[m_compartmentid].m_currentpressure= pressure_str.toFloat();
    emit sigPressure(m_compartmentid+1, map);

}

void TestService::OnTimer2()
{
    qDebug("OnTimer2 >>>enter ");
    //float pressure;
    //Read_pressure(pressure);

    QThread::sleep(5);

    //emit Pressure_changed(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));
    qDebug("OnTimer2 >>>leave ");
}

Ret_Value  TestService::Pressure_RoughAdjust(const TestExpect& expect)
{
    Ret_Value ret_v = Ret_OK;
    int count = 0;

    bool bOpen1 = false;
    bool bOpen2 = false;
    bool bOpen3 = false;

   QElapsedTimer  timer;
   timer.start();
   float current_pressure;

   //等待压力达到目标值附近
   while(m_bRunning){

        current_pressure = calculate_averagepressure();

        if(current_pressure >=  expect.target+0.1){

            count++;

            if(bOpen1){
                if(Valve_op(Valve_ID_ROUGH_0, Valve_OP_Close))
                    bOpen1 = false;
            }

            if(bOpen2){
                if(Valve_op(Valve_ID_ROUGH_1, Valve_OP_Close))
                    bOpen2 = false;
            }

            if(bOpen3){
                if(Valve_op(Valve_ID_ROUGH_2, Valve_OP_Close))
                    bOpen3 = false;
            }

            //break;
        }else if(current_pressure < expect.target) {

            count =0;

            if(!bOpen1){
                bOpen1 = Valve_op(Valve_ID_ROUGH_0, Valve_OP_Open);
            }

            if(!bOpen2){
                bOpen2 = Valve_op(Valve_ID_ROUGH_1, Valve_OP_Open);
            }

            if(!bOpen3){
                bOpen3 = Valve_op(Valve_ID_ROUGH_2, Valve_OP_Open);
            }

        }else{
            count++;
        }

        if(count >= 240){ //about 60s
            break;
        }

        QThread::msleep(500);

        int remainingtime = expect.timeout*1000 - timer.elapsed();
        if(remainingtime <= 0){

            qDebug(" add_pressure timeout, Rough valve will colse");
            ret_v = Ret_Timeout;
            break;
        }

   }

   if(!m_bRunning){
       // be stoped
       ret_v = Ret_Exit;
   }

   if(bOpen1){
       if(Valve_op(Valve_ID_ROUGH_0, Valve_OP_Close))
           bOpen1 = false;
   }

   if(bOpen2){
       if(Valve_op(Valve_ID_ROUGH_1, Valve_OP_Close))
           bOpen2 = false;
   }

   if(bOpen3){
       if(Valve_op(Valve_ID_ROUGH_2, Valve_OP_Close))
           bOpen3 = false;
   }

   return ret_v;

}


#if 1
Ret_Value  TestService::Pressure_Adjust(const TestExpect& expect)
{
    PID pid = PID(1, 20, -10, 5.1, 28.0, 1.0);

    float current_pressure;
    Ret_Value ret_v = Ret_OK;
    int voltage_offset = 0;
    int keep_times = 0;
    QElapsedTimer  timer;

    Valve_op(Valve_ID_INTAKE, Valve_OP_Open);
    timer.start();

    while(m_bRunning){

        current_pressure = calculate_averagepressure();

        double inc = pid.calculate(expect.target, current_pressure);

        voltage_offset = (inc);

        if(!Adjust_pressure(expect.start_voltage+voltage_offset)){
            QThread::msleep(200);
            if(!Adjust_pressure(expect.start_voltage+voltage_offset)){
                qDebug("communication error, ajust_pressure failed");
                ret_v = Ret_Failed;
                break;
            }
        }

        if(abs(current_pressure - (expect.target+0.05)) < 0.05){
            keep_times++;
        }else{
            keep_times=0;
        }

        if(keep_times >= 15){
            break;
        }

        QThread::msleep(1000);



        int remainingtime = expect.timeout*1000 - timer.elapsed();
        if(remainingtime < 0){
            ret_v = Ret_Timeout;
            qDebug("timeout, ajust_pressure failed");
            break;
        }
    }

     Valve_op(Valve_ID_INTAKE, Valve_OP_Close);

    if(!m_bRunning){
        // be stoped
        ret_v = Ret_Exit;
    }

    return ret_v;

}
#else
int  TestService::Pressure_Adjust(const TestExpect& expect)
{

    float current_pressure;
    int keep_times = 0;
    bool bValveOpen = false;
    int add_base = 5;
    int sub_base = 0;


    float delta = 0.0; //当前差值
    keep_times = 0;
    int count_h = 0;
    int count_l =0;
    short voltage_offset = 0;
    QElapsedTimer  timer;
    timer.start();
    int ret_value = 0;
    keep_times=0;

    while(m_bRunning){

        current_pressure = calculate_averagepressure();
        if(current_pressure >= expect.target-0.04){
            count_l = 0;
            delta = current_pressure - expect.target;
            if(delta >= 0.08){
                keep_times=0;
                count_h++;

                if(count_h < 30){

                    if(bValveOpen){
                        if(Valve_op(Valve_ID_INTAKE, Valve_OP_Close))
                            bValveOpen = false;

                        qDebug("ajust_pressure IntakeValve close return[%d] ",  bValveOpen == true? 1:0);
                    }

                }

                qDebug("ajust_pressure  count_h[%d] ",  count_h);

                if(count_h > 30){

                    voltage_offset = 0;
                    qDebug("ajust_pressure ,  voltage: %d \n", expect.start_voltage+voltage_offset);

                    if(!Adjust_pressure(expect.start_voltage+voltage_offset)){
                        QThread::msleep(200);
                        if(!Adjust_pressure(expect.start_voltage+voltage_offset)){
                            qDebug("communication error, ajust_pressure failed");
                        }
                    }

                    if(false == bValveOpen){

                        bValveOpen = Valve_op(Valve_ID_INTAKE, Valve_OP_Open);
                        qDebug("ajust_pressure IntakeValve open return[%d] ",  bValveOpen == true? 1:0);
                    }
                }


            }else{

                keep_times++;
                //count_h=0;
                if(count_h > 30){
                    if(delta > 0.05){
                        if(bValveOpen){
                            if(Valve_op(Valve_ID_INTAKE, Valve_OP_Close))
                                bValveOpen = false;
                        }
                    }else if(){

                    }
                }

            }


        }else {
            keep_times=0;
            count_h=0;
            count_l++;
            delta = expect.target - current_pressure;
            if(delta > 0.0){

                int k = count_l/30;

                if(voltage_offset != (add_base+k*1)){

                    voltage_offset = add_base+k*1;
                    //add_base = voltage_offset;
                    qDebug("ajust_pressure   voltage: %d \n", expect.start_voltage+voltage_offset);
                    if(!Adjust_pressure(expect.start_voltage+voltage_offset)){
                        QThread::msleep(200);
                        if(!Adjust_pressure(expect.start_voltage+voltage_offset)){
                            qDebug("communication error, ajust_pressure failed");
                        }
                    }

                }

                if(false == bValveOpen){

                    bValveOpen = Valve_op(Valve_ID_INTAKE, Valve_OP_Open);
                    qDebug("ajust_pressure IntakeValve open return[%d] ",  bValveOpen == true? 1:0);
                }
            }

        }

        qDebug("ajust_pressure keep_times [%d] ",  keep_times);

        if(keep_times >= 30){
            break;
        }

        QThread::msleep(500);

        int remainingtime = expect.timeout*1000 - timer.elapsed();
        if(remainingtime < 0){
            ret_value = -1;
            qDebug("timeout, ajust_pressure failed");
            break;
        }
    }

    if(!m_bRunning){
        // be stoped
        return 1;
    }

    return ret_value;

}

#endif

Ret_Value  TestService::Pressure_Relief(const TestExpect& expect)
{
    Ret_Value ret_v = Ret_OK;
    //打开泄压阀
    if(!Valve_op(Valve_ID_VENT, Valve_OP_Open)){
        QThread::msleep(200);
        if(!Valve_op(Valve_ID_VENT, Valve_OP_Open)){
            qDebug("Pressure_Relief faile, valve communicate failed");
            ret_v = Ret_Failed;
            return ret_v;
        }
    }
     //等待压力清零

    float last_pressure = calculate_averagepressure();
    float current_pressure;
    int keep_count = 0;
    while(m_bRunning){
        QThread::msleep(1000);
        current_pressure = calculate_averagepressure();
        if(abs(current_pressure-last_pressure) < 0.02){
            keep_count++;
            if(keep_count > 15){
                break;
            }
        }else{
            keep_count = 0;
        }

        last_pressure = current_pressure;
    }

     //关闭泄压阀
     if(!Valve_op(Valve_ID_VENT, Valve_OP_Close)){
         if(!Valve_op(Valve_ID_VENT, Valve_OP_Close)){
             qDebug("Pressure_Relief faile, valve communicate failed");
             ret_v = Ret_Failed;
             return ret_v;
         }
     }

    if(!m_bRunning){
        ret_v = Ret_Exit;
    }

    return ret_v;
}

Ret_Value  TestService::Pressure_Keep(int keeptime, float threshold, float& delta)
{
    int count = 0;
    Ret_Value ret_v = Ret_OK;
    float  start_pressure =  calculate_averagepressure();

    while((count < keeptime) && m_bRunning){

       QThread::msleep(1000);
       count++;

    }

    if(!m_bRunning){
        // be stoped
        //return 1;
        ret_v = Ret_Exit;
    }else{

        delta = start_pressure - calculate_averagepressure();

        if(abs(delta) <= threshold){

            ret_v = Ret_OK;
        }else{
            ret_v = Ret_Failed;
        }
    }

    return ret_v;

}

int TestService::make_messagebox(Test_Direction direction, Test_Step step, Ret_Value ret_v)
{
    int ret_btn = QMessageBox::NoButton;
    QString notice_str;

    if(Test_Direction_Positive == direction){

        switch(step){
        case Test_Step_AddPressure:
            if(Ret_Timeout == ret_v){
                notice_str = "加压超时， 是否重试？";
                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Retry|QMessageBox::Abort,  QMessageBox::Retry);
            }else if(Ret_Failed == ret_v){
                notice_str = "继电器通信失败, 和序终止";
                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Ok,  QMessageBox::Ok);
            }

            break;
        case Test_Step_AdjustPressure:
            if( Ret_Timeout == ret_v ){
                notice_str = "比例阀调压精调超时, 是否重试？";
                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Retry|QMessageBox::Abort,  QMessageBox::Retry);
                //emit onNotice(notice_str);
            }else if(Ret_Failed == ret_v){
                notice_str = "继电器通信失败， 程序终止";
                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Ok,  QMessageBox::Ok);
                //emit onNotice(notice_str);
            }
            break;
        default:
            break;

        }

    }else {


    }

    return ret_btn;
}



void TestService::run()
{
    qDebug("doTest >>>enter ");
    QString notice_str;
    QElapsedTimer  q_time;
    int ret_btn = QMessageBox::NoButton;
    TestExpect texpect;
    bool bQuit = false;

    q_time.start();
    Ret_Value ret_v = Ret_OK;

#if 0

    while(m_bRunning){

        QThread::sleep(4);
        int ret = m_msgbox.warning(NULL, "提示：", "请打开旋拧阀给系统加压", QMessageBox::Retry|QMessageBox::Abort, QMessageBox::Abort);
        switch (ret)
        {
        case QMessageBox::Ok:
            qDebug()<<"111 OK";
            break;
        case QMessageBox::Retry:
            qDebug()<<"111 Retry";
            break;
        case QMessageBox::Abort:
            qDebug()<<"111 Abort";
            break;
        default:
            qDebug()<<"111 default";
            break;
        }

    }

#else

    if(m_compartmentid >= 0){

        if(m_direction == Test_Direction_Positive){

            while(m_bRunning && (bQuit == false)){

                switch(m_step){

                case Test_Step_Start:
                    {
                        m_tank.get_compartment(m_compartmentid).clear_result();
                        // close all valves
                         Valve_op(Valve_ID_All, Valve_OP_Close);
                         ret_btn = m_msgbox.information(NULL, "提示：", "请打开旋拧阀给系统加压", QMessageBox::Ok, QMessageBox::Ok);
                         switch (ret_btn)
                         {
                         case QMessageBox::Ok:
                             qDebug()<<"Yes";
                             // 打开压力传感阀
                             Valve_op(Valve_ID_PRESSURESENSOR, Valve_OP_Open);

                             // 如果容积大于 1000L , 才进入粗调步骤
                             if(m_tank.get_compartment(m_compartmentid).m_volume >= 1000){
                                 m_step = Test_Step_AddPressure;
                             }else{
                                 m_step = Test_Step_AdjustPressure;
                             }

                             break;
                         default:
                             break;
                         }
                    }

                    break;
                case Test_Step_AddPressure:
                    {
                        if(m_stage == Test_Stage_SysTest){
                            emit sigState(m_compartmentid+1, "回收系统测试,开始加压", "");
                        }else{
                            emit sigState(m_compartmentid+1, "回收阀测试,开始加压", "");
                        }

                        texpect.target = 4.50;
                        texpect.timeout = m_tank.m_comparts[m_compartmentid].get_Roughadjust_timeout();
                        ret_v = Pressure_RoughAdjust(texpect);
                        if(Ret_OK == ret_v){
                            //m_step = Test_Step_AdjustPressure;
                            //m_step = Test_Step_KeepPressure;
                            if(m_stage == Test_Stage_SysTest){
                                m_step = Test_Step_KeepPressure;
                            }else if(m_stage == Test_Stage_ValveTest){
                                m_step = Test_Step_reliefPressure;
                            }

                        }else if(Ret_Exit == ret_v){
                            bQuit = true;
                        }else{
                            ret_btn = make_messagebox(m_direction, m_step, ret_v);
                            switch (ret_btn)
                            {
                            case QMessageBox::Retry:
                                qDebug()<<"Retry";

                                break;
                            case QMessageBox::Abort:
                                qDebug()<<"Abort";
                                bQuit = true;
                                break;
                            case QMessageBox::Ok:
                                qDebug()<<"OK";
                                bQuit = true;
                                break;
                            default:
                                break;
                            }

                        }

#if 0
                        if(ret_v < 0){
                            ret_btn = QMessageBox::NoButton;
                            if( -1 == state ){
                                notice_str = "加压超时， 是否重试？";
                                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Retry|QMessageBox::Abort,  QMessageBox::Retry);
                                //emit onNotice(notice_str);
                            }else if(-2 == state){
                                notice_str = "继电器读写不成功, 和序终止";
                                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Ok,  QMessageBox::Ok);
                                //emit onNotice(notice_str);
                            }
                            qDebug() << notice_str;

                            //ret_btn = QMessageBox::information(NULL, "提示：", notice_str, QMessageBox::Yes|QMessageBox::No,  QMessageBox::Yes);
                            switch (ret_btn)
                            {
                            case QMessageBox::Retry:
                                qDebug()<<"Retry";

                                break;
                            case QMessageBox::Abort:
                                qDebug()<<"Abort";
                                bQuit = true;
                                break;
                            case QMessageBox::Ok:
                                qDebug()<<"OK";
                                bQuit = true;
                                break;
                            default:
                                break;
                            }

                        }else{
                            m_step = Test_Step_AdjustPressure;
                        }
#endif

                    }
                    break;
                case Test_Step_AdjustPressure:
                    {

                        if(m_stage == Test_Stage_SysTest){
                            emit sigState(m_compartmentid+1, "回收系统测试,开始调压", "");
                        }else{
                            emit sigState(m_compartmentid+1, "回收阀测试,开始调压", "");
                        }


                        texpect.start_voltage = 175;
                        texpect.target = 4.50;
                        texpect.timeout = m_tank.m_comparts[m_compartmentid].get_adjust_timeout();
                        ret_v = Pressure_Adjust(texpect);
                        if(Ret_OK == ret_v){
                            if(m_stage == Test_Stage_SysTest){
                                m_step = Test_Step_KeepPressure;
                            }else if(m_stage == Test_Stage_ValveTest){
                                m_step = Test_Step_reliefPressure;
                            }

                        }else if(Ret_Exit == ret_v){
                            bQuit = true;
                        }else{
                            ret_btn = make_messagebox(m_direction, m_step, ret_v);
                            switch (ret_btn)
                            {
                            case QMessageBox::Retry:
                                qDebug()<<"Retry";

                                break;
                            case QMessageBox::Abort:
                                qDebug()<<"Abort";
                                bQuit = true;
                                break;
                            case QMessageBox::Ok:
                                qDebug()<<"OK";
                                bQuit = true;
                                break;
                            default:
                                break;
                            }


                        }


#if 0
                        if(state < 0){
                            ret_btn = QMessageBox::NoButton;
                            if( -1 == state ){
                                notice_str = "比例阀调压超时, 是否重试？";
                                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Retry|QMessageBox::Abort,  QMessageBox::Retry);
                                //emit onNotice(notice_str);
                            }else if(-2 == state){
                                notice_str = "继电器读写不成功， 程序终止";
                                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Ok,  QMessageBox::Ok);
                                //emit onNotice(notice_str);
                            }

                            qDebug() << notice_str;

                            //ret_btn = QMessageBox::information(NULL, "提示：", notice_str, QMessageBox::Yes|QMessageBox::No,  QMessageBox::Yes);
                            switch (ret_btn)
                            {
                            case QMessageBox::Retry:
                                qDebug()<<"Retry";

                                break;
                            case QMessageBox::Abort:
                                qDebug()<<"Abort";
                                bQuit = true;
                                break;
                            case QMessageBox::Ok:
                                qDebug()<<"OK";
                                bQuit = true;
                                break;
                            default:
                                break;
                            }

                        }else{
                            if(m_stage == Test_Stage_SysTest){
                                m_step = Test_Step_KeepPressure;
                            }else if(m_stage == Test_Stage_ValveTest){
                                m_step = Test_Step_reliefPressure;
                            }
                        }
#endif

                    }

                    break;
                case Test_Step_KeepPressure:
                    {
                        if(m_stage == Test_Stage_SysTest){
                            emit sigState(m_compartmentid+1, "回收系统测试,开始保压", "");
                        }else{
                            emit sigState(m_compartmentid+1, "回收阀测试,开始保压", "");
                        }

                        // 检测 5分钟都没超限，就是通过了
                        float delta = 0;
                        float threshold = 0.0;
                        bool bPassed = true;

                        if(m_stage == Test_Stage_SysTest){

                            threshold = m_tank.m_comparts[m_compartmentid].m_standarditem.system_threshold;
                            m_tank.m_comparts[m_compartmentid].m_result.sysstart_pressure = calculate_averagepressure();
                            ret_v = Pressure_Keep(5*60, threshold, delta);
                            m_tank.m_comparts[m_compartmentid].m_result.sysend_pressure = calculate_averagepressure();

                            m_tank.m_comparts[m_compartmentid].m_result.delta_sys_pressure = delta;

                            if(Ret_Exit == ret_v){

                                bQuit = true;
                            } else {

                                if(Ret_OK == ret_v){
                                    //正压测试通过
                                    bPassed = true;
                                    m_tank.m_comparts[m_compartmentid].m_result.pass_sys_pressure = true;

                                } else{
                                    //notice_str = "油气回收系统密封性,测试未通过";
                                    bPassed = false;
                                    m_tank.m_comparts[m_compartmentid].m_result.pass_sys_pressure = false;
                                }

                                m_tank.m_comparts[m_compartmentid].m_result.sys_test_ok = true;

                                QString delta_str = QString("%1").arg(delta, 4,'f',2,QLatin1Char('0'));
                                emit sigSystemResult(m_compartmentid+1, delta_str, bPassed);
                                emit sigState(m_compartmentid+1, "回收系统检测,结束", "");

                                ret_btn = QMessageBox::NoButton;
                                notice_str = "系统密闭性已经检测完成，是否进行阀门密闭性检测？";
                                ret_btn = m_msgbox.information(NULL, "提示：",  notice_str, QMessageBox::Yes|QMessageBox::No,  QMessageBox::Yes);
                                switch (ret_btn)
                                {
                                case QMessageBox::Yes:
                                    m_stage = Test_Stage_ValveTest;
                                    if(calculate_averagepressure() < 4.50){
                                        m_step = Test_Step_AddPressure;
                                    }else{
                                        m_step = Test_Step_reliefPressure; //如果压力还在4.5以上， 可以不调压
                                    }

                                    break;
                                case QMessageBox::No:
                                    m_step = Test_Step_End;
                                    break;
                                default:
                                    break;
                                }


                            }


                        }else{
                            threshold = m_tank.m_comparts[m_compartmentid].m_standarditem.valve_threshold;
                            m_tank.m_comparts[m_compartmentid].m_result.valvestart_pressure = calculate_averagepressure();
                            ret_v = Pressure_Keep(5*60, threshold, delta);
                            m_tank.m_comparts[m_compartmentid].m_result.valveend_pressure = calculate_averagepressure();

                            m_tank.m_comparts[m_compartmentid].m_result.delta_valve_pressure = delta;

                            if(Ret_Exit == ret_v){
                                bQuit = true;
                            }else {
                                if(Ret_OK == ret_v){
                                    m_tank.m_comparts[m_compartmentid].m_result.pass_valve_pressure = true;
                                    bPassed = true;
                                }else{
                                    m_tank.m_comparts[m_compartmentid].m_result.pass_valve_pressure = false;
                                    bPassed = false;
                                }
                                m_tank.m_comparts[m_compartmentid].m_result.valve_test_ok = true;

                                QString delta_str = QString("%1").arg(delta, 4,'f',2,QLatin1Char('0'));
                                emit sigValveResult(m_compartmentid+1, delta_str, bPassed);
                                emit sigState(m_compartmentid+1, "回收阀测试,结束", "");

                                m_step = Test_Step_End;
                            }

                        }



                    }
                    break;
                case Test_Step_reliefPressure:
                    {
                        ret_btn = m_msgbox.information(NULL, "提示：", "请确认已经关闭油气回收阀。", QMessageBox::Ok, QMessageBox::Ok);
                        switch (ret_btn)
                        {
                        case QMessageBox::Ok:
                            break;
                        default:
                            break;
                        }

                        if(m_stage == Test_Stage_SysTest){
                            emit sigState(m_compartmentid+1, "油气回收系统测试,开始泄压", "");
                        }else{
                            emit sigState(m_compartmentid+1, "油气回收阀测试,开始泄压", "");
                        }

                        texpect.start_voltage = 0;
                        texpect.target = 0.0;
                        texpect.timeout = 0;//m_tank.m_comparts[m_compartmentid].get_adjust_timeout();
                        ret_v = Pressure_Relief(texpect);
                        if(Ret_Exit == ret_v){
                            bQuit = true;
                        }else if(Ret_OK == ret_v){
                            m_step = Test_Step_KeepPressure;

                        }else{

                            ret_btn = QMessageBox::NoButton;
                            if(Ret_Timeout == ret_v){
                                notice_str = "泄压超时, 是否重试？";
                                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Retry|QMessageBox::Abort,  QMessageBox::Retry);
                            }else{
                                notice_str = "继电器通信失败， 程序终止";
                                ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Ok,  QMessageBox::Ok);
                            }

                            switch (ret_btn)
                            {
                            case QMessageBox::Retry:
                                break;
                            case QMessageBox::Abort:
                                bQuit = true;
                                break;
                            case QMessageBox::Ok:
                                bQuit = true;
                                break;
                            default:
                                break;
                            }

                        }


                    }
                    break;
                default:
                    break;
                }


                if(Test_Step_End == m_step){
                    break;
                }

            }


        }else{
            //负压测试， 暂不支持
            m_stage = Test_Stage_SysTest;
            qDebug(" negative test is not support now  ");
        }

    }else{
        //self test
        if(m_direction == Test_Direction_Positive){

             while(m_bRunning && (bQuit == false)){

                 switch(m_step){
                     case Test_Step_Start:
                         {
                            emit sigState(m_compartmentid+1, "开始", "");

                             int errors = 0;
                             // close all valves
                              errors = Valve_op(Valve_ID_All, Valve_OP_Close)? 0:1;

                              if(errors > 0){
                                ret_btn = m_msgbox.information(NULL, "提示：", "继电器通信故障，请终止程序", QMessageBox::Abort, QMessageBox::Abort);
                              }else{
                                ret_btn = m_msgbox.information(NULL, "提示：", "请确认已经打开旋拧阀给系统施缓慢加压", QMessageBox::Ok, QMessageBox::Ok);
                              }

                              switch (ret_btn)
                              {
                               case QMessageBox::Ok:
                                  qDebug()<<"Yes";
                                  // 打开压力传感阀
                                  Valve_op(Valve_ID_PRESSURESENSOR, Valve_OP_Open);
                                  m_step = Test_Step_AdjustPressure;
                                  break;
                               case QMessageBox::Abort:
                                    bQuit = true;
                                  break;
                              }
                         }

                         break;
                      case Test_Step_AdjustPressure:
                         {
                             emit sigState(m_compartmentid+1, "调压", "");
                             QThread::msleep(2000);

                             texpect.start_voltage = 175;
                             texpect.target = 4.50;
                             texpect.timeout = 10*60; //10分钟
                             ret_v = Pressure_Adjust(texpect);

                             if(Ret_Exit == ret_v){
                                bQuit = true;
                             }else if(Ret_OK == ret_v){
                                m_step = Test_Step_KeepPressure;
                             }else{

                                 ret_btn = QMessageBox::NoButton;
                                if(Ret_Timeout == ret_v){
                                    notice_str = "比例阀调压超时, 是否重试？";
                                    ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Retry|QMessageBox::Abort,  QMessageBox::Retry);
                                }else{
                                    notice_str = "继电器通信失败， 程序终止";
                                    ret_btn = m_msgbox.information(NULL, "提示：", notice_str, QMessageBox::Ok,  QMessageBox::Ok);
                                }

                                switch (ret_btn)
                                {
                                case QMessageBox::Retry:
                                    break;
                                case QMessageBox::Abort:
                                    bQuit = true;
                                    break;
                                case QMessageBox::Ok:
                                    bQuit = true;
                                    break;
                                default:
                                    break;
                                }

                             }

                         }
                        break;
                     case Test_Step_KeepPressure:
                         {
                             emit sigState(m_compartmentid+1, "保压", "");

                             // 检测 5分钟都没超限，就是通过了
                             float delta = 0;
                             float threshold = 0.2;
                             bool bPassed = true;

                             ret_v = Pressure_Keep(5*60, threshold, delta);

                             if(Ret_Exit == ret_v){
                                bQuit = true;
                             }else{
                                 if(Ret_OK == ret_v){
                                    bPassed = true;
                                 }else{
                                    bPassed = false;
                                 }

                                 QString delta_str = QString("%1").arg(delta, 4,'f',2,QLatin1Char('0'));
                                 emit sigSelfTestResult(m_compartmentid+1, delta_str, bPassed);
                                 emit sigState(m_compartmentid+1, "结束", "");

                                 m_step = Test_Step_End;
                             }



                         }
                         break;
                      default:
                         break;
                 }

                 if(Test_Step_End == m_step){
                    break;
                 }

             }

        }else{ //negtive

        }

    }

    if(Test_Step_End == m_step){
        ret_btn = m_msgbox.information(NULL, "提示：", "栓测任务结束，是否要泄压？", QMessageBox::Yes|QMessageBox::No, QMessageBox::Yes);
    }else{
        if(true == bQuit){
            if(Ret_Exit == ret_v){ // 主动退出
                ret_btn = m_msgbox.information(NULL, "提示：", "程序退出，是否要泄压？", QMessageBox::Yes|QMessageBox::No, QMessageBox::Yes);
            }else if(Ret_Timeout == ret_v){  // 超时退出
                ret_btn = m_msgbox.information(NULL, "提示：", "程序退出，是否要泄压？", QMessageBox::Yes|QMessageBox::No, QMessageBox::Yes);
            }else{//通信错误退出
                ret_btn = m_msgbox.information(NULL, "提示：", "程序退出，是否要泄压？", QMessageBox::Yes|QMessageBox::No, QMessageBox::Yes);
            }
        }

    }


    switch (ret_btn)
    {
    case QMessageBox::Yes:
        qDebug()<<"Yes";
        // 打开泄压阀
        Valve_op(Valve_ID_VENT, Valve_OP_Open);
        break;
    default:
        break;
    }

    if(m_bRunning){
        m_bRunning = false;
        emit sigStop(m_compartmentid+1);
    }else{

    }


    // 关闭压力传感阀
    //Valve_op(Valve_ID_PRESSURESENSOR, Valve_OP_Close);

    // 复位
    Adjust_pressure(0);

    //m_pTimer_1->stop();

#endif
    qDebug("doTest >>>leave ");

}