#include "masterslave.h"
#include "ota_update.h"
#include "taskOpt.h"

uint32_t _msgid = 0;

void slave_send_data_to_uart(uint8_t type1, uint16_t type2,uint8_t *data,uint8_t len)
{
    MasterSlave *msg = NULL;
    uint16_t crc ;
    uint8_t sendlen;

    msg = (MasterSlave*)usart485TX_Buffer;
    memset(usart485TX_Buffer,0,sizeof(usart485TX_Buffer));

    msg->start = 0xFEFE;
    msg->msgId = _msgid++;
    msg->proVer = 2;
    msg->msgType1 = type1;
    msg->msgType2 = type2;

    memcpy(msg->comInfo.info,data,len);
    sendlen =  COMM_HEAD_LEN + len;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;


    crc = _crc16_get(usart485TX_Buffer,sendlen);
    msg->comInfo.info[len] = crc &0xff;
    msg->comInfo.info[len+1] = (crc>>8) &0xff;

    data_dump("send to 485:",usart485TX_Buffer,sendlen+2);
    usart_tx_dma_send(USART1,usart485TX_Buffer,sendlen+2);
}



static void slave_get_status_0x1002(uint8_t *buf,uint8_t *len,uint16_t devtypeM,uint32_t devSnM,uint8_t bself)
{
    status0x2002 *msg = (status0x2002*)buf;


    if(bself == SLAVE_OFFLINE){
        msg->devTypeM = g_devMsg.devType;
        msg->devSnM   = g_devMsg.devSn;
        msg->devTypeS = devtypeM;
        msg->devSnS   = devSnM;
        msg->identity = IDENTITY_SLAVE;

        msg->identity = g_iDentity;
        if(IDENTITY_MASTER == g_iDentity){
            memcpy(msg->cfgFileNo,g_table1027.confFileNum,8);
            msg->bHave4G  = g_devMsg.bHave4G;
        }
        else{
            memset(msg->cfgFileNo,0,8);
            msg->bHave4G  = 0;
        }
        msg->status = 0;
    }
    else {
        msg->devTypeM = devtypeM;
        msg->devSnM   = devSnM;
        msg->devTypeS = g_devMsg.devType;
        msg->devSnS   = g_devMsg.devSn;
        memcpy(msg->cfgFileNo,g_table1027.confFileNum,8);
        msg->identity = g_iDentity;
        msg->bHave4G  = g_devMsg.bHave4G;
        msg->status = 1;
        msg->lastResetType = g_devResetMsg.resetflag;
        msg->resetNum = g_devResetMsg.resetNum;
        msg->runTime  = Get_SysTick()/1000;
        msg->voltage = 0x00;
        msg->temperature = 0x00;
        msg->rssi4G  =  0 + 1000;
        msg->snr4G   = 0x00;
        msg->tempStamp = g_taskRunDa.timetamp;
        msg->reserve = 0x00;
    }

    *len = sizeof(status0x2002);

    return;
}
static void slave_get_status_0x1001(uint8_t *buf,uint8_t *len,uint16_t devtypeM,uint32_t devSnM)
{
    status0x2001 *msg = (status0x2001*)buf;

    msg->devTypeM = devtypeM;
    msg->devSnM   = devSnM;

    msg->devTypeS = g_devMsg.devType;
    msg->devSnS   = g_devMsg.devSn;

    msg->upCode   = 0;
    msg->bootVer  = g_devAppVer.bootVer;
    msg->ptVer    = g_devAppVer.ptVer;
    msg->appVer   = g_devAppVer.app1Ver;
    memcpy(msg->uuid,g_devfirmMsg.uuid,12);
    memset(msg->imei,0,15);
    memset(msg->iccid,0,20);
    msg->reserve = 0x00;


    *len = sizeof(status0x2001);

    return;
}
void slave_get_update_0x1001(uint8_t *outdata, uint8_t *len,uint16_t taskId)
{
    update0x2001 *msg = (update0x2001*)outdata;

    msg->devType = g_devMsg.devType;
    msg->devSn = g_devMsg.devSn;
    msg->appVer = 0x1001234;
    msg->taskId = taskId;
    msg->reserve = 0x00;

    *len = sizeof(update0x2001);
    return;
}


void slave_send_status_comm(uint16_t cmd,uint8_t *data,uint8_t len)
{
    MasterSlave *msg = NULL;
    uint16_t crc ;
    uint8_t sendlen;

    msg = (MasterSlave*)usart485TX_Buffer;
    memset(usart485TX_Buffer,0,sizeof(usart485TX_Buffer));

    msg->start = 0xFEFE;
    msg->msgId = _msgid++;
    msg->proVer = 2;
    msg->msgType1 = 0x02;
    msg->msgType2 = cmd;

    memcpy(msg->comInfo.info,data,len);
    sendlen =  COMM_HEAD_LEN + len;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;


    crc = _crc16_get(usart485TX_Buffer,sendlen);
    msg->comInfo.info[len] = crc &0xff;
    msg->comInfo.info[len+1] = (crc>>8) &0xff;

    data_dump("send:",usart485TX_Buffer,sendlen+2);
    usart_tx_dma_send(USART1,usart485TX_Buffer,sendlen+2);
}

void slave_send_data_0x2061(uint16_t devType, uint32_t devSn,uint8_t *data, uint8_t len,uint8_t bnew)
{
    MasterSlave *msg = NULL;
    uint16_t crc ;
    uint8_t sendlen;

    msg = (MasterSlave*)usart485TX_Buffer;
    memset(usart485TX_Buffer,0,sizeof(usart485TX_Buffer));

    msg->start = 0xFEFE;
    msg->msgId = _msgid++;
    msg->proVer = 2;
    msg->msgType1 = 0x03;
    msg->msgType2 = 0x2061;

    msg->comInfo.da2061.devTypeM = devType;
    msg->comInfo.da2061.devSnM  = devSn;
    msg->comInfo.da2061.devTypeS = g_devMsg.devType;
    msg->comInfo.da2061.devSnS = g_devMsg.devSn;
    msg->comInfo.da2061.bnewflag = bnew;
    msg->comInfo.da2061.palen = len;

    memcpy(msg->comInfo.da2061.info,data,len);
    sendlen = DATA_2061_LEN + COMM_HEAD_LEN + len;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;


    crc = _crc16_get(usart485TX_Buffer,sendlen);
    msg->comInfo.da2061.info[len] = crc &0xff;
    msg->comInfo.da2061.info[len+1] = (crc>>8) &0xff;

    data_dump("send:",usart485TX_Buffer,sendlen+2);
    usart_tx_dma_send(USART1,usart485TX_Buffer,sendlen+2);
}

void slave_send_log_0x2062(uint16_t devType, uint32_t devSn,uint8_t *data, uint8_t len)
{
    MasterSlave *msg = NULL;
    uint16_t crc ;
    uint8_t sendlen;

    msg = (MasterSlave*)usart485TX_Buffer;
    memset(usart485TX_Buffer,0,sizeof(usart485TX_Buffer));

    msg->start = 0xFEFE;
    msg->msgId = _msgid++;
    msg->proVer = 2;
    msg->msgType1 = 0x10;
    msg->msgType2 = 0x2062;

    msg->comInfo.lg2062.devTypeM = devType;
    msg->comInfo.lg2062.devSnM  = devSn;
    msg->comInfo.lg2062.devTypeS = g_devMsg.devType;
    msg->comInfo.lg2062.devSnS = g_devMsg.devSn;
    msg->comInfo.lg2062.palen = len;

    memcpy(msg->comInfo.lg2062.info,data,len);
    sendlen = LOG_2062_LEN + COMM_HEAD_LEN + len;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;


    crc = _crc16_get(usart485TX_Buffer,sendlen);
    msg->comInfo.lg2062.info[len] = crc &0xff;
    msg->comInfo.lg2062.info[len+1] = (crc>>8) &0xff;

   // data_dump_00("send:",usart485TX_Buffer,sendlen+2);
    usart_tx_dma_send(USART1,usart485TX_Buffer,sendlen+2);
}

void slave_send_log_0x2063(uint16_t devType, uint32_t devSn,uint8_t logtype,uint8_t *data, uint8_t len)
{
    MasterSlave *msg = NULL;
    uint16_t crc ;
    uint8_t sendlen;

    msg = (MasterSlave*)usart485TX_Buffer;
    memset(usart485TX_Buffer,0,sizeof(usart485TX_Buffer));

    msg->start = 0xFEFE;
    msg->msgId = _msgid++;
    msg->proVer = 2;
    msg->msgType1 = 0x10;
    msg->msgType2 = 0x2063;

    msg->comInfo.lg2063.devTypeM = devType;
    msg->comInfo.lg2063.devSnM  = devSn;
    msg->comInfo.lg2063.devTypeS = g_devMsg.devType;
    msg->comInfo.lg2063.devSnS = g_devMsg.devSn;
    msg->comInfo.lg2063.logtype = logtype;
    msg->comInfo.lg2063.reserve = 0x00;
    msg->comInfo.lg2063.palen = len;

    memcpy(msg->comInfo.lg2063.info,data,len);
    sendlen = LOG_2063_LEN + COMM_HEAD_LEN + len;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;


    crc = _crc16_get(usart485TX_Buffer,sendlen);
    msg->comInfo.lg2063.info[len] = crc &0xff;
    msg->comInfo.lg2063.info[len+1] = (crc>>8) &0xff;

   // data_dump_00("send:",usart485TX_Buffer,sendlen+2);
    usart_tx_dma_send(USART1,usart485TX_Buffer,sendlen+2);
}
void slave_send_data_0x2030(uint16_t devType, uint32_t devSn,uint8_t *data,uint8_t *cfigNo, uint8_t len)
{
    MasterSlave *msg = NULL;
    uint16_t crc ;
    uint8_t sendlen;

    msg = (MasterSlave*)usart485TX_Buffer;
    memset(usart485TX_Buffer,0,sizeof(usart485TX_Buffer));

    msg->start = 0xFEFE;
    msg->msgId = _msgid++;
    msg->proVer = 2;
    msg->msgType1 = 0x01;
    msg->msgType2 = 0x2030;

    msg->comInfo.sysMsg.devTypeM = devType;
    msg->comInfo.sysMsg.devSnM  = devSn;
    msg->comInfo.sysMsg.devTypeS = g_devMsg.devType;
    msg->comInfo.sysMsg.devSnS = g_devMsg.devSn;
    memcpy(msg->comInfo.sysMsg.sDa.s0x2030.configfileNo,cfigNo,8);// = bnew;
    msg->comInfo.sysMsg.sDa.s0x2030.reserve = 0;

    memcpy(msg->comInfo.info+SYSTEM_2030_LEN,data,len); // 24为2030的头
    sendlen = SYSTEM_2030_LEN + COMM_HEAD_LEN + len;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;


    crc = _crc16_get(usart485TX_Buffer,sendlen);
    msg->comInfo.info[len+SYSTEM_2030_LEN] = crc &0xff;
    msg->comInfo.info[len+1+SYSTEM_2030_LEN] = (crc>>8) &0xff;

    data_dump("send:",usart485TX_Buffer,sendlen+2);
    usart_tx_dma_send(USART1,usart485TX_Buffer,sendlen+2);
}
/*------------------------------------------- 主解析从的指令 并存储到4G 的发送fifo中---------------*/



/*-----------------------------------------------------------------------------
 *  从设备读取flash 中的交易记录 放入到485的发送fifo中
 *  flag : 1：主设备读取的，2：服务器读取的
 * ----------------------------------------------------------------------------*/
void slave_read_flash_data_to485(uint16_t devType, uint32_t devSn)
{
    uint8_t ret;
    XspDataInfo xspda;

    ret = read_flash(xspda.data,1);
    if(ret==1){ // 有新的交易记录
        printf("发送数据到服务器:recordId=%d,amount=%d,oil=%d,tamout=%lld,toil=%lld\r\n",\
               xspda.reDa.recordId,xspda.reDa.amount,xspda.reDa.oil,\
               xspda.reDa.tamount,xspda.reDa.toil);
        // 组成数据
        if((0xFFFFFFFF == xspda.reDa.recordId) && (xspda.reDa.price==0xFFFFFFFF)) {// 错误数据不上传
            slave_send_data_0x2061(devType, devSn,xspda.data,0,0);
        }
        else
            slave_send_data_0x2061(devType,devSn,xspda.data,64,1);
    }
    else { // 无新的交易记录
        slave_send_data_0x2061(devType, devSn,xspda.data,0,0);
    }
}
uint8_t master_check_dev_table(uint16_t devType, uint32_t devSn)
{
    volatile uint8_t i = 0;
    uint8_t flag;
    flag = 0;
    g_runNode.slaveNum = (g_runNode.slaveNum>NODE_MAX_SIZE ? NODE_MAX_SIZE:g_runNode.slaveNum);
    for(i=0;i<g_runNode.slaveNum;i++){
        if((devType== g_runNode.nodMsg[i].devType) \
           && (devSn == g_runNode.nodMsg[i].devSn)) {
            flag = 1;
            break;
        }
    }
    if(flag == 1){
        g_runNode.nodMsg[i].readCount = 0;
        g_runNode.nodMsg[i].status = 1;
        return i;
    }
    else
        return 0xFF;
}

void slave_system_cmd_0x1026(uint8_t *data)
{
    systemCmd *msg = (systemCmd*)(data);
    if((msg->sDa.s0x1026.appointDevModel == g_devMsg.devType)) {
        if((0xFFFFFFFF == msg->devSnS) ||(msg->devSnS == g_devMsg.devSn) ){ //

//            exti_interrupt_flag_clear(g_extimsg.extiLine); /* 清除中断 */
//            exti_interrupt_disable(g_extimsg.extiLine);
            epprom_init_com_config();
            epprom_write_com_config((uint8_t*)(&msg->sDa.s0x1026.priceInuseCout),sizeof(system0x1026)-6);
            epprom_read_com_config();
            exti_gpio_init();
//            exti_interrupt_enable(g_extimsg.extiLine);
            power_up_read_comm_min_time();
        }
    }
}


void anlaysis_0x1027(uint8_t *data,uint8_t framNo,uint16_t time)
{
    static uint8_t groupId;
    uint8_t flag = 0,i=0;
    sysCmd1027 *msg = (sysCmd1027*)data;

    if(0xFF == framNo){ // 单帧
        groupId = 0;
        memcpy((uint8_t*)&g_table1027,data,sizeof(sysCmd1027));
        g_table1027.groupNum = msg->groupNum;
        flag = 1;
    }
    else if((framNo&0x80) == 0x80){ // 多帧的第一帧
        groupId = 0;
        memcpy((uint8_t*)&g_temtable1027,data,sizeof(sysCmd1027));
        groupId = msg->groupNum;

    }
    else if((framNo%0x0F) != 0x01) { // 多帧的中间帧
        memcpy(g_temtable1027.table[groupId],msg->table,sizeof(sysCmd1027)-11);
        groupId += msg->groupNum;
    }
    else if((framNo&0x01) == 0x01) { // 多帧的最后一帧
        memcpy(g_temtable1027.table[groupId],msg->table,sizeof(sysCmd1027)-11);
        groupId += msg->groupNum;
        g_temtable1027.groupNum = groupId;
        flag = 1;
        memcpy(&g_table1027,&g_temtable1027,sizeof(sysCmd1027));// 将临时表中的数据放入到用到的表中
    }

    if( (1 == flag) ){
        if((0==time)){
            epprom_write_pin_config((uint8_t*)&g_table1027,(uint16_t)sizeof(sysCmd1027)); // 写入EEPROm中
            g_taskRunDa.bcfgfiletime = 0;
        }
        else {
            timeout_setValue(&g_taskRunDa.cfigFileTime,time*1000);
            timeout_start(&g_taskRunDa.cfigFileTime);
            g_taskRunDa.bcfgfiletime = 1;
        }
        for(i=0;i<g_table1027.groupNum;i++){
            if(i%10 == 0) printf("\r\n");
            printf("{%d,%2d},",g_table1027.table[i][0],g_table1027.table[i][1]);

        }
    }
}
void slave_system_cmd_0x1027(uint8_t *data)
{
    systemCmd *msg = (systemCmd*)data;

    if(msg->sDa.s0x1027.da1027.appointDevModel != g_devMsg.devType) return; // 不是本设备的设备类型

    if((0xFFFFFFFF != msg->devSnS) && (msg->devSnS != g_devMsg.devSn)) return;

    if((0xFF ==msg->sDa.s0x1027.framNo) ||(0x80 == (msg->sDa.s0x1027.framNo&0x80)) ){
        if(0 == msg->sDa.s0x1027.expireTime) epprom_init_pin_config();
    }
    anlaysis_0x1027((uint8_t*)&msg->sDa.s0x1027.da1027,msg->sDa.s0x1027.framNo,msg->sDa.s0x1027.expireTime);
}

void slave_system_cmd_0x1028(uint8_t *data)
{
    systemCmd *msg = (systemCmd*)data;
    uint8_t flag = 0; // 1: 主 2： 从 3： 主从
    if(0xFFFF == msg->devTypeS) flag = 3;
    else if(0xFFFFFFFF == msg->devSnS) flag = 3;
    else if(msg->devSnS == g_devMsg.devSn) flag = 1;
    else flag = 2;
    if((3==flag) ||(1==flag)){

        g_up7segData.bOpen = 1;
        if(0xFFFFFFFF == msg->sDa.s0x1028.time) {
            timeout_setValue(&g_up7segData.upTime,4000);
            g_up7segData.bofflineTest = 1;
        }
        else{
            timeout_setValue(&g_up7segData.upTime,msg->sDa.s0x1028.time*1000);
            g_up7segData.bofflineTest = 0;
        }
        timeout_start(&g_up7segData.upTime);
    }
}

void slave_system_cmd_0x1029(uint8_t *data)
{
    systemCmd *msg = (systemCmd*)data;
    uint8_t flag = 0; // 1: 主 2： 从 3： 主从
    if(0xFFFF == msg->devTypeS) flag = 3;
    else if(0xFFFFFFFF == msg->devSnS) flag = 3;
    else if(msg->devSnS == g_devMsg.devSn) flag = 1;
    else flag = 2;
    g_up7segData.bofflineTest = 0;
    if((3==flag) ||(1==flag)){
        g_up7segData.bOpen = 0;
        timeout_stop(&g_up7segData.upTime);
        if(msg->sDa.s0x1029.status == 1){ // 1保存
            epprom_write_pin_config((uint8_t*)&g_table1027,(uint16_t)sizeof(sysCmd1027));
        }
        else if(msg->sDa.s0x1029.status == 2){ //2放弃不存储，要读取回原来的数据
            epprom_read_pin_config();
        }
    }

}

/*----------------------------------------------------------------------------------
 *   解析系统类 0x01
 * ---------------------------------------------------------------------------------*/
void analysis_cmd_system(uint16_t cmd, uint8_t *data,uint8_t len)
{
    MasterSlave * pmsg = (MasterSlave*)data;
    commInfo_t *msg = &(pmsg->comInfo);

    if(0x1000 == (cmd&0x1000)) {
        if(0x1015 == cmd ){
            printf("收到时间同步指令\r\n");
            set_time(msg->sysMsg.sDa.s0x1015.timer);
            g_taskRunDa.timetamp = msg->sysMsg.sDa.s0x1015.timer;
            return;
        }
        if(0==check_dev_type_sn01(msg->sysMsg.devTypeS,msg->sysMsg.devSnS)) return;
        data_dump("收到数据",data,len);
        switch(cmd){
        case 0x1021: // 系统重启
            if(0x02 == msg->sysMsg.sDa.s0x1021.object)NVIC_SystemReset();
            break;
        case 0x1015: // 时间同步
            printf("收到时间同步指令\r\n");
            set_time(msg->sysMsg.sDa.s0x1015.timer);
            break;
        case 0x1026: // com配置文件
            slave_system_cmd_0x1026((uint8_t *)msg);
            break;
        case 0x1027: // 探针脚配置表
            slave_system_cmd_0x1027((uint8_t*)msg);
            break;
        case 0x1028: // 开启8段码上报
            slave_system_cmd_0x1028((uint8_t*)msg);
            break;
        case 0x1029: // 关闭8段码上报
            slave_system_cmd_0x1029((uint8_t*)msg);
            break;
        case 0x1030:
            slave_send_data_0x2030(msg->sysMsg.devTypeM,msg->sysMsg.devSnM,&g_7egDa[1],&g_table1027.confFileNum[0],28);
            break;
        }
    }
}
/*----------------------------------------------------------------------------------
 *   解析状态类 0x02
 * ---------------------------------------------------------------------------------*/
void analysis_cmd_status(uint16_t cmd, uint8_t *data,uint8_t len)
{
    uint8_t sendbuff[128], sendlen;
    MasterSlave *msg = (MasterSlave*)data;

    if(0x1000 == (cmd&0x1000)) { // 从设备处理
        if(0==check_dev_type_sn(msg->comInfo.statusMsg.devTypeS,msg->comInfo.statusMsg.devSnS)) return;
        data_dump("收到数据",data,len);
        memset(sendbuff,0,128);
        switch(cmd){
        case 0x1002: // 实时状态
            slave_get_status_0x1002(sendbuff,&sendlen,msg->comInfo.statusMsg.devTypeM,msg->comInfo.statusMsg.devSnM,SELF_STATUS);
            slave_send_status_comm(0x2002,sendbuff,sendlen);
            break;
        case 0x1001: // 固件信息
            slave_get_status_0x1001(sendbuff,&sendlen,msg->comInfo.statusMsg.devTypeM,msg->comInfo.statusMsg.devSnM);
            slave_send_status_comm(0x2001,sendbuff,sendlen);
            break;
        }
    }
}

/*----------------------------------------------------------------------------------
 *   解析数据类 0x03
 * ---------------------------------------------------------------------------------*/
void analysis_cmd_data(uint16_t cmd,uint8_t *data,uint8_t len)
{
    MasterSlave *msg = (MasterSlave*)data;
//    uint16_t sIndex = 0xFF;
    uint8_t ret;
    switch (cmd) {
    case 0x1061:
        if(0==check_dev_type_sn(msg->comInfo.da1061.devTypeS,msg->comInfo.da1061.devSnS)) break;
        data_dump("收到数据",data,len);
        if(0 == msg->comInfo.da1061.recordId) {
            if(g_xspErrDa.bsend ==2 ){
                slave_send_log_0x2062(msg->comInfo.da1061.devTypeM,msg->comInfo.da1061.devSnM,g_xspErrDa.segDa,16);
                g_xspErrDa.bsend = 1;
                //printf("~~~~~~~~~~~~~~~~~~~~~~~~发送错误数据\r\n");
            }
            else slave_read_flash_data_to485(msg->comInfo.da1061.devTypeM,msg->comInfo.da1061.devSnM);
        }
        else if(0xFFFFFFFF == msg->comInfo.da1061.recordId){ // 主设备按键读取
//            save_display_data_to_flash();
//            slave_read_flash_data_to485(msg->comInfo.da1061.devTypeM,msg->comInfo.da1061.devSnM);
        }
        else { // 服务器读取
            ret = xsp_check_point_record(msg->comInfo.da1061.recordId,g_xspReDa.data);
            if(1 == ret ){ // 说明已经找到的记录
                slave_send_data_0x2061(msg->comInfo.da1061.devTypeM,msg->comInfo.da1061.devSnM,g_xspReDa.data,64,2);
            }
        }
        break;

    default:
        break;
    }
}
/*----------------------------------------------------------------------------------
 *   解析升级类 0x04
 * ---------------------------------------------------------------------------------*/
void analysis_cmd_update(uint16_t cmd,uint8_t *data,uint8_t len)
{
    uint8_t sendbuff[128], sendlen;
    MasterSlave *msg = (MasterSlave*)data;

    if(0x2000 == (cmd&0x2000)){
        if((g_devMsg.workMode==WORK_UPDATE && g_updateDa.iDentity==IDENTITY_SLAVE)||0x01 ==g_updateDa.bResetUpdate) return;//被升级时,不处理
        data_dump("收到数据",data,len);
        switch(cmd){

        case 0x2007: //  收到从设备上报的升级状态
            set_start_ota_timer(&g_otaTimer.upstatusTmr,10*1000);
            master_update_status_rcv(msg->comInfo.info,msg->palen-2);
            printf("收到从设备上报的升级状态\r\n");
            break;
        case 0x2005: // 收到从设备的重传指令
            ota_update_master_retransmit(msg->comInfo.info);
            break;
        }
    }
    else if(0x1000 == (cmd&0x1000)) { // 从设备处理

        memset(sendbuff,0,128);
        switch(cmd){
        case 0x1001: // 获取设备版本
            if(0==check_dev_type_sn(msg->comInfo.upMsg.up0x1001.devType,msg->comInfo.upMsg.up0x1001.devSn)) return;
            data_dump("收到数据",data,len);
            slave_get_update_0x1001(sendbuff,&sendlen,msg->comInfo.upMsg.up0x1001.taskId);
            slave_send_data_to_uart(0x04,0x2001,sendbuff,sendlen);
            break;
        case 0x1003: case 0x1004: case 0x1005: case 0x1007: // 需要在升级时处理
            if(0==check_dev_type_sn(msg->comInfo.upMsg.up0x1001.devType,msg->comInfo.upMsg.up0x1001.devSn)) return;
            ota_timer_stop(&g_otaTimer.randomTmr);
            if(0x1005 == cmd) g_updateDa.bRetransmit = 0;
            //data_dump("收到升级指令",data,len);
            ota_update_slave_task(cmd,msg->comInfo.info,msg->palen-2);
            break;
        case 0x1006: // 离线升级
            ota_update_slave_offline(msg->comInfo.info,msg->palen-2);
            break;


        }
    }
}
/*----------------------------------------------------------------------------------
 *   解析日志类 0x10
 * ---------------------------------------------------------------------------------*/
void analysis_cmd_log(uint16_t cmd,uint8_t *data,uint8_t len)
{
    MasterSlave *msg = (MasterSlave*)data;
//    uint16_t sIndex = 0xFF;

    switch(cmd){
    case 0x1062:
        if(msg->comInfo.lg1062.devTypeS != DEV_TYPE) break;
        if((msg->comInfo.lg1062.devSnS != 0xFFFFFFFF)&& (msg->comInfo.lg1062.devSnS!= g_devMsg.devSn)) break;
        if(msg->comInfo.lg1062.time != 0) {
            g_logMsg.logType = msg->comInfo.lg1062.logType;
            g_logMsg.blogOpen = 1;
            timeout_setValue(&g_logMsg.timer,msg->comInfo.lg1062.time*1000);
            timeout_start(&g_logMsg.timer);
        }
        else{
            g_logMsg.logType = 0;
            g_logMsg.blogOpen = 0;
            timeout_stop(&g_logMsg.timer);
        }
        printf("收到 10---1062, delay = %d, type=%d\r\n",msg->comInfo.lg1062.time,msg->comInfo.lg1062.logType);
        break;
    case 0x1063:
        if(msg->comInfo.lg1063.devTypeS != DEV_TYPE) break;
        if((msg->comInfo.lg1063.devSnS != 0xFFFFFFFF)&& (msg->comInfo.lg1063.devSnS!= g_devMsg.devSn)) break;
        slave_send_log_0x2063(msg->comInfo.lg1063.devTypeM,msg->comInfo.lg1063.devSnM,msg->comInfo.lg1063.logType,g_testCollDa.sendCollNum,192);
        break;
//    case 0x2062: // 错误数据
//        sIndex = master_check_dev_table(msg->comInfo.lg2062.devTypeS,msg->comInfo.lg2062.devSnS);
//        if(sIndex == 0xFF) return;
//        fifo_write(&g_4Gtxfifo,data,len);// 直接透传
//        timeout_stop(&g_uart485.time);
//        break;
    }
}