#include "work_thread.h"
#include <QDebug>
#include <QDateTime>
#include "unistd.h"
#include <sys/vfs.h>
#include <QDir>
#include "remote_ctrl.h"
#include "DataForm/datalist_page.h"


QStringList alarmStateText;

Work_Thread::Work_Thread()
{
    memset(&fboData,0x00,sizeof(fboData));
    memset(&packData,0x00,sizeof(packData));
    memset(&packData_Origin,0x00,sizeof(packData_Origin));
    memset(&modTestData,0x00,sizeof(modTestData));
    memset(&modTestData_Origin,0x00,sizeof(modTestData_Origin));
    memset(&iconState,0x00,sizeof(iconState));
    memset(&testStateData,0x00,sizeof(testStateData));
    memset(&cellMaxMInValue,0x00,sizeof(cellMaxMInValue));
    memset(&remoteState,0x00,sizeof(remoteState));
    memset(&adjParamSet,0x00,sizeof(adjParamSet));
    memset(&volDropParam,0x00,sizeof(volDropParam));
    memset(&passthroughState,0x00,sizeof(passthroughState));

    cmdExecResult = 0;
    workThreadCMD = CMD_Null;
    adjWorkState = ADJ_STATE_STOPPED;

    timer_1s = new QTimer(this);
    connect(timer_1s,SIGNAL(timeout()),this,SLOT(Timer1sSlot()));
    timer_1s->start(1000);

    rs485_PowerCtrl = new RS485_PowerCtrl(RS485_PwrCtr_DEV_PORT);
    rs485_PowerCtrl->start();

    qRegisterMetaType<MOD_TEST_DATA>("MOD_TEST_DATA");
    connect(rs485_PowerCtrl,SIGNAL(sendModTestDataSignal(MOD_TEST_DATA)),this,SLOT(RecvModTestData(MOD_TEST_DATA)));

    rs485_Pack = new RS485_Pack(RS485_Pack_DEV_PORT);
    rs485_Pack->start();

    qRegisterMetaType<PACK_DATA>("PACK_DATA");
    connect(rs485_Pack,SIGNAL(sendPackDataSignal(PACK_DATA)),this,SLOT(RecvPackData(PACK_DATA)));

    initValueForParam();

    alarmStateText<<tr("测试停止!")<<tr("正在放电!")<<tr("正在充电!") \
                  <<tr("放电时间到!")<<tr("放电容量到!")<<tr("放电SOC到!")<<tr("组端下限到!")<<tr("单体下限到!") \
                  <<tr("充电时间到!")<<tr("充电容量到!")<<tr("充电SOC到!")<<tr("组端上限到!")<<tr("单体上限到!") \
                  <<tr("电芯温度过高!")<<tr("电芯压差过大!") \
                  <<tr("内部通信异常!")<<tr("电压异常!")<<tr("电流异常!")<<tr("温度异常!")<<tr("内部停止!") \
                  <<tr("Pack通信异常!")<<tr("Pack故障!")<<tr("未知错误!");

}

Work_Thread::~Work_Thread()
{

}

//=============================================================================================================

void Work_Thread::initValueForParam()
{
    //---------------- system param ---------------
    sysParamXml.dev_addr = 1;
    sysParamXml.save_time_interval = 60;
    sysParamXml.tcp_type = 1;
    sysParamXml.server_port = 6666;
    sysParamXml.server_ip = "192.168.10.199";
    ClassXML::CreateSysParamXml(sysParamXml);
    ClassXML::ReadSysParamXml(sysParamXml);

    Remote_Ctrl::setRemoteDevAddr(sysParamXml.dev_addr);

    //---------------- test param -----------------
    TEST_PARAM defaultTestParam;
    memset(&defaultTestParam,0x00,sizeof(defaultTestParam));

    //defaultTestParam.batt_pack_type = PACK_TYPE_Halo;
    //defaultTestParam.batt_pack_addr = 0x06;
    defaultTestParam.test_type = TestTypeDischarge;
    defaultTestParam.union_test_EN = 0;

    defaultTestParam.cell_vol_diff = 100;//1mv
    defaultTestParam.temp_high = 650; //0.1
    defaultTestParam.constvol_EN = 0;
    defaultTestParam.curr_end = 50; //0.01A

    defaultTestParam.disParam.dis_time = 180;//minute
    defaultTestParam.disParam.dis_curr = 1000;//0.01A
    defaultTestParam.disParam.dis_cap = 3000;//0.01AH
    defaultTestParam.disParam.sum_vol_low = 3750;//0.01V
    defaultTestParam.disParam.cell_vol_low = 3200;//0.001V
    defaultTestParam.disParam.dis_soc = 300;//0.1%

    defaultTestParam.chgParam.chg_time = 180;//minute
    defaultTestParam.chgParam.chg_curr = 1000;//0.01A
    defaultTestParam.chgParam.chg_cap = 3000;//0.01AH
    defaultTestParam.chgParam.sum_vol_high = 4550; //0.01V
    defaultTestParam.chgParam.cell_vol_high = 4200;//0.001V
    defaultTestParam.chgParam.chg_soc = 900;//0.1%

    defaultTestParam.crc16 = CRC16::CalModbusCRC16(&defaultTestParam,sizeof(defaultTestParam)-2);

    ClassXML::CreateTestParamFile(defaultTestParam);
    ClassXML::ReadTestParamFile(testParam);
    quint16 crc = CRC16::CalModbusCRC16(&testParam,sizeof(testParam)-2);

    if(crc != testParam.crc16){
        testParam = defaultTestParam;
        ClassXML::SaveTestParamFile(testParam);
    }

    //---------------- pack param -----------------
    PACK_PARAM defaultPackParam;
    memset(&defaultPackParam,0x00,sizeof(defaultPackParam));

    defaultPackParam.pack_devaddr = 0x06;
    defaultPackParam.pack_type = PACK_TYPE_Halo;

    defaultPackParam.crc16 = CRC16::CalModbusCRC16(&defaultPackParam,sizeof(defaultPackParam)-2);

    ClassXML::CreatePackParamFile(defaultPackParam);
    ClassXML::ReadPackParamFile(packParam);
    crc = CRC16::CalModbusCRC16(&packParam,sizeof(packParam)-2);

    if(crc != packParam.crc16){
        packParam = defaultPackParam;
        ClassXML::SavePackParamFile(packParam);
    }

    rs485_Pack->setPackCommParam(packParam.pack_devaddr, packParam.pack_type);
}

void Work_Thread::setPageIndex(const quint8 pageindex)
{
    pageIndex = pageindex;
}

quint8 Work_Thread::getPageIndex(void)
{
    return pageIndex;
}

void Work_Thread::setPackBarcodeStr(QString code)
{
    packBarcode = code;
}

void Work_Thread::setRemoteState(REMOTE_STATE &st)
{
    remoteState = st;
}

void Work_Thread::setPassthroughState(PASSTHROUGH_ST &st)
{
    passthroughState = st;
}

void Work_Thread::CheckIconState(void)
{
    iconState.usbState = CheckDiskState(usbDir);
}

quint8 Work_Thread::CheckDiskState(const QString &disk)
{
    struct statfs st;
    statfs(disk.toLocal8Bit().data(), &st);
    if(19780 == st.f_type)
    {
        return 1;
    }

    return 0;
}

void Work_Thread::saveTestParam(TEST_PARAM &testparam)
{
    testParam = testparam;
    testParam.crc16 = CRC16::CalModbusCRC16(&testParam,sizeof(testParam)-2);
    ClassXML::SaveTestParamFile(testParam);

    if(WORK_STATE_STOPPED != testStateData.workState || ADJ_STATE_STOPPED != adjWorkState){
        setWorkThreadCMD(CMD_SetTestParam);
    }
}

void Work_Thread::savePackParam(PACK_PARAM &packparam)
{
    packParam = packparam;
    packParam.crc16 = CRC16::CalModbusCRC16(&packParam,sizeof(packParam)-2);
    ClassXML::SavePackParamFile(packParam);

    rs485_Pack->setPackCommParam(packParam.pack_devaddr, packParam.pack_type);
}

void Work_Thread::saveSysParam(SYSTEM_PARAM_XML &sysparam)
{
    sysParamXml = sysparam;

    //qDebug("save time interval = %d,dev addr = %d",sysParamXml.save_time_interval,sysParamXml.dev_addr);

    ClassXML::SaveSysParamXml(sysParamXml);

    Remote_Ctrl::setRemoteDevAddr(sysParamXml.dev_addr);
}

//=============================================================================================================
void Work_Thread::RecvModTestData(MOD_TEST_DATA testdata)
{
    modTestData_Origin = testdata;
    MOD_TEST_DATA tmpdata = testdata;
    tmpdata.ADCVp = tmpdata.ADCVp/10; //2位小数
    tmpdata.ADCVdc = tmpdata.ADCVdc/10;
    tmpdata.ADCIdc = tmpdata.ADCIdc/10;

    if(tmpdata.ADCIdc < 0){
        tmpdata.ADCIdc *= -1;
    }

    modTestData = tmpdata;

    if(!(rs485_Pack->packComm_OK)){
        memset(&packData,0x00,sizeof(packData));
        memset(&packData_Origin,0x00,sizeof(packData_Origin));
        memset(&cellMaxMInValue,0x00,sizeof(cellMaxMInValue));
    }
}

void Work_Thread::RecvPackData(PACK_DATA packdata)
{
    packData_Origin = packdata;
    packData = packdata;

    if(rs485_Pack->packComm_OK){
        packData.cell_tempe_max = packData.cell_tempe_max-50; //Halo温度换算-50
        packData.cell_tempe_min = packData.cell_tempe_min-50;
        for(quint16 n=0;n<packData.temp_count;n++){
            packData.cell_temp[n] = packData.cell_temp[n]-50;
        }
    }

    packData.junheng_on_state = (packData.junheng_on_state & 0x00FF);


    cellMaxMInValue.max_vol_value = packData.cell_vol_max;
    cellMaxMInValue.min_vol_value = packData.cell_vol_min;
    for(int n=0;n<packData.cell_count;n++){
        if(packData.cell_vol[n] == cellMaxMInValue.max_vol_value){
            cellMaxMInValue.max_vol_index = n;
        }

        if(packData.cell_vol[n] == cellMaxMInValue.min_vol_value){
            cellMaxMInValue.min_vol_index = n;
        }
    }

//    char sv[24] = {'\0'};
//    memcpy(sv,packData.soft_version,16);
//    qDebug("soft_version: %s",sv);

//    qDebug("life_data_signal = %d,cell_count = %d,temp_count = %d",packData.life_data_signal, packData.cell_count,packData.temp_count);
//    qDebug("pre_charge_mos_state = 0x%X,charge_mos_state = 0x%X,dischg_mos_state = 0x%X",packData.pre_charge_mos_state,packData.charge_mos_state,packData.dischg_mos_state);

}

void Work_Thread::initFBO_Data(FBO_DATA_HEAD_START &fbo_data_head_start)
{
    memset(&fboData,0x00,sizeof(fboData));
    if(TestTypeDischarge == testParam.test_type){
        fboData.m_DataType.TypeTag0 = TestTypeDischarge;
        fboData.m_DataType.TypeTag1 = TestTypeDischarge;
        fboData.m_DataType.TypeTag2 = TestTypeDischarge;
        fboData.m_DataType.TypeTag3 = TestTypeDischarge;
    }
    else{
        fboData.m_DataType.TypeTag0 = TestTypeCharge;
        fboData.m_DataType.TypeTag1 = TestTypeCharge;
        fboData.m_DataType.TypeTag2 = TestTypeCharge;
        fboData.m_DataType.TypeTag3 = TestTypeCharge;
    }

    testfilename = testDataDir + format_data_name();

    fbo_data_head_start.TestStartTime.year = QDate::currentDate().year()-2000;
    fbo_data_head_start.TestStartTime.month = QDate::currentDate().month();
    fbo_data_head_start.TestStartTime.day = QDate::currentDate().day();
    fbo_data_head_start.TestStartTime.hour = QTime::currentTime().hour();
    fbo_data_head_start.TestStartTime.minute = QTime::currentTime().minute();
    fbo_data_head_start.TestStartTime.second = QTime::currentTime().second();
    fbo_data_head_start.Device = 0x99;

    fbo_data_head_start.DataVersion = 0x00;

    fbo_data_head_start.DataType = testParam.test_type;

    fbo_data_head_start.HourRate = 10;
    fbo_data_head_start.SaveInterval = sysParamXml.save_time_interval;
    fbo_data_head_start.STDCap = 100;

    if(TestTypeDischarge == testParam.test_type)
        fbo_data_head_start.TestCur = testParam.disParam.dis_curr/10; //0.1
    else
        fbo_data_head_start.TestCur = testParam.chgParam.chg_curr/10; //0.1

    fbo_data_head_start.MVLLimit = testParam.disParam.cell_vol_low/10;  //0.01
    fbo_data_head_start.SumVLLimit = testParam.disParam.sum_vol_low/10; //0.1
    fbo_data_head_start.BattSum = (packData.cell_count>0)?packData.cell_count:1;;
    fbo_data_head_start.BattGroup = 1;
    fbo_data_head_start.MVLLimitCount = 1;
    fbo_data_head_start.MonomerVol = 32;

    fboData.BattSum = fbo_data_head_start.BattSum;//2个位置BattSum必须一致
}

void Work_Thread::makeFBO_Data()
{
    fboData.m_TestTime = testStateData.testTime;
    fboData.BattGroup = 1;
    //fboData.BattSum = (packData.cell_count>0)?packData.cell_count:1;
    fboData.OnlineVol = 0;
    fboData.SumVoltage = modTestData.ADCVdc/10; //0.1
    fboData.SumCurrent = modTestData.ADCIdc/10; //0.1
    fboData.AllCap = testStateData.testCap/100;  //1
    for(quint8 n=0;n<4;n++){
        fboData.SubCurrent[n] = fboData.SumCurrent;
        fboData.SubCap[n] = fboData.AllCap;
    }

    if(fboData.BattSum > 1){
        for(quint8 n=0;n<30;n++){
            if(n<fboData.BattSum){
                fboData.SingleVol[n] = packData.cell_vol[n];//0.001
            }
        }
    }
    else{
        fboData.SingleVol[0] = modTestData.ADCVdc*10;//0.001
    }
}

void Work_Thread::SaveFbo_Data(bool force_save){

    if( (true==testStateData.saveDataEn) || (true==force_save) ){

        testStateData.saveDataEn = false;

        makeFBO_Data();
        ClassXML::SaveFBO_Data(testfilename,fboData);
    }
}

void Work_Thread::closeTestFbo_Data(const quint8 stoptype)
{
    FBO_DATA_HEAD_STOP fbo_data_head_stop;
    fbo_data_head_stop.TestTimeLong = fboData.m_TestTime;

    fbo_data_head_stop.StopType = stoptype;

    fbo_data_head_stop.BlockSum = 1;
    fbo_data_head_stop.StandBy = 0;
    fbo_data_head_stop.TestCap = fboData.AllCap;
    for(quint8 g=0;g<4;g++)
    {
        fbo_data_head_stop.SMaxIndex[g] = cellMaxMInValue.max_vol_index;
        fbo_data_head_stop.SMinIndex[g] = cellMaxMInValue.min_vol_index;
        fbo_data_head_stop.SMaxVol[g] = cellMaxMInValue.max_vol_value;
        fbo_data_head_stop.SMinVol[g] = cellMaxMInValue.min_vol_value;
    }

    ClassXML::CloseFBO_Data(testfilename,fbo_data_head_stop);
}

//=============================================================================================================

QString Work_Thread::format_data_name(void)
{
    QDateTime dtime = QDateTime::currentDateTime();//获取系统现在的时间
    QString str = "F"+dtime.toString("yyyy-MM-dd hh.mm.ss")+".FBO"; //设置显示格式

    testStartTime.year = QDate::currentDate().year()-2000;
    testStartTime.month = QDate::currentDate().month();
    testStartTime.day = QDate::currentDate().day();
    testStartTime.hour = QTime::currentTime().hour();
    testStartTime.minute = QTime::currentTime().minute();
    testStartTime.second = QTime::currentTime().second();

    return str;
}

CT_DATE_TIME Work_Thread::getTestStartTime()
{
    return testStartTime;
}



//=============================================================================================================
void Work_Thread::Timer1sSlot()
{
    if( WORK_STATE_DISCHG == testStateData.workState
        || WORK_STATE_CHARGE == testStateData.workState )
    {
        if(testStateData.testTime.second<59)
        {
            testStateData.testTime.second++;
        }
        else
        {
            testStateData.testTime.second = 0;
            if(testStateData.testTime.minute<59)
            {
                testStateData.testTime.minute++;
            }
            else
            {
                testStateData.testTime.minute = 0;
                if(testStateData.testTime.hour < 99)
                {
                    testStateData.testTime.hour++;
                }
                else
                {
                    testStateData.testTime.hour = 0;
                }
            }
        }

        testStateData.testCapPS += modTestData.ADCIdc;

        if(testStateData.testCapPS>=3600)
        {
            testStateData.testCapPS -= 3600;

            testStateData.testCap++;
        }
        /*
        else if(testStateData.testCapPS<=-3600)
        {
            testStateData.testCapPS += 3600;

            testStateData.testCap--;
        }
        */

        quint32 secondsum =3600*testStateData.testTime.hour
                + 60*testStateData.testTime.minute
                + testStateData.testTime.second;

        //前3分钟5秒，以后按saveInterval秒
        if(secondsum<=180)
        {
            if(secondsum%5 == 0)
            {
                testStateData.saveDataEn = true;
            }
        }
        else
        {
            if(secondsum%sysParamXml.save_time_interval == 0)
            {
                testStateData.saveDataEn = true;
            }
        }
    }

    if(remoteState.heart_ticks < 1000){
        remoteState.heart_ticks++;

        if(remoteState.heart_ticks > 60){
            remoteState.conn_type = 0;
            remoteState.enter_slave = 0;
            remoteState.heart_ticks = 0;

            passthroughState.passing = 0;

            rs485_Pack->remsumPackComm();
        }
    }
}

//=============================================================================================================
int Work_Thread::initTestState()
{
    testStateData.testCap = 0;
    testStateData.testCapPS = 0;

    testStateData.testTime.hour = 0;
    testStateData.testTime.minute = 0;
    testStateData.testTime.second = 0;

    testStateData.workState = WORK_STATE_STOPPED;
    testStateData.alarmState = ALARM_STATE_STOPPED;
    testStateData.startState = EXE_RES_OK;

    testStateData.saveDataEn = 0;

    stateWorkCount = 0;

    FBO_DATA_HEAD_START fbo_data_head_start;

    initFBO_Data(fbo_data_head_start);

    ClassXML::CreateFBO_Data(testfilename,fbo_data_head_start);

    SaveFbo_Data(true);

    return 0;
}

int Work_Thread::startErrorCheck()
{
#ifdef _debug_demo_
    return 0;
#endif

    if (modTestData.ADCVdc< VOL_TOO_LOW){
        return START_VOL_LOW;
    }

    if (modTestData.ADCVdc>VOL_TOO_HIGH){
        return START_VOL_HIGH;
    }

    if(DataList_Page::isMemoryIsFull()){
        return START_MEM_ERROR;
    }

    double vol = modTestData.ADCVdc;
    quint16 volmin = (quint16)(vol * 0.8);
    quint16 volmax = (quint16)(vol * 1.2);

    if(testParam.test_type == TestTypeDischarge){
        if( (testParam.disParam.sum_vol_low<volmin)
             || (testParam.disParam.sum_vol_low>=modTestData.ADCVdc) ){
            return START_DISVOL_ERROR;
        }
    }
    else{
        if( (testParam.chgParam.sum_vol_high>volmax)
               || (testParam.chgParam.sum_vol_high<=modTestData.ADCVdc) ){
            return START_CHGVOL_ERROR;
        }
    }

    /*
    quint32 power1 = modTestData.ADCVdc;
    quint32 power2 = 0;

    if(testParam.test_type == TestTypeDischarge){
        power1 *= testParam.disParam.dis_curr;
        power2 = testParam.disParam.dis_curr * testParam.disParam.sum_vol_low;
    }
    else{
        power1 *= testParam.chgParam.chg_curr;
        power2 = testParam.chgParam.chg_curr * testParam.chgParam.sum_vol_high;
    }

    if(power1>POWER_MAX || power2>POWER_MAX){
        return START_POWER_OVER;
    }
    */

    return START_OK;
}

int Work_Thread::closePrechgMos()
{
    int res = 0;

#ifdef _debug_demo_
    return res;
#endif

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        if(rs485_Pack->packComm_OK){

            if(0==packData.pre_charge_mos_state && WORK_STATE_STOPPED==testStateData.workState){
                rs485_Pack->lock_RS485();
                res = setPreChgMos_Close();
                msleep(100);
                rs485_Pack->unlock_RS485();
            }
        }
    }

    return res;
}

int Work_Thread::setPreChgMos_Close()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        quint16 mos_close = 0x0001;

        for(quint8 t=0;t<3;t++){
            //预充电MOS管闭合
            res = rs485_Pack->ModBusMultiWrite(0x06, 0x02B1, &mos_close, 1, 200);

            if(Uart_Driver::CommOK == res){
                break;
            }
            else{
                msleep(100);
            }
        }
    }

    return res;
}

int Work_Thread::setPreChgMos_Break()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        quint16 mos_break = 0x0000;

        for(quint8 t=0;t<3;t++){
            //预充电MOS管断开
            res = rs485_Pack->ModBusMultiWrite(0x06, 0x02B1, &mos_break, 1, 200);
            if(Uart_Driver::CommOK == res){
                break;
            }
            else{
                msleep(100);
            }
        }
    }

    return res;
}

int Work_Thread::setChargeMos_Close()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        quint16 mos_close = 0x0001;

        for(quint8 t=0;t<3;t++){
            //充电MOS管闭合
            res = rs485_Pack->ModBusMultiWrite(0x06, 0x02B2, &mos_close, 1, 200);
            if(Uart_Driver::CommOK == res){
                break;
            }
            else{
                msleep(100);
            }
        }
    }

    return res;
}

int Work_Thread::setChargeMos_Break()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        quint16 mos_break = 0x0000;

        for(quint8 t=0;t<3;t++){
            //充电MOS管断开
            res = rs485_Pack->ModBusMultiWrite(0x06, 0x02B2, &mos_break, 1, 200);
            if(Uart_Driver::CommOK == res){
                break;
            }
            else{
                msleep(100);
            }
        }
    }

    return res;
}

int Work_Thread::setDischgMos_Close()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        quint16 mos_close = 0x0001;

        for(quint8 t=0;t<3;t++){
            //放电MOS管闭合
            res = rs485_Pack->ModBusMultiWrite(0x06, 0x02B3, &mos_close, 1, 200);
            if(Uart_Driver::CommOK == res){
                break;
            }
            else{
                msleep(100);
            }
        }
    }

    return res;
}

int Work_Thread::setDischgMos_Break()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        quint16 mos_break = 0x0000;

        for(quint8 t=0;t<3;t++){
            //放电MOS管断开
            res = rs485_Pack->ModBusMultiWrite(0x06, 0x02B3, &mos_break, 1, 200);
            if(Uart_Driver::CommOK == res){
                break;
            }
            else{
                msleep(100);
            }
        }
    }

    return res;
}

int Work_Thread::getMos_State(quint16 *premos, quint16 *chgmos, quint16 *dismos)
{
    quint16 mos_state[3] = {0};

    int res  = rs485_Pack->ModBusRead(0x06, 675, 3, mos_state, 200);

    if(res == Uart_Driver::CommOK){
        *premos = Swap16(mos_state[0]);
        *chgmos = Swap16(mos_state[1]);
        *dismos = Swap16(mos_state[2]);
    }

    return res;
}

int Work_Thread::setMOS_BeforeDischarge()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        res = setPreChgMos_Break();
        msleep(20);

        if(Uart_Driver::CommOK == res){
            res = setChargeMos_Break();
            msleep(20);
        }

        if(Uart_Driver::CommOK == res){
            res = setDischgMos_Close();
        }

        msleep(500);

        if(Uart_Driver::CommOK == res){
            quint16 premos = 0;
            quint16 chgmos = 0;
            quint16 dismos = 0;

            for(quint8 t=0;t<10;t++){
                msleep(100);
                res = getMos_State(&premos, &chgmos, &dismos);
                if(0==res){
                    qDebug("presmos = %d,chgmos = %d,dismos = %d",premos,chgmos,dismos);
                    if(0==premos && 0==chgmos && 1==dismos){
                        break;
                    }
                    else
                        res = RES_Error_MOS_State;
                }
            }
        }
    }

    return res;
}

int Work_Thread::setMOS_AfterDischarge()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        rs485_Pack->lock_RS485();

        res = setDischgMos_Break();
        msleep(20);

        if(Uart_Driver::CommOK == res){
            res = setPreChgMos_Close();
        }

        msleep(100);

        rs485_Pack->unlock_RS485();
    }

    return res;
}

int Work_Thread::setTestParam(const quint8 testtype)
{
    if(TestTypeDischarge == testtype){
        DISCHG_PARAM_SET disparamset;

        disparamset.Vdis = testParam.disParam.sum_vol_low*10;
        disparamset.Idis = testParam.disParam.dis_curr*10;
        disparamset.Tdis = testParam.disParam.dis_time*60+600;

        //qDebug("sum_vol_low = %d,dis_curr = %d",disparamset.Vdis,disparamset.Idis);

        //设置放电参数
        int res = 0;
        for(quint8 t=0;t<3;t++){
            res = rs485_PowerCtrl->ModBusMultiWrite(0x01, RegAddr_SetModDisParam, (quint16 *)&disparamset,RegCount_SetModDisParam, 200);
            if(Uart_Driver::CommOK == res){
                break;
            }
            else{
                msleep(100);
            }
        }

        return res;
    }
    else if(TestTypeCharge == testtype){
        CHARGE_PARAM_SET chgparamset;

        chgparamset.Vchg = testParam.chgParam.sum_vol_high*10;
        chgparamset.Ichg = testParam.chgParam.chg_curr*10;
        chgparamset.Tchg = testParam.chgParam.chg_time*60+600;

        //qDebug("sum_vol_high = %d,chg_curr = %d",chgparamset.Vchg,chgparamset.Ichg);

        //设置充电参数
        int res = 0;
        for(quint8 t=0;t<3;t++){
            res = rs485_PowerCtrl->ModBusMultiWrite(0x01, RegAddr_SetModChrParam, (quint16 *)&chgparamset,RegCount_SetModChrParam, 200);
            if(Uart_Driver::CommOK == res){
                break;
            }
            else{
                msleep(100);
            }
        }

        return res;
    }

    return 0;
}

int Work_Thread::setIOBoardState(const quint8 testype, bool is_start)
{
    int res = 0;

    if(TestTypeDischarge == testype){
        if(is_start){
            //启动放电
            quint16 startdis = CMD_BeginWork;
            for(quint8 t=0;t<3;t++){
                res = rs485_PowerCtrl->ModBusMultiWrite(0x01, RegAddr_Discharge, (quint16 *)&startdis,1, 200);
                if(Uart_Driver::CommOK == res){
                    break;
                }
                else{
                    msleep(100);
                }
            }
        }
        else{
            //关闭放电
            quint16 stopdis = CMD_EndWork;
            for(quint8 t=0;t<3;t++){
                res = rs485_PowerCtrl->ModBusMultiWrite(0x01, RegAddr_Discharge, (quint16 *)&stopdis,1, 200);
                if(Uart_Driver::CommOK == res){
                    break;
                }
                else{
                    msleep(100);
                }
            }
        }
    }
    else if(TestTypeCharge == testype){
        if(is_start){
            //启动充电
            quint16 startchg = CMD_BeginWork;
            for(quint8 t=0;t<3;t++){
                res = rs485_PowerCtrl->ModBusMultiWrite(0x01, RegAddr_Charge, (quint16 *)&startchg, 1, 200);
                if(Uart_Driver::CommOK == res){
                    break;
                }
                else{
                    msleep(100);
                }
            }
        }
        else{
            //关闭充电
            quint16 stopchg = CMD_EndWork;
            for(quint8 t=0;t<3;t++){
                res = rs485_PowerCtrl->ModBusMultiWrite(0x01, RegAddr_Charge, (quint16 *)&stopchg, 1, 200);
                if(Uart_Driver::CommOK == res){
                    break;
                }
                else{
                    msleep(100);
                }
            }
        }
    }

    return res;
}

int Work_Thread::openDischargePower()
{
    int res = 0;

#ifdef _debug_demo_
    return res;
#endif

    rs485_Pack->lock_RS485();
    rs485_PowerCtrl->lock_RS485();

    //start mos
    res = setMOS_BeforeDischarge();
    if(Uart_Driver::CommOK != res){
        if(res < -20){
            res = EXE_MOS_STATE_ERR;
        }
        else
            res = EXE_MOS_CTRL_FAIL;
    }

    if(0 == res){
        res = setTestParam(TestTypeDischarge);

        if(Uart_Driver::CommOK != res){
            res = EXE_SET_PARAM_FAIL;
        }
    }

    if(0 == res){
        msleep(30);
        res = setIOBoardState(TestTypeDischarge,true);
        if(Uart_Driver::CommOK != res){
            res = EXE_START_FAIL;
        }
    }

    msleep(100);

    rs485_Pack->unlock_RS485();
    rs485_PowerCtrl->unlock_RS485();

    if(packData.comm_certification_state != 2){
        rs485_Pack->setCertificationPackEn();
    }
    else{
        qDebug("discharge,comm_certification_state = 2.");
    }

    return res;
}

int Work_Thread::closeDischargePower()
{
#ifdef _debug_demo_
    return 0;
#endif

    //关闭放电
    rs485_PowerCtrl->lock_RS485();

    int res = setIOBoardState(TestTypeDischarge,false);
    if(Uart_Driver::CommOK != res){
        res = EXE_STOP_FAIL;
    }

    //opt mos
    setMOS_AfterDischarge();

    rs485_PowerCtrl->unlock_RS485();

    return res;
}

int Work_Thread::startDischarge()
{
    initTestState();

    int res = openDischargePower();

    testStateData.startState = res;

    if(0 == res){
        testStateData.workState = WORK_STATE_DISCHG;
        testStateData.alarmState = ALARM_STATE_DISCHARGING;
    }

    return res;
}

int Work_Thread::stopDischarge(const quint8 stoptype)
{
    SaveFbo_Data(true);
    closeTestFbo_Data(stoptype);

    int res = closeDischargePower();

    testStateData.workState = WORK_STATE_STOPPED;
    testStateData.alarmState = stoptype;

    return res;
}

int Work_Thread::setMOS_BeforeCharge()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        res = setDischgMos_Break();
        msleep(20);

        if(Uart_Driver::CommOK == res){
            res = setPreChgMos_Close();
            msleep(20);
        }

        if(Uart_Driver::CommOK == res){
            res = setChargeMos_Close();
        }

        msleep(200);

        if(Uart_Driver::CommOK == res){
            quint16 premos = 0;
            quint16 chgmos = 0;
            quint16 dismos = 0;

            for(quint8 t=0;t<10;t++){
                msleep(100);
                res = getMos_State(&premos, &chgmos, &dismos);
                if(0==res){
                    qDebug("presmos = %d,chgmos = %d,dismos = %d",premos,chgmos,dismos);
                    if(1==premos && 1==chgmos && 0==dismos){
                        break;
                    }
                    else
                        res = RES_Error_MOS_State;
                }
            }
        }
    }

    return res;
}

int Work_Thread::setMOS_AfterCharge()
{
    int res = 0;

    if(PACK_TYPE_Halo == packParam.pack_type)
    {
        rs485_Pack->lock_RS485();

        res = setChargeMos_Break();

        msleep(100);

        rs485_Pack->unlock_RS485();
    }

    return res;
}

int Work_Thread::openChargePower()
{
    int res = 0;

#ifdef _debug_demo_
    return res;
#endif

    rs485_Pack->lock_RS485();
    rs485_PowerCtrl->lock_RS485();

    //start mos
    res = setMOS_BeforeCharge();
    if(Uart_Driver::CommOK != res){
        if(res < -20){
            res = EXE_MOS_STATE_ERR;
        }
        else
            res = EXE_MOS_CTRL_FAIL;
    }

    if(0 == res){
        res = setTestParam(TestTypeCharge);

        if(Uart_Driver::CommOK != res){
            res = EXE_SET_PARAM_FAIL;
        }
    }

    if(0 == res){
        msleep(30);
        res = setIOBoardState(TestTypeCharge,true);
        if(Uart_Driver::CommOK != res){
            res = EXE_START_FAIL;
        }
    }

    msleep(100);

    rs485_Pack->unlock_RS485();
    rs485_PowerCtrl->unlock_RS485();

    return res;
}

int Work_Thread::closeChargePower()
{

#ifdef _debug_demo_
    return 0;
#endif

    rs485_PowerCtrl->lock_RS485();

    int res = setIOBoardState(TestTypeCharge,false);
    if(Uart_Driver::CommOK != res){
        res = EXE_STOP_FAIL;
    }

    //opt mos
    setMOS_AfterCharge();

    rs485_PowerCtrl->unlock_RS485();

    return res;
}

int Work_Thread::activePackByCharge()
{
#ifdef _debug_demo_
    return 0;
#endif

    if(modTestData.State > 0){
        return 0;
    }

    rs485_PowerCtrl->lock_RS485();

    CHARGE_PARAM_SET chgparamset;

    chgparamset.Vchg = testParam.chgParam.sum_vol_high*10;
    chgparamset.Ichg = 500;
    chgparamset.Tchg = 1000; //ms  when  active

    //设置充电参数
    int res = 0;
    for(quint8 t=0;t<3;t++){
        res = rs485_PowerCtrl->ModBusMultiWrite(0x01, RegAddr_SetModChrParam, (quint16 *)&chgparamset,RegCount_SetModChrParam, 200);
        if(Uart_Driver::CommOK == res){
            break;
        }
        else{
            msleep(100);
        }
    }

    if(0 == res){
        msleep(30);
        quint16 startchg = CMD_ActivePack; //active the pack
        for(quint8 t=0;t<3;t++){
            res = rs485_PowerCtrl->ModBusMultiWrite(0x01, RegAddr_Charge, (quint16 *)&startchg, 1, 200);
            if(Uart_Driver::CommOK == res){
                break;
            }
            else{
                msleep(100);
            }
        }
    }

    rs485_PowerCtrl->unlock_RS485();

    return res;
}

int Work_Thread::startCharge()
{
    initTestState();

    int res = openChargePower();

    testStateData.startState = res;

    if(0 == res){
        testStateData.workState = WORK_STATE_CHARGE;
        testStateData.alarmState = ALARM_STATE_CHARGING;
    }

    return res;
}

int Work_Thread::stopCharge(const quint8 stoptype)
{
    SaveFbo_Data(true);
    closeTestFbo_Data(stoptype);

    closeChargePower();

    testStateData.workState = WORK_STATE_STOPPED;
    testStateData.alarmState = stoptype;

    return 0;
}

quint16 Work_Thread::getCellVolLowCount(const quint16 celllow)
{
    quint16 cnt = 0;

    /*
    for(quint16 n=0;n<packData.cell_count;n++){
        if(packData.cell_vol[n] <= celllow){
            cnt++;
        }
    }
    */

    if(packData.cell_vol_min<=celllow){
        return 1;
    }

    return cnt;
}

quint16 Work_Thread::getCellVolHighCount(const quint16 cellhigh)
{
    quint16 cnt = 0;

    /*
    for(quint16 n=0;n<packData.cell_count;n++){
        if(packData.cell_vol[n] >= cellhigh){
            cnt++;
        }
    }
    */
    if(packData.cell_vol_max>=cellhigh){
        return 1;
    }

    return cnt;
}

quint16 Work_Thread::getCellTempHighCount(const quint16 cellhigh)
{
    quint16 cnt = 0;

    /*
    for(quint16 n=0;n<packData.temp_count;n++){
        if(packData.cell_temp[n] >= cellhigh){
            cnt++;
        }
    }
    */

    if(packData.cell_tempe_max*10>=cellhigh){
        return 1;
    }

    return cnt;
}
//=============================================================================================================
int Work_Thread::getAdjParamFromIOBoard()
{
    quint16 databuff[8] = {0};

    int res = 0;
    for(quint8 t=0;t<3;t++){
        res = rs485_PowerCtrl->ModBusRead(0x01, 0xB00E, 8, databuff, 300);
        if(Uart_Driver::CommOK == res){
            adjParamSet.Islope = Swap16(databuff[0]);
            adjParamSet.Ioffset = Swap16(databuff[1]);
            adjParamSet.Tslope = Swap16(databuff[2]);
            adjParamSet.Toffset = Swap16(databuff[3]);
            adjParamSet.Vslope = Swap16(databuff[4]);
            adjParamSet.Voffset = Swap16(databuff[5]);
            adjParamSet.Pslope = Swap16(databuff[6]);
            adjParamSet.Poffset = Swap16(databuff[7]);

            break;
        }
        else{
            msleep(100);
        }
    }

    return res;
}

int Work_Thread::setAdjParamToIOBoard(void)
{
    int res = 0;
    for(quint8 t=0;t<3;t++){
        res = rs485_PowerCtrl->ModBusMultiWrite(0x01, 0xB00E, (quint16 *)&adjParamSet, 8, 200);
        if(Uart_Driver::CommOK == res){
            qDebug("setAdjParamToIOBoard success.");
            break;
        }
        else{
            msleep(100);
        }
    }

    return res;
}

void Work_Thread::saveAdjParam(ADJ_PARAM_SET &param)
{
    //因采取的是多个校准参数同时下发，所以务必保证所有都正确，以避免将其它校准参数写偏
    if( (param.Ioffset>-1000&&param.Ioffset<1000&&param.Islope>8000&&param.Islope<12000)
         &&(param.Toffset>-1000&&param.Toffset<1000&&param.Tslope>8000&&param.Tslope<12000)
         &&(param.Voffset>-1000&&param.Voffset<1000&&param.Vslope>8000&&param.Vslope<12000)
         &&(param.Poffset>-1000&&param.Poffset<1000&&param.Pslope>8000&&param.Pslope<12000) ){

        adjParamSet = param;

        setWorkThreadCMD(CMD_SetAdjParamSet);
    }
    else{
        qDebug("Adjust Param Err....");
    }

}

//=============================================================================================================
int Work_Thread::getDropVolParamFromIOBoard()
{
    quint16 databuff[1] = {0};

    int res = 0;
    for(quint8 t=0;t<3;t++){
        res = rs485_PowerCtrl->ModBusRead(0x01, 0xB017, 1, databuff, 300);
        if(Uart_Driver::CommOK == res){
            volDropParam.dropVol = Swap16(databuff[0]);

            break;
        }
        else{
            msleep(100);
        }
    }

    return res;
}

int Work_Thread::setDropVolParamToIOBoard(void)
{
    int res = 0;
    for(quint8 t=0;t<3;t++){
        res = rs485_PowerCtrl->ModBusMultiWrite(0x01, 0xB017, (quint16 *)&volDropParam, 1, 200);
        if(Uart_Driver::CommOK == res){
            qDebug("setDropVolParamToIOBoard success.");
            break;
        }
        else{
            msleep(100);
        }
    }

    return res;
}

void Work_Thread::saveVolDropParam(VOL_DROP_PARAM &param)
{
    //因采取的是多个参数同时下发，所以务必保证所有都正确，以避免将其它参数写偏
    if(param.dropVol>=0 && param.dropVol<=2000 ){

        volDropParam = param;

        setWorkThreadCMD(CMD_SetVolDropParam);
    }
    else{
        qDebug("Vol Drop Param Err....");
    }

}

//=============================================================================================================

void Work_Thread::CheckIfStop()
{
    //-----------------------  放电  -------------------------
    if(WORK_STATE_DISCHG == testStateData.workState){
        quint16 timsum = testStateData.testTime.hour*60 + testStateData.testTime.minute;

        //-----------------------------------------------------------------
        if(rs485_PowerCtrl->powerCtrlComm_OK == false){
            stopDischarge(ALARM_STATE_ERR_COMM);
        }
        else if((packParam.pack_type!=PACK_TYPE_Other) && (rs485_Pack->packComm_OK==false)){
            stopDischarge(ALARM_STATE_PACK_COMM_ERR);
        }
        //-----------------------------------------------------------------
        else if(timsum >= testParam.disParam.dis_time)
        {
            stopDischarge(ALARM_STATE_DISTIMEOVER);
        }
        else if( (0==testParam.constvol_EN && modTestData.ADCVdc<=testParam.disParam.sum_vol_low)
                 || (1==testParam.constvol_EN && modTestData.ADCVdc<=testParam.disParam.sum_vol_low && modTestData.ADCIdc<testParam.curr_end) )
        {
            stopDischarge(ALARM_STATE_SUMVOLLOW);
        }
        else if(testStateData.testCap >= testParam.disParam.dis_cap)
        {
            stopDischarge(ALARM_STATE_DISCAPOVER);
        }
        else if(getCellVolLowCount(testParam.disParam.cell_vol_low)>0 && packParam.pack_type!=PACK_TYPE_Other)
        {
            stopDischarge(ALARM_STATE_CELLVOLLOW);
        }
        else if(packData.soc <= testParam.disParam.dis_soc  && packParam.pack_type!=PACK_TYPE_Other){
            stopDischarge(ALARM_STATE_DISSOCOVER);
        }
        //--------------------------------------------------------------
        else if(getCellTempHighCount(testParam.temp_high) > 0){
            stopDischarge(ALARM_STATE_TEMPHIGH);
        }
        else if(packData.cell_diff_vol_max>=testParam.cell_vol_diff){
            stopDischarge(ALARM_STATE_CELLVOLDIFF);
        }
        //--------------------------------------------------------------
        else if(modTestData.ErrorStop & MOD_ERROR_VOL)
        {
            stopDischarge(ALARM_STATE_ERR_VOL);
        }
        else if(modTestData.ErrorStop & MOD_ERROR_PWRVOL)
        {
            stopDischarge(ALARM_STATE_ERR_VOL);
        }
        else if(modTestData.ErrorStop & MOD_ERROR_CURR)
        {
            stopDischarge(ALARM_STATE_ERR_CURR);
        }
        else if(modTestData.ErrorStop & MOD_ERROR_TEMP)
        {
            stopDischarge(ALARM_STATE_ERR_TEMP);
        }
        else if((~modTestData.State) & MOD_STATE_DIS)
        {
            stateWorkCount++;
            if(stateWorkCount>=10)
                stopDischarge(ALARM_STATE_ERR_INTSTOP);
        }
        //-----------------------------------------------------------
        else if( (packData.bms_error_state > 0)
                 && ((packData.error[0]&packParam.pack_errMask1)>0 || (packData.error[1]&packParam.pack_errMask2)>0) )
        {
            stopDischarge(ALARM_STATE_PACK_ERR);
        }
        //-----------------------------------------------------------

    }
    //-----------------------  充电  -------------------------
    else if(WORK_STATE_CHARGE == testStateData.workState){
        quint16 timsum = testStateData.testTime.hour*60 + testStateData.testTime.minute;
        //-----------------------------------------------------------------
        if(rs485_PowerCtrl->powerCtrlComm_OK == false){
            stopCharge(ALARM_STATE_ERR_COMM);
        }
        else if((packParam.pack_type!=PACK_TYPE_Other) && (rs485_Pack->packComm_OK==false)){
            stopCharge(ALARM_STATE_PACK_COMM_ERR);
        }
        //-----------------------------------------------------------------
        else if(timsum >= testParam.chgParam.chg_time)
        {
            stopCharge(ALARM_STATE_CHRTIMEOVER);
        }
        else if( (0==testParam.constvol_EN && modTestData.ADCVdc>=testParam.chgParam.sum_vol_high)
                 || (1==testParam.constvol_EN && modTestData.ADCVdc>=testParam.chgParam.sum_vol_high && modTestData.ADCIdc<testParam.curr_end) )
        {
            stopCharge(ALARM_STATE_SUMVOLHIGH);
        }
        else if(testStateData.testCap >= testParam.chgParam.chg_cap)
        {
            stopCharge(ALARM_STATE_CHRCAPOVER);
        }
        else if(getCellVolHighCount(testParam.chgParam.cell_vol_high)>0 && packParam.pack_type!=PACK_TYPE_Other)
        {
            stopCharge(ALARM_STATE_CELLVOLHIGH);
        }
        else if(packData.soc >= testParam.chgParam.chg_soc  && packParam.pack_type!=PACK_TYPE_Other){
            stopCharge(ALARM_STATE_CHGSOCOVER);
        }
        //--------------------------------------------------------------
        else if(getCellTempHighCount(testParam.temp_high) > 0){
            stopCharge(ALARM_STATE_TEMPHIGH);
        }
        else if(packData.cell_diff_vol_max>=testParam.cell_vol_diff){
            stopCharge(ALARM_STATE_CELLVOLDIFF);
        }
        //--------------------------------------------------------------
        else if(modTestData.ErrorStop & MOD_ERROR_VOL)
        {
            stopCharge(ALARM_STATE_ERR_VOL);
        }
        else if(modTestData.ErrorStop & MOD_ERROR_PWRVOL)
        {
            stopCharge(ALARM_STATE_ERR_VOL);
        }
        else if(modTestData.ErrorStop & MOD_ERROR_CURR)
        {
            stopCharge(ALARM_STATE_ERR_CURR);
        }
        else if(modTestData.ErrorStop & MOD_ERROR_TEMP)
        {
            stopCharge(ALARM_STATE_ERR_TEMP);
        }
        else if((~modTestData.State) & MOD_STATE_CHR)
        {
            stateWorkCount++;
            if(stateWorkCount>=10)
                stopCharge(ALARM_STATE_ERR_INTSTOP);
        }
        //-----------------------------------------------------------
        else if( (packData.bms_error_state > 0)
                 && ((packData.error[0]&packParam.pack_errMask1)>0 || (packData.error[1]&packParam.pack_errMask2)>0) )
        {
            stopCharge(ALARM_STATE_PACK_ERR);
        }
        //-----------------------------------------------------------
    }
}

//=============================================================================================================

void Work_Thread::setWorkThreadCMD(int cmd)
{
    if(CMD_Null == workThreadCMD){
        workThreadCMD = cmd;
        //qDebug("workThreadCMD = %d",workThreadCMD);
    }
}

void Work_Thread::processWorkThreadCMD()
{
    if(CMD_Null != workThreadCMD){
        passthroughState.execing = 1;
    }

    if(CMD_StartTest == workThreadCMD){
        if(TestTypeDischarge == testParam.test_type){
            cmdExecResult = startDischarge();
            if(EXE_RES_OK != cmdExecResult){
                closeDischargePower();
            }
        }
        else if(TestTypeCharge == testParam.test_type){
            cmdExecResult = startCharge();
            if(EXE_RES_OK != cmdExecResult){
                closeChargePower();
            }
        }
    }
    else if(CMD_StopTest == workThreadCMD){
        if(WORK_STATE_DISCHG == testStateData.workState){
            stopDischarge(ALARM_STATE_STOPPED);
        }
        else if(WORK_STATE_CHARGE == testStateData.workState){
            stopCharge(ALARM_STATE_STOPPED);
        }
    }
    else if(CMD_SetTestParam == workThreadCMD){
        if(testStateData.workState == WORK_STATE_DISCHG
                || adjWorkState == ADJ_STATE_DISCHARGE){
            rs485_PowerCtrl->lock_RS485();
            if(setTestParam(TestTypeDischarge) != 0){
                //cmdExecResult = EXE_SET_PARAM_FAIL;
            }
            msleep(100);
            rs485_PowerCtrl->unlock_RS485();
        }
        else if(testStateData.workState == WORK_STATE_CHARGE
                || adjWorkState == ADJ_STATE_CHARGE){
            rs485_PowerCtrl->lock_RS485();
            if(setTestParam(TestTypeCharge) != 0){
                //cmdExecResult = EXE_SET_PARAM_FAIL;
            }
            msleep(100);
            rs485_PowerCtrl->unlock_RS485();
        }
    }
    else if(CMD_GetAdjParamSet == workThreadCMD){
        rs485_PowerCtrl->lock_RS485();
        if(getAdjParamFromIOBoard() != 0){
            cmdExecResult = EXE_READ_ADJ_FAIL;
        }
        msleep(100);
        rs485_PowerCtrl->unlock_RS485();
    }
    else if(CMD_SetAdjParamSet == workThreadCMD){
        rs485_PowerCtrl->lock_RS485();
        if(setAdjParamToIOBoard() != 0){
            cmdExecResult = EXE_SET_ADJ_FAIL;
        }
        msleep(100);
        rs485_PowerCtrl->unlock_RS485();
    }
    else if(CMD_AdjStartChr == workThreadCMD){
        if(ADJ_STATE_STOPPED == adjWorkState){
            cmdExecResult = openChargePower();
            if(EXE_RES_OK != cmdExecResult){
                closeChargePower();
            }
            else{
                adjWorkState = ADJ_STATE_CHARGE;
            }
        }
    }
    else if(CMD_AdjStartDis == workThreadCMD){
        if(ADJ_STATE_STOPPED == adjWorkState){
            cmdExecResult = openDischargePower();
            if(EXE_RES_OK != cmdExecResult){
                closeDischargePower();
            }
            else{
                adjWorkState = ADJ_STATE_DISCHARGE;
            }
        }
    }
    else if(CMD_AdjStopTest == workThreadCMD){
        if(ADJ_STATE_DISCHARGE == adjWorkState){
            closeDischargePower();
        }
        else if(ADJ_STATE_CHARGE == adjWorkState){
            closeChargePower();
        }

        adjWorkState = ADJ_STATE_STOPPED;
    }
    else if(CMD_SetActivePack == workThreadCMD){
        activePackByCharge();
    }
    else if(CMD_GetVolDropParam == workThreadCMD){
        rs485_PowerCtrl->lock_RS485();
        if(getDropVolParamFromIOBoard() != 0){

        }
        msleep(100);
        rs485_PowerCtrl->unlock_RS485();
    }
    else if(CMD_SetVolDropParam == workThreadCMD){
        rs485_PowerCtrl->lock_RS485();
        if(setDropVolParamToIOBoard() != 0){

        }
        msleep(100);
        rs485_PowerCtrl->unlock_RS485();
    }

    passthroughState.execing = 0;

    if(CMD_Null != workThreadCMD){
        qDebug("cmd exe err,errcode = %d",cmdExecResult);
        emit sendCMD_Result(cmdExecResult);
    }

    cmdExecResult = 0;
    workThreadCMD = CMD_Null;
}

//=============================================================================================================

void Work_Thread::run()
{
    quint16 rate_ctrl = 0;

    while(1){
        msleep(50);

        processWorkThreadCMD();

        if(0 == (rate_ctrl%6)){
            CheckIconState();
        }

        if(0 == (rate_ctrl%15)){
            closePrechgMos();
        }

        if(1 == (rate_ctrl%10)){
            SaveFbo_Data(false);
        }

        if(0 == (rate_ctrl%10)){
            if(WORK_STATE_STOPPED != testStateData.workState){
                quint32 secondsum =3600*testStateData.testTime.hour
                        + 60*testStateData.testTime.minute
                        + testStateData.testTime.second;

                if(secondsum > 5){
                 #ifndef _debug_demo_
                    CheckIfStop();
                 #endif
                }
            }
            else{
                stateWorkCount = 0;
            }
        }

        rate_ctrl++;
    }
}