//---------------------------------------------------------------------
#include <QApplication>
#include <QDateTime>
#include    "SlaveCtrl.h"
#include    "crc16.h"
#include "filemanage.h"
#include "classxml.h"

#define SYSCODE     0xAAAAAAAA
#define Version     12


#define ADJ_VOL     0
#define ADJ_DIS     1
#define ADJ_CHR     2



//#define EN_THREAD_WORK_DEBUG
#ifdef EN_THREAD_WORK_DEBUG
#define THREAD_WORK_DEBUG qDebug
#else
#define THREAD_WORK_DEBUG(...)
#endif

QList<MASTER_CMD> master_cmd;

SlaveCtrl::SlaveCtrl(Working_Page *page)
{
    work_page = page;
    IF_CLOSEServer = IF_CLOSEClient = false;
    connect(this,SIGNAL(SendInterface(int)),work_page->work_thread,SLOT(RecvInterface(int)));

    connect(this,SIGNAL(sendParam(int)),work_page,SLOT(operatorCMD_Work(int)));

    connect(work_page,SIGNAL(senddeleteSocket()),this,SLOT(deleteSocket()));

    ServerFlag = ClientFlag = 0;

}

SlaveCtrl::~SlaveCtrl()
{
    quit();
    wait();
}

bool SlaveCtrl::CheckLen(FRAME_DATA *recv)
{
    if(recv->Len >= 18)
    {
        return true;
    }
    return false;
}
bool SlaveCtrl::CheckSYNCode(FRAME_DATA *recv)
{
    if(recv->SYNCode == SYSCODE)
    {
        return true;
    }
    return false;
}
bool SlaveCtrl::CheckCRC(FRAME_DATA *recv)
{
    unsigned short Temp = recv->CRC;
    recv->CRC =0;
    recv->CRC = CRC16::CalCRC16(recv,recv->Len);
    if(recv->CRC == Temp)
    {
        return true;
    }
    return false;
}
bool SlaveCtrl::WriteFrameData(FRAME_DATA *Sent)
{
    QByteArray arrTest;
    arrTest.append(reinterpret_cast<char *>(Sent),Sent->Len);
    //qDebug()<<arrTest.toHex();
    if(ServerFlag)
    {
        if(tcpSocket->write(arrTest)==Sent->Len)
        {
            tcpSocket->flush();
            tcpSocket->waitForBytesWritten(1000);
            return true;
        }
        else
            return false;
    }
    else if(ClientFlag)
    {
        if(tcpClient->write(arrTest)==Sent->Len)
        {
            tcpClient->flush();
            tcpClient->waitForBytesWritten(1000);
            return true;
        }
        else
            return false;
    }
    else
        return false;
}

bool SlaveCtrl::ReadFrameHead(FRAME_DATA *recv, FRAME_DATA *Sent)
{
    if(CheckSYNCode(recv) == true)
    {
        if(CheckLen(recv) == false)
        {
            Sent->RecState = LEN_ERR;
        }
        return true;
    }
    else
    {
        return false;
    }
}

bool SlaveCtrl::ReadFrameData(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    if(ReadFrameHead(&recv,&Sent) == true)
    {
        if(Sent.RecState == SUCCEED)
        {
            if(CheckCRC(&recv) == false)
            {
                Sent.RecState = CRC_ERR;
            }
        }
        return true;
    }
    return false;
}
//----------------------------------------------------------------------------------

quint16 SlaveCtrl::getMonData(quint8 *info,quint16 MonNum)
{
    static quint8 cnt = 0;
    static quint8 bak_state = 0;
    MON_DATA mondata;
    memset(&mondata,0,sizeof(MON_DATA));
    for(int i=0;i<4;i++)
    {
        mondata.GroupVol[i] = work_page->work_thread->fboData.SumVoltage;
        mondata.GroupCur[i] = work_page->work_thread->fboData.SubCurrent[i];
        mondata.reserved[0] = work_page->work_thread->fboData.OnlineVol;
        if(work_page->work_thread->localData.SysWorkState == Discharging || work_page->work_thread->localData.SysWorkState == Paused_Dischg)
        {
            bak_state = work_page->work_thread->localData.SysWorkState;
            cnt = 5;
        }
        else
            cnt = 0;

        if((cnt > 0) && (work_page->work_thread->localData.SysWorkState == WorkStopped))
        {
            cnt--;
            mondata.BattStatus[0] = bak_state + 0x80;
            mondata.GroupCur[0] = 0;
        }
        else
        {
            mondata.BattStatus[0] = work_page->work_thread->localData.SysWorkState + 0x80;
            bak_state = work_page->work_thread->localData.SysWorkState;
            if(work_page->work_thread->localData.SysWorkState == WorkStopped/* && work_page->work_thread->localData.deviceTestType != TYPE_ON_LINE*/)
                mondata.GroupCur[0] = 0;
        }
    }
    mondata.BattStatus[1] = 0x80;
    mondata.BattStatus[2] = 0x80;
    mondata.BattStatus[3] = 0x80;
    if(MonNum>300)
        MonNum = 100;
    memcpy(mondata.MonomerVol,work_page->work_thread->fboData.SingleVol,MonNum*2);
    memcpy(info,&mondata,32 + MonNum*2);

    return 32 + MonNum*2;
}

//quint16 SlaveCtrl::getAdjData(quint8 *info)
//{
//    ADJ_DATA adjdata;
//    memset(&adjdata,0,sizeof(adjdata));
//    adjdata.OnlineVol = work_page->work_thread->fboData.OnlineVol;
//    adjdata.GroupVol = 0.1*work_page->work_thread->fboData.SumVoltage;
//    adjdata.dis_cur = 0.1*work_page->work_thread->fboData.SumCurrent;
//    adjdata.chr_cur = 0.1*work_page->work_thread->fboData.SumCurrent;
//    adjdata.out_cur = 0;

//    memcpy(info,&adjdata,sizeof(ADJ_DATA));
//    return sizeof(ADJ_DATA);
//}

quint16 SlaveCtrl::getTestData(quint8 *info)
{
    TEST_DATA testdata;
    memset(&testdata,0,sizeof(testdata));
    testdata.OnlineVol = work_page->work_thread->fboData.OnlineVol;
    testdata.GroupVol = work_page->work_thread->fboData.SumVoltage;
    testdata.CurrTime = work_page->work_thread->getTestFileTime();
    testdata.testtime = work_page->work_thread->fboData.m_TestTime;

    if(work_page->work_thread->localData.SysWorkState == Paused_Dischg ||
       work_page->work_thread->localData.SysWorkState == Paused_charge)
    {
        testdata.KeyState = 1;
    }
    else if(work_page->work_thread->localData.SysWorkState == Charging ||
       work_page->work_thread->localData.SysWorkState == WaitForCharging)
    {
        testdata.KeyState = work_page->work_thread->localData.SysWorkState-1;
    }
    else
    {
        testdata.KeyState = work_page->work_thread->localData.SysWorkState;
    }
    if(work_page->work_thread->localData.SysWorkState == Discharging)
        testdata.monomerCount = work_page->work_thread->localData.monomerLowCount;
//    else if(work_page->work_thread->localData.SysWorkState == Charging)
//        testdata.monomerCount = work_page->work_thread->localData.monomerHighCount;

    testdata.curr_cur = work_page->work_thread->fboData.SumCurrent;//*0.1
    testdata.AllCap = work_page->work_thread->fboData.AllCap;
    testdata.SMaxIndex = work_page->work_thread->localData.SMaxIndex[0];
    testdata.SMaxVol = work_page->work_thread->localData.SMaxVol[0];
    testdata.SMinIndex = work_page->work_thread->localData.SMinIndex[0];
    testdata.SMinVol = work_page->work_thread->localData.SMinVol[0];
    testdata.dischgTimes = work_page->work_thread->localData.dischgTimes;
    //testdata.HighTemp = work_page->work_thread->GetBYDInfo()->temp_hight;
    //testdata.LowTTemp = work_page->work_thread->GetBYDInfo()->temp_low;
    if(work_page->work_thread->localData.SysWorkState == WorkStopped/* && work_page->work_thread->localData.deviceTestType != TYPE_ON_LINE*/)
        testdata.curr_cur = 0;
    if(work_page->work_thread->fboData.SumVoltage<F0VOL)
    {
       testdata.reserved[0] = work_page->work_thread->localData.RLY_OK&(~IGBT_VALUE);
    }
    else
       testdata.reserved[0] = work_page->work_thread->localData.RLY_OK&(IGBT_VALUE_X);
    memcpy(info,&testdata,sizeof(TEST_DATA));

    return sizeof(TEST_DATA);
}
quint8 *SlaveCtrl::getFileDataHead(FILE_LIST_DATA &data,TEST_DATA_INFO &test_info,quint8 total,quint8 Index)
{
    data.TotalFileNum = total;
    data.CurrFileIndex = Index;
    data.TestStartTime = test_info.fbo_data_head_start.TestStartTime;
    data.TestTimeLong = test_info.fbo_data_head_stop.TestTimeLong;
    data.DataType = test_info.fbo_data_head_start.DataType;
    data.TestCur = test_info.fbo_data_head_start.TestCur;
    data.TestCap = test_info.fbo_data_head_stop.TestCap;
    data.STDCap = test_info.fbo_data_head_start.STDCap;
    data.MVLLimit = test_info.fbo_data_head_start.MVLLimit;
    data.SumVLLimit = test_info.fbo_data_head_start.SumVLLimit;
    data.BattSum = test_info.fbo_data_head_start.BattSum;
    data.BattGroup = test_info.fbo_data_head_start.BattGroup;
    data.StopType = test_info.fbo_data_head_stop.StopType;
    data.MonomerVol = test_info.fbo_data_head_start.MonomerVol;

    return (quint8 *)&data;
}

quint16 SlaveCtrl::getPageFileData(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    quint8 i;
    quint8 page = recv.Db1;
    quint16 j=0;
    FileManage fileManage;
    QStringList nameList = fileManage.getFiles(work_page->batteryName+"/",".FBO");

    TEST_DATA_INFO test_info;
    FILE_LIST_DATA file_data;

    if(page*8 > nameList.count())
    {
        Sent.RecState = FILE_DATA_ERR;
        return 0;
    }

    for(i=0;i<8 && i+page*8<nameList.count();i++)
    {
        if(ClassXML::AnalysisDataFBO(dataDir+work_page->batteryName+"/"+nameList.at(i+page*8),test_info))
        {
            getFileDataHead(file_data,test_info,nameList.count(),i+page*8);
            memcpy(Sent.info+j,&file_data,sizeof(FILE_LIST_DATA));
            j += sizeof(FILE_LIST_DATA);
        }
    }
    return j;
}

quint16 SlaveCtrl::getFileSmallBlock(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    quint16 Cnt_len=0;
    quint16 total_block=0;
    quint16 file_index = recv.RecState*256+recv.type;
    quint16 smallBlock = recv.workState*256+recv.Alarm;
    FileManage fileManage;
    QStringList nameList = fileManage.getFiles(work_page->batteryName+"/",".FBO");

    if(file_index >= nameList.count())
    {
        Sent.RecState = FILE_DATA_ERR;
        return 0;
    }
    if(ClassXML::ReadsmallBlockDataFBO(dataDir+work_page->batteryName+"/"+nameList.at(file_index),
                Sent.info,Cnt_len,total_block,smallBlock))
    {
        Sent.Db1 = (total_block>>8)&0xFF;
        Sent.Db2 = (total_block)&0xFF;
        Sent.Db3 = (smallBlock>>8)&0xFF;
        Sent.Db4 = (smallBlock)&0xFF;
        return Cnt_len;
    }
    return 0;
}
quint16 SlaveCtrl::getBattName(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    quint16 batt_index = recv.RecState*256+recv.type;
    QStringList batt_list = FileManage::getDirs();
    quint16 batt_total = batt_list.count();

    if(batt_index >= batt_total)
    {
        Sent.RecState = FILE_DATA_ERR;
        return 0;
    }
    Sent.Db1 = (batt_total>>8)&0xFF;
    Sent.Db2 = batt_total&0xFF;
    Sent.Db3 = recv.RecState;
    Sent.Db4 = recv.type;

    QString battname = batt_list.at(batt_index);
    memcpy(Sent.info,battname.toUtf8().data(),battname.toUtf8().length());
    return battname.toUtf8().length();
}
quint16 SlaveCtrl::getfileName(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    quint16 batt_index = recv.RecState*256+recv.type;//FF
    quint16 file_index = recv.workState*256+recv.Alarm;//0
    QStringList batt_list = FileManage::getDirs();
    quint16 batt_total = batt_list.count();
    if(batt_index >= batt_total)
    {
        Sent.RecState = FILE_DATA_ERR;
        return 0;
    }
    QStringList file_List = FileManage::getFiles(batt_list.at(batt_index)+"/",".FBO");
    quint16 file_total = file_List.count();
    if(file_index >= file_total)
    {
        Sent.RecState = FILE_DATA_ERR;
        return 0;
    }

    Sent.Db1 = (file_total>>8)&0xFF;
    Sent.Db2 = file_total&0xFF;
    Sent.Db3 = recv.workState;
    Sent.Db4 = recv.Alarm;

    QString filename = file_List.at(file_index);
    memcpy(Sent.info,filename.toUtf8().data(),filename.toUtf8().length());
    return filename.toUtf8().length();
}

quint16 SlaveCtrl::getSelectFile(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    QString path_name = QString::fromUtf8((const char *)recv.info,recv.Len-18);
    //qDebug()<<"111111"<<path_name;
    quint16 Cnt_len=0;
    quint16 total_block=0;
    quint16 smallBlock = recv.RecState*256+recv.type;

    if(ClassXML::ReadsmallBlockDataFBO(dataDir+path_name,
                Sent.info,Cnt_len,total_block,smallBlock))
    {
        if(smallBlock >= total_block)
        {
            Sent.RecState = FILE_DATA_ERR;
        }
        Sent.Db1 = (total_block>>8)&0xFF;
        Sent.Db2 = (total_block)&0xFF;
        Sent.Db3 = (smallBlock>>8)&0xFF;
        Sent.Db4 = (smallBlock)&0xFF;
        return Cnt_len;
    }
    Sent.RecState = OTHER_ERR;
    return 0;
}

quint16 SlaveCtrl::getVersion(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    Sent.RecState = recv.RecState;
    QString battname = phoneVersion;
    memcpy(Sent.info,battname.toUtf8().data(),battname.toUtf8().length());
    return battname.toUtf8().length();
}

void SlaveCtrl::SaveTestParam(const QString &fname,TEST_PARAM_XML &test_param)
{
    if(ClassXML::CreateTestParamXml(fname,test_param)) //新建的
    {

    }
    else //原有的
    {
        ClassXML::ModifyTestParamXml(fname,test_param);
    }
}

void SlaveCtrl::NewBattFile(quint8 *info)
{
    QString newname((const char *)info);
    if(work_page->batteryName != newname)
    {
        ClassXML::ModifyNewestPNameXml(newname);
        work_page->batteryName = newname;
        SaveTestParam(newname,work_page->test_param_xml);
    }
}
bool SlaveCtrl::SelectBatt(quint8 *info)
{
    QString newname((const char *)info);
    TEST_PARAM_XML testParam;
    if(true == ClassXML::ReadTestParamXml(newname, testParam))
    {
        ClassXML::ModifyNewestPNameXml(newname);
        work_page->batteryName = newname;
        emit sendParam(PARAM_PAGE_CMD_PARAM);
        return true;
    }
    return false;
}
void SlaveCtrl::DeleteBatt(quint8 *info)
{
    QString newname((const char *)info);
    FileManage fileManage;

    if(newname == Default_Battery)
    {
        fileManage.clearDirectoryFiles(Default_Battery,fileManage.getFiles(Default_Battery,".FBO"));
    }
    else
    {
        fileManage.removeDir(dataDir+newname);
    }

    if(work_page->batteryName == newname)
    {
        newname = Default_Battery;
        ClassXML::ModifyNewestPNameXml(newname);
        work_page->batteryName = newname;
        emit sendParam(PARAM_PAGE_CMD_PARAM);
    }
}

//----------------------------------------------------------------------------------
void SlaveCtrl::SlaveClearHeart()
{
    work_page->work_thread->localData.tcp_ctrl.heart_cnt = 0;
}

void SlaveCtrl::SlaveDisposeCMD(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    if((work_page->work_thread->localData.tcp_ctrl.Enter_ctrl == 0)&&(recv.CMD != EnterSlave))
    {
        Sent.RecState = SLAVEMODE_ERR;
        return;
    }

    switch (recv.CMD) {
    case Heartbea:
        //SlaveClearHeart(dev);
        break;
    case ExitSlave:
        work_page->work_thread->localData.tcp_ctrl.Enter_ctrl = 0;
        break;
    case EnterSlave:
        if(work_page->work_thread->localData.tcp_ctrl.Enter_ctrl)
        {
            break;
        }
//        qDebug("get CMD = %x",recv.CMD);
        work_page->work_thread->localData.tcp_ctrl.Enter_ctrl = 1;
        if(work_page->work_thread->localData.SysWorkState == WorkStopped && work_page->work_thread->localData.pauseBtnState == 0)
        {
            emit SendInterface(FACE_HOME);
        }
        else
        {
            Sent.RecState = SLAVEMODE_ERR;
        }
        break;
    case StartDischarge:
        if((work_page->work_thread->localData.SysWorkState == WorkStopped||work_page->work_thread->localData.SysWorkState == Paused_Dischg)&&
            work_page->work_thread->localData.pauseBtnState!=2)
            emit sendParam(PARAM_PAGE_CMD_START_DIS);//emit sendStart(work_page->work_thread->CMD_StartDischarge,work_page->batteryName);
        else
            Sent.RecState = START_ERR;
        break;
    case PausetDischarge:
        if(work_page->work_thread->localData.SysWorkState == Discharging || work_page->work_thread->localData.SysWorkState == Paused_Dischg)
            emit sendParam(PARAM_PAGE_CMD_PAUSE);//emit sendStart(work_page->work_thread->CMD_PauseDischarge,work_page->batteryName);
        else
            Sent.RecState = START_ERR;
        break;
    case StopDischarge:
        if(work_page->work_thread->localData.SysWorkState == Paused_Dischg ||
           work_page->work_thread->localData.SysWorkState == Discharging ||
           work_page->work_thread->localData.SysWorkState == WaitForCharging )
            emit sendParam(PARAM_PAGE_CMD_STOP);//emit sendStart(work_page->work_thread->CMD_StopDischarge,work_page->batteryName);
        else
            Sent.RecState = START_ERR;
        break;
    case StartCharge:
        if(work_page->work_thread->localData.SysWorkState == WorkStopped ||work_page->work_thread->localData.SysWorkState == Paused_charge)
            emit sendParam(PARAM_PAGE_CMD_START_CHR);//emit sendStart(work_page->work_thread->CMD_StartCharge,work_page->batteryName);
        else
            Sent.RecState = START_ERR;
        break;
    case PauseCharge:
        if(work_page->work_thread->localData.SysWorkState == Charging)
            emit sendParam(PARAM_PAGE_CMD_PAUSE);//emit sendStart(work_page->work_thread->CMD_PauseCharge,work_page->batteryName);
        else
            Sent.RecState = START_ERR;
        break;
    case StopCharge:
        if(work_page->work_thread->localData.SysWorkState == Paused_charge || work_page->work_thread->localData.SysWorkState == Charging)
            emit sendParam(PARAM_PAGE_CMD_STOP);//emit sendStart(work_page->work_thread->CMD_StopCharge,work_page->batteryName);
        else
            Sent.RecState = START_ERR;
        break;
//    case StartCycle:
//        if(work_page->work_thread->localData.SysWorkState == WorkStopped && work_page->work_thread->localData.deviceTestType == TYPE_CYCLE_TEST)
//        {
//            if(START_DISCHG == testParam.cycle_start)
//                emit sendParam(PARAM_PAGE_CMD_START_DIS);
//            else if(START_CHARGE == testParam.cycle_start)
//                emit sendParam(PARAM_PAGE_CMD_START_CHR);
//            else
//                Sent.RecState = START_ERR;
//        }
//        else
//            Sent.RecState = START_ERR;
//        break;
//    case PauseCycle:
//        if(work_page->work_thread->localData.SysWorkState != WorkStopped && work_page->work_thread->localData.deviceTestType == TYPE_CYCLE_TEST)
//            emit sendParam(PARAM_PAGE_CMD_PAUSE);
//        else
//            Sent.RecState = START_ERR;
//        break;
//    case StopCycle:
//        if(work_page->work_thread->localData.SysWorkState != WorkStopped && work_page->work_thread->localData.deviceTestType == TYPE_CYCLE_TEST)
//            emit sendParam(PARAM_PAGE_CMD_STOP);
//        else
//            Sent.RecState = START_ERR;
//        break;
//    case Adjust_StartDischarge:
//        if(work_page->work_thread->localData.SysWorkState == WorkStopped)
//            emit sendStart(work_page->work_thread->CMD_Adj_StartDis,work_page->batteryName);
//        else
//            Sent.RecState = START_ERR;
//        break;
//    case Adjust_StartCharge:
//        if(work_page->work_thread->localData.SysWorkState == WorkStopped)
//            emit sendStart(work_page->work_thread->CMD_Adj_StartChr,work_page->batteryName);
//        else
//            Sent.RecState = START_ERR;
//        break;
//    case Adjust_Stop:
//        if(work_page->work_thread->localData.SysWorkState == Discharging)
//            emit sendStart(work_page->work_thread->CMD_Adj_StopDis,work_page->batteryName);
//        else if(work_page->work_thread->localData.SysWorkState == Charging)
//            emit sendStart(work_page->work_thread->CMD_Adj_StopChr,work_page->batteryName);
//        else
//            Sent.RecState = START_ERR;
//        break;
//    case SetAdjustParm:
//        if(recv.RecState == ADJ_VOL)
//            emit SendCurrAdjCMD(work_page->work_thread->CMD_SetGroupVol,
//                (recv.type*256+recv.workState-work_page->work_thread->localData.sim_buf.ADCVdin));
//        else if(recv.RecState == ADJ_DIS)
//            emit SendCurrAdjCMD(work_page->work_thread->CMD_SetDisChargCur,
//                (recv.type*256+recv.workState-work_page->work_thread->localData.sim_buf.ADCId));
//        else if(recv.RecState == ADJ_CHR)
//            emit SendCurrAdjCMD(work_page->work_thread->CMD_SetChargCur,
//                (recv.type*256+recv.workState-work_page->work_thread->localData.sim_buf.ADCIc));
//        else
//            Sent.RecState = START_ERR;
//        break;

    case SetDischargeParam:
    case SetChargeParam:
    case SetCycleParam:
        if(sizeof(COMM_TEST_PARAM) == (recv.Len - 18))
        {
            TEST_PARAM_XML testParam;
            setTestCommParam(testParam,recv.info);
            //memcpy(addr,recv.info,sizeof(testParam));
            SaveTestParam(work_page->batteryName,testParam);
            emit sendParam(PARAM_PAGE_CMD_PARAM);
        }
        break;

    case EnterHome:
    {
        quint8 pageIndex = 0;
        if(recv.Len > 18)
        {
            pageIndex = recv.info[0];
        }
        else
        {
             pageIndex = recv.RecState;
        }
        //qDebug("pageIndex = %d,work_page->work_thread->localData.Interface=%d",pageIndex,work_page->work_thread->localData.Interface);
        if(pageIndex != work_page->work_thread->localData.Interface)
        {
            if(work_page->work_thread->localData.SysWorkState == Paused_Dischg      ||
               work_page->work_thread->localData.SysWorkState == Paused_charge      ||
               work_page->work_thread->localData.SysWorkState == Discharging ||
               work_page->work_thread->localData.SysWorkState == Charging    ||
                work_page->work_thread->localData.SysWorkState == WaitForCharging)
                Sent.RecState = SYSTEM_WORKING;
            else
            {
                emit SendInterface(pageIndex);
            }
        }
        break;
    }
    case NewBatt:
        NewBattFile(recv.info);
        break;
    case ChangedBatt:
        if(!SelectBatt(recv.info))
            Sent.RecState = OTHER_ERR;
        break;
    case DelBatt:
        DeleteBatt(recv.info);
        break;
    case ClearAlarm:
        work_page->work_thread->localData.popBox = 0;
        emit sendParam(PARAM_PAGE_CLOSE_BOX);
        break;
    case SetTKQState:
        emit sendParam(PARAM_PAGE_CMD_START_PSW);
        break;
    case SetFanState:
        emit sendParam(PARAM_PAGE_CMD_START_FAN);
        break;
    case GetBattName:
    case GetFileName:
    case GetSelectFile:
    case GetCellData:
    case GetDischargeParam:
    case GetChargeParam:
    case GetDischargeData:
    case GetChargeData:
    case GetCycleParam:
    case GetAdjustData:
    case GetFileInfo:
    case GetFile:

    default:
        break;
    }
}

void SlaveCtrl::SlaveSentFrame(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    static quint8 cnt = 0;
    static quint8 bak_state = 0;
    Sent.SYNCode = SYSCODE;
    Sent.CMD = recv.CMD;

    Sent.Len = 18;
    Sent.type = work_page->work_thread->localData.Interface + 0x80;

    if(work_page->work_thread->localData.SysWorkState == Discharging || work_page->work_thread->localData.SysWorkState == Paused_Dischg)
    {
        bak_state = work_page->work_thread->localData.SysWorkState;
        cnt = 5;
    }
    else
        cnt = 0;

    if((cnt > 0) && (work_page->work_thread->localData.SysWorkState == WorkStopped))
    {
        cnt--;
        Sent.workState = bak_state;
        work_page->work_thread->fboData.SubCurrent[0] = 0;
        work_page->work_thread->fboData.SumCurrent = 0;
    }
    else
    {
        Sent.workState = work_page->work_thread->localData.SysWorkState;
        bak_state = work_page->work_thread->localData.SysWorkState;
    }
    if(work_page->work_thread->localData.TestType == TestTypeCharge)
        Sent.Alarm = work_page->work_thread->localData.WPAlarmState  + work_page->work_thread->localData.popBox + 0x40;
    else
        Sent.Alarm = work_page->work_thread->localData.WPAlarmState  + work_page->work_thread->localData.popBox;

    switch (recv.CMD) {
    case Heartbea:
        Sent.Db1 = work_page->work_thread->localData.tcp_ctrl.ID;
        memcpy(Sent.info,work_page->batteryName.toUtf8().data(),work_page->batteryName.toUtf8().length());
        Sent.Len += work_page->batteryName.toUtf8().length();
        break;
    case ExitSlave:
    case StartDischarge:
    case PausetDischarge:
    case StartCharge:
    case PauseCharge:
    case SetAdjustParm:
    case Adjust_StartDischarge:
    case Adjust_StartCharge:
    case Adjust_Stop:
    case NewBatt:
    case ChangedBatt:
    case DelBatt:
    case StopDischarge:
    case StopCharge:
    case ClearAlarm:
    case StartCycle:
    case PauseCycle:
    case StopCycle:
    case EnterHome:
        break;
    case EnterSlave:
        Sent.Db1 = Version;
        Sent.Db2 = 0;
        Sent.Db3 = 0xF4;
        break;
    case GetDischargeParam:
    case GetChargeParam:
    case GetCycleParam:
//        Sent.info = (quint8 *)&testParam;
//        Sent.Len += sizeof(testParam);
        getTestCommParam(work_page->test_param_xml,Sent.info);
        Sent.Len += sizeof(COMM_TEST_PARAM);
        break;

    case GetCellData:
        Sent.Db1 = work_page->test_param_xml.mon_number>>8;
        Sent.Db2 = work_page->test_param_xml.mon_number & 0xFF;

        Sent.Len += getMonData(Sent.info,work_page->work_thread->fboData.BattSum);
        break;
    case SetDischargeParam:
    case SetChargeParam:
    case SetCycleParam:
        Sent.Db1 = recv.Db1;
        break;

    case GetDischargeData:
    case GetChargeData:
        if(work_page->work_thread->localData.waitTimeCount)
        {
            Sent.Db2 = 1;
            quint16 timesec = work_page->work_thread->localData.waitTimeCount;
            Sent.Db3 = timesec/256;
            Sent.Db4 = timesec%256;
        }
        else if(((work_page->work_thread->localData.SysWorkState == Charging)&&(recv.CMD == GetDischargeData))
            ||((work_page->work_thread->localData.SysWorkState == Discharging)&&(recv.CMD == GetChargeData)))
        {
            Sent.Db2 = 2;
        }
        Sent.Len += getTestData(Sent.info);
        break;
//    case GetAdjustData:
//        Sent.Len += getAdjData(Sent.info);
//        break;
    case GetFileInfo:
        Sent.Len += getPageFileData(recv, Sent);
        break;
    case GetFile:
        Sent.Len += getFileSmallBlock(recv,Sent);
        break;
    case GetBattName:
        Sent.Len += getBattName(recv,Sent);
        break;
    case GetFileName:
        Sent.Len += getfileName(recv,Sent);
        break;
    case GetSelectFile:
        Sent.Len += getSelectFile(recv,Sent);
        break;
    case GetVersion:
        Sent.Len += getVersion(recv,Sent);
    default:
        break;
    }

    Sent.CRC = CRC16::CalCRC16(&Sent,Sent.Len);

    WriteFrameData(&Sent);

}

void SlaveCtrl::SlaveResponse(FRAME_DATA &recv,FRAME_DATA &Sent)
{
    if(Sent.RecState == SUCCEED)
    {
        SlaveClearHeart();//任何有效指令都当作心跳指令
        SlaveDisposeCMD(recv,Sent);
    }
    SlaveSentFrame(recv,Sent);
}

//---------------------------------------------------------------------
void SlaveCtrl::SlaveMode(FRAME_DATA &recv,FRAME_DATA &Sent)
{
    if(ReadFrameData(recv,Sent) == true)
    {
        //qDebug("recv.CMD = %x",recv.CMD);
        SlaveResponse(recv,Sent);
    }
}

/******************************************************************************************/
bool SlaveCtrl::MasterSentFrame(MASTER_CMD cmd_data)
{
    FRAME_DATA Sent;

    memset(&Sent,0,sizeof(Sent));

    Sent.SYNCode = SYSCODE;
    Sent.CMD = cmd_data.CMD;
    Sent.Len = 18;

    switch (cmd_data.CMD) {
    case Heartbea:
    case ExitSlave:
        break;
    case EnterSlave:
        Sent.RecState = 1;
        break;
    case GetDischargeParam:
    case GetChargeParam:
    case GetCycleParam:
        Sent.Db1 = cmd_data.Cid1;
        break;
    case SetDischargeParam:
    case SetChargeParam:
    case SetCycleParam:
        Sent.Db1 = cmd_data.Cid1;
        //Sent.info = (quint8 *)&testParam;
        getTestCommParam(work_page->test_param_xml,Sent.info);
//        memcpy(Sent.info,&testParam,sizeof());

        Sent.Len += sizeof(COMM_TEST_PARAM);
        break;
    case GetBattName:
    case GetFileName:
    case GetSelectFile:
    case GetCellData:
    case GetDischargeData:
    case GetChargeData:
    case GetAdjustData:
    case StartCharge:
    case PauseCharge:
    case Adjust_StartDischarge:
    case Adjust_StartCharge:
    case Adjust_Stop:
    case StopDischarge:
    case StopCharge:
    case ChangedBatt:
    case DelBatt:
    case ClearAlarm:
    case StartCycle:
    case PauseCycle:
    case StopCycle:
        break;
    case NewBatt:
        memcpy(Sent.info,work_page->batteryName.toUtf8().data(),work_page->batteryName.toUtf8().length());
        Sent.Len += work_page->batteryName.toUtf8().length();
        break;
    case GetFileInfo:
        Sent.Db1 = cmd_data.Cid1;
        break;
    case GetFile:
        Sent.RecState = cmd_data.RecState;
        Sent.type = cmd_data.Cid1;
        Sent.workState = cmd_data.Cid2;
        Sent.Alarm = cmd_data.Alarm;
        break;
    case StartDischarge:
    case PausetDischarge:
        Sent.RecState = cmd_data.Cid1;
        break;
    case SetAdjustParm:
        Sent.RecState = cmd_data.Cid1;
        Sent.type = cmd_data.Cid2;
        Sent.workState = cmd_data.Alarm;
        break;

    case EnterHome:
        Sent.RecState = cmd_data.RecState;
        break;
    default:
        break;
    }

    Sent.CRC = CRC16::CalCRC16(Sent.info, Sent.Len);

    return WriteFrameData(&Sent);
}
void SlaveCtrl::MasterDisposeCMD(FRAME_DATA &recv)
{
    work_page->work_thread->localData.master_data.Interface = recv.type;
    work_page->work_thread->localData.master_data.workState = recv.workState;
    work_page->work_thread->localData.master_data.Alarm = recv.Alarm;
    work_page->work_thread->localData.master_data.heart_cnt = 0;

    if(recv.RecState == SLAVEMODE_ERR)
    {
        work_page->work_thread->localData.master_data.Enter_ctrl = 0;
        return;
    }
    if(work_page->work_thread->localData.SysWorkState == WorkStopped)
    {
        if(work_page->work_thread->localData.master_data.workState == Discharging)
        {
            if(master_cmd.count() == 0)
                setMasterCmd(SlaveCtrl::StopDischarge);
        }
    }

    switch (recv.CMD) {
    case Heartbea:
        //work_page->work_thread->localData.master_data.heart_cnt = 0;
        //work_page->work_thread->localData.master_data.battname = QString::fromUtf8((const char *)recv.info,recv.Len-18);
        break;
    case ExitSlave:
        work_page->work_thread->localData.master_data.Enter_ctrl = 0;
        break;
    case EnterSlave:
        work_page->work_thread->localData.master_data.Enter_ctrl = 1;
        break;
    case GetBattName:
    case GetFileName:
    case GetSelectFile:
    case StartDischarge:
    case PausetDischarge:
    case StartCharge:
    case PauseCharge:
    case Adjust_StartDischarge:
    case Adjust_StartCharge:
    case Adjust_Stop:
    case SetAdjustParm:
    case SetDischargeParam:
    case SetChargeParam:
    case SetCycleParam:
    case GetDischargeParam:
    case GetChargeParam:
    case GetCycleParam:
    case StartCycle:
    case PauseCycle:
    case StopCycle:
        break;
    case GetCellData:
        if((quint16)(recv.Len-18) <= sizeof(MON_DATA))
        {
            memcpy(&work_page->work_thread->localData.master_data.Cell_data,recv.info,recv.Len-18);
        }
        break;
    case GetDischargeData:
    case GetChargeData:
        if((quint16)(recv.Len-18) <= sizeof(TEST_DATA))
        {
            memcpy(&work_page->work_thread->localData.master_data.test_data,recv.info,recv.Len-18);
        }
        break;

    case GetAdjustData:
        if((quint16)(recv.Len-18) <= sizeof(ADJ_DATA))
        {
            memcpy(&work_page->work_thread->localData.master_data.adj_data,recv.info,recv.Len-18);
        }
        break;
    case GetFileInfo:
    case GetFile:
    case EnterHome:
    case StopDischarge:
    case StopCharge:
    case NewBatt:
    case ChangedBatt:
    case DelBatt:
    case ClearAlarm:
        break;
    default:
        break;
    }
}

void SlaveCtrl::MasterMode(FRAME_DATA &recv, FRAME_DATA &Sent)
{
    if(waitRecvCnt)
    {
        --waitRecvCnt;
        if(ReadFrameData(recv,Sent) == true)
        {
            waitRecvCnt = 0;
            if(Sent.RecState == SUCCEED)
            {
                MasterDisposeCMD(recv);
            }
        }
        //qDebug("----%d",waitRecvCnt);
    }
    else
    {
        if(master_cmd.count() > 0)
        {
            if(MasterSentFrame(master_cmd.first()) == true)
            {
                waitRecvCnt = 5;
                master_cmd.removeFirst();
            }
        }
        else if(work_page->work_thread->localData.master_data.Enter_ctrl)
        {
            setMasterCmd(GetDischargeData);
        }
        else
        {
            ReadFrameData(recv,Sent);
        }
    }
}

void SlaveCtrl::setMasterCmd(CMD_TYPE CMD, quint8 status, quint8 Cid1, quint8 Cid2,quint8 arm)
{
    MASTER_CMD temp;
    temp.CMD = CMD;
    temp.RecState = status;
    temp.Cid1 = Cid1;
    temp.Cid2 = Cid2;
    temp.Alarm = arm;

    master_cmd.append(temp);
}

void SlaveCtrl::setTestCommParam(TEST_PARAM_XML &test_param,void *comm_param)
{
    if(PageType == IDCE48CT)
        test_param.test_mode    = OFFline_working;
    else if(PageType == FBI48CT)
        test_param.test_mode    = ONline_working;
    else
        test_param.test_mode    = ((COMM_TEST_PARAM *)comm_param)->test_mode;
    test_param.acstop_op    = ((COMM_TEST_PARAM *)comm_param)->acstop_op;
    test_param.nominal_cap  = ((COMM_TEST_PARAM *)comm_param)->nominal_cap;
    test_param.hourly_rate  = ((COMM_TEST_PARAM *)comm_param)->hourly_rate;
    if(((COMM_TEST_PARAM *)comm_param)->preset_cur>=MinCur)
        test_param.preset_cur   = ((COMM_TEST_PARAM *)comm_param)->preset_cur;
    else
        test_param.preset_cur = MinCur;
    test_param.preset_cap   = ((COMM_TEST_PARAM *)comm_param)->preset_cap;
    test_param.preset_time  = ((COMM_TEST_PARAM *)comm_param)->preset_time;
    test_param.mon_lower    = ((COMM_TEST_PARAM *)comm_param)->mon_lower;
    test_param.group_lower  = ((COMM_TEST_PARAM *)comm_param)->group_lower;
    test_param.mon_number   = ((COMM_TEST_PARAM *)comm_param)->mon_number;
    test_param.group_number = ((COMM_TEST_PARAM *)comm_param)->group_number;
    test_param.lower_number = ((COMM_TEST_PARAM *)comm_param)->lower_number;
    test_param.mon_vol      = ((COMM_TEST_PARAM *)comm_param)->mon_vol;
    if(PageType == FBO48CT || TYPE_FBI_10480 || TYPE_FBI_4548 || TYPE_FBI_20240)
        test_param.onlinevol_lowlimit = ((COMM_TEST_PARAM *)comm_param)->Reserved[0];
    else
        test_param.onlinevol_lowlimit = onlinevollow;

    test_param.booster_ceiling  = ((COMM_TEST_PARAM *)comm_param)->Reserved[1];
    test_param.charge_limit    = ((COMM_TEST_PARAM *)comm_param)->chrg_curr;
    test_param.temp_High    = ((COMM_TEST_PARAM *)comm_param)->chrg_temp;
    test_param.discharge_mode = ((COMM_TEST_PARAM *)comm_param)->dischg_mode;
    test_param.preset_power = ((COMM_TEST_PARAM *)comm_param)->pre_power;

    if(test_param.group_number*test_param.mon_number > 300)
        test_param.mon_number = 300/test_param.group_number;
    if(test_param.group_number>4)
        test_param.group_number = 4;
    if(test_param.group_number*test_param.mon_number > 300)
        test_param.mon_number = 300/test_param.group_number;
    if(test_param.lower_number<=0)
        test_param.lower_number = 1;
    if(test_param.preset_time<=0)
        test_param.preset_time = 1;

    if(!(test_param.mon_vol == 20 || test_param.mon_vol == 40 ||
       test_param.mon_vol == 60 || test_param.mon_vol  == 120 ||
       test_param.mon_vol == 12))
    {
        test_param.mon_vol      =   work_page->test_param_xml.mon_vol;
    }

}

void SlaveCtrl::getTestCommParam(TEST_PARAM_XML &test_param, void *comm_param)
{
    memset(comm_param,0x00,sizeof(COMM_TEST_PARAM));
    ((COMM_TEST_PARAM *)comm_param)->test_mode  = test_param.test_mode;
    ((COMM_TEST_PARAM *)comm_param)->acstop_op  = test_param.acstop_op;
    ((COMM_TEST_PARAM *)comm_param)->nominal_cap  = test_param.nominal_cap;
    ((COMM_TEST_PARAM *)comm_param)->hourly_rate  = test_param.hourly_rate;
    ((COMM_TEST_PARAM *)comm_param)->preset_cur   = test_param.preset_cur;
    ((COMM_TEST_PARAM *)comm_param)->preset_cap   = test_param.preset_cap;
    ((COMM_TEST_PARAM *)comm_param)->preset_time  = test_param.preset_time;
    ((COMM_TEST_PARAM *)comm_param)->mon_lower    = test_param.mon_lower;
    ((COMM_TEST_PARAM *)comm_param)->group_lower  = test_param.group_lower;
    ((COMM_TEST_PARAM *)comm_param)->mon_number   = test_param.mon_number;
    ((COMM_TEST_PARAM *)comm_param)->group_number = test_param.group_number;
    ((COMM_TEST_PARAM *)comm_param)->lower_number = test_param.lower_number;
    ((COMM_TEST_PARAM *)comm_param)->mon_vol      = test_param.mon_vol;
    ((COMM_TEST_PARAM *)comm_param)->Reserved[0] = test_param.onlinevol_lowlimit;
    ((COMM_TEST_PARAM *)comm_param)->Reserved[1]  = test_param.booster_ceiling;
    ((COMM_TEST_PARAM *)comm_param)->chrg_curr    = test_param.charge_limit;
    ((COMM_TEST_PARAM *)comm_param)->chrg_temp = test_param.temp_High;
    ((COMM_TEST_PARAM *)comm_param)->dischg_mode    = test_param.discharge_mode;
    ((COMM_TEST_PARAM *)comm_param)->pre_power = test_param.preset_power;
}

void SlaveCtrl::dataReceived()
{
    QByteArray buffer;
    //读取缓冲区数据
    if(ServerFlag)
        buffer = tcpSocket->readAll();
    else if(ClientFlag)
        buffer = tcpClient->readAll();
//    qDebug()<<buffer.toHex();
    if(!buffer.isEmpty())
    {
        FRAME_DATA frame_sent;
        memset(&frame_sent,0x00,sizeof(FRAME_DATA));
        FRAME_DATA *frame_recv = (FRAME_DATA*)buffer.data();
        SlaveMode(*frame_recv,frame_sent);
    }
}

void SlaveCtrl::deleteSocket()
{
    IF_CLOSEServer = IF_CLOSEClient = true;
}

void SlaveCtrl::Restartlisten(void)
{
    if(ClientFlag || NULL != tcpSocket)
        IF_CLOSEClient = true;
    qDebug("---Restartlisten-");
}

bool SlaveCtrl::isConnect(void)
{
    return (ServerFlag || ClientFlag);
}

void SlaveCtrl::sentClientConnect(const QString &hostName, quint16 port)
{
    if(tcpServer->isListening()||
       ServerFlag ||
       tcpServer->hasPendingConnections())
        IF_CLOSEServer = true;
    qDebug()<<hostName<<port;
    ClienthostName = hostName;
    Clientport = port;
}

void SlaveCtrl::run()
{
    tcpServer = new QTcpServer();
    tcpServer->setMaxPendingConnections(1);
    tcpSocket = new QTcpSocket();
    tcpClient = new QTcpSocket();
    Restartlisten();

    bool timeOut = true;
    while(true)
    {
        if(work_page->work_thread->localData.tcp_ctrl.mode==0)//服务端
        {
            if(!tcpServer->isListening())//开启监听
                tcpServer->listen(QHostAddress::Any, 6666);
            if(tcpServer->waitForNewConnection(5000, &timeOut)&&(!IF_CLOSEServer))
            {
                tcpSocket = tcpServer->nextPendingConnection();
                if(NULL != tcpSocket)
                {
                    ServerFlag = 1;
                    while(1)
                    {
                        if(tcpSocket->waitForReadyRead(30000)&&(!IF_CLOSEServer))
                        {
                            dataReceived();
                        }
                        else
                        {
                            work_page->work_thread->localData.tcp_ctrl.heart_cnt = 0;
                            work_page->work_thread->localData.tcp_ctrl.Enter_ctrl = 0;
                            break;
                        }
                    }
                }
            }
            ServerFlag = 0;
            IF_CLOSEServer = false;
            tcpSocket->close();
            tcpServer->close();
            msleep(500);
        }
        else//客户端
        {
            tcpClient->connectToHost(ClienthostName,Clientport);
            if(tcpClient->waitForConnected(5000)&&(!IF_CLOSEClient))
            {
                if(NULL != tcpClient)
                {
                    ClientFlag = 1;
                    while(1)
                    {
                        if(tcpClient->waitForReadyRead(30000)&&(!IF_CLOSEClient))
                        {
                            dataReceived();
                        }
                        else
                        {
                            work_page->work_thread->localData.tcp_ctrl.heart_cnt = 0;
                            work_page->work_thread->localData.tcp_ctrl.Enter_ctrl = 0;
                            break;
                        }
                    }
                }
            }
            ClientFlag = 0;
            IF_CLOSEClient = false;
            tcpClient->close();
            msleep(500);
        }
    }
}
//***********************************************************************************