0103_APP/App/masterslave.c

#include "masterslave.h"
#include "up_4g.h"
#include "air780e.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(UART3,usart485TX_Buffer,sendlen+2);


}

void master_read_status(uint16_t cmd,DevMsg *dev)
{
    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;

    msg->comInfo.statusMsg.devTypeM = dev->devType;
    msg->comInfo.statusMsg.devSnM  = dev->devSn;
    msg->comInfo.statusMsg.devTypeS = dev->devTypeS;
    msg->comInfo.statusMsg.devSnS  = dev->devSnS;

    sendlen = STATUS_COMM_LEN + COMM_HEAD_LEN;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;

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

    data_dump("send to 485:",usart485TX_Buffer,sendlen+2);
    usart_tx_dma_send(UART3,usart485TX_Buffer,sendlen+2);
    //fifo_write(&g_txfifo,usart485TX_Buffer,sendlen+2);
}
void master_read_data_0x1061(DevMsg *dev,uint32_t recordId)
{
    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 = 0x1061;

    msg->comInfo.da1061.devTypeM = dev->devType;
    msg->comInfo.da1061.devSnM  = dev->devSn;
    msg->comInfo.da1061.devTypeS = dev->devTypeS;
    msg->comInfo.da1061.devSnS = dev->devSnS;
    msg->comInfo.da1061.recordId = recordId;
    sendlen = DATA_1061_LEN + COMM_HEAD_LEN;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;

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

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

void master_read_data_0x1030(DevMsg *dev)
{
    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 = 0x1030;

    msg->comInfo.sysMsg.devTypeM = dev->devType;
    msg->comInfo.sysMsg.devSnM  = dev->devSn;
    msg->comInfo.sysMsg.devTypeS = dev->devTypeS;
    msg->comInfo.sysMsg.devSnS = dev->devSnS;
    msg->comInfo.sysMsg.sDa.s0x1030.reserve = 0x00;

    sendlen = SYSTEM_1030_LEN + COMM_HEAD_LEN;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;

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

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

void master_read_log_0x1063(DevMsg *dev)
{
    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 = 0x1063;

    msg->comInfo.lg1063.devTypeM = dev->devType;
    msg->comInfo.lg1063.devSnM  = dev->devSn;
    msg->comInfo.lg1063.devTypeS = dev->devTypeS;
    msg->comInfo.lg1063.devSnS = dev->devSnS;
    msg->comInfo.lg1063.logType = 0x03;
    msg->comInfo.lg1063.time  = 0x00;
    msg->comInfo.lg1063.interval  = 0x00;
    msg->comInfo.lg1063.reserve = 0x00;
    sendlen = LOG_1063_LEN + COMM_HEAD_LEN;
    msg->palen  = sendlen + 2 - COMM_HEAD_LEN;

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

    data_dump("send:",usart485TX_Buffer,sendlen+2);
    usart_tx_dma_send(UART3,usart485TX_Buffer,sendlen+2);
}
//void master_get_self_0x2030(void)
//{
//   uint8_t sendbuff[128],len;

//    memset(sendbuff,0,128);
//    up_system_cmd_0x2030(sendbuff,&g_7egDa[1],(uint8_t*)&g_table1027.confFileNum[0],&len);
//    add_data_to_4G_txfifo(sendbuff,len,0x01,0x2030);
//}

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  =  g_4gMsg.dBm + 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);
    memcpy(msg->imei,g_4gMsg.imei,15);
    memcpy(msg->iccid,g_4gMsg.iccid,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 master_add_status_to_4g_txfifo(uint8_t type1,uint16_t type2,uint16_t devType,uint32_t devSn, uint8_t bself)
{
    uint8_t sendbuff[128],sendlen;

    memset(sendbuff,0,128);
    if(0x2002 == type2) slave_get_status_0x1002(sendbuff,&sendlen,devType,devSn,bself);
    else slave_get_status_0x1001(sendbuff,&sendlen,devType,devSn);
    add_data_to_4G_txfifo(sendbuff,sendlen,type1,type2);
}

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(UART3,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(UART3,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(UART3,usart485TX_Buffer,sendlen+2);
}
/*------------------------------------------- 主解析从的指令 并存储到4G 的发送fifo中---------------*/
/*----------------------------------------------------------------------
 *  直接透传 状态指令 0x2002 0x2001
 * --------------------------------------------------------------------*/
void master_analysis_status_cmd(uint8_t *data, uint8_t size)
{
    fifo_write(&g_4Gtxfifo,data,size); // 直接透传

//END_02_0x2002:
    timeout_stop(&g_uart485.time);
    return;
}

extern timeout_t g_upstatusTime;
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;
        if(g_runNode.nodMsg[i].status == 0){ // 前一次是离线，离线后再上线
            timeout_stop(&g_upstatusTime);
            g_runNode.nodMsg[i].status = 1;
            g_runNode.devRunMsg[i].readNum = 4;
        }

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

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

    if(0x2000 == (cmd&0x2000)){
        data_dump("收到数据",data,len);
        switch(cmd){
        case 0x2030: // 8段码数据上报
            if((msg->sysMsg.devSnM == g_devMsg.devSn) && (msg->sysMsg.devTypeM== g_devMsg.devType)) {
                fifo_write(&g_4Gtxfifo,data,len); // 直接透传
                timeout_stop(&g_uart485.time);
                break;
            }
        }
    }

}
/*----------------------------------------------------------------------------------
 *   解析状态类 0x02
 * ---------------------------------------------------------------------------------*/
void analysis_cmd_status(uint16_t cmd, uint8_t *data,uint8_t len)
{
    uint8_t sendbuff[128], sendlen,sIndex;
    MasterSlave *msg = (MasterSlave*)data;
    status0x2001 *s2001Msg = NULL;
    if(0x2000 == (cmd&0x2000)){
        data_dump("收到数据",data,len);
        sIndex = master_check_dev_table(msg->comInfo.statusMsg.devTypeS,msg->comInfo.statusMsg.devSnS);
        if(sIndex == 0xFF) return;
        switch(cmd){
        case 0x2002:// 实时状态信息 // 固件信息
            g_runNode.devRunMsg[sIndex].readNum++;
            if(g_runNode.devRunMsg[sIndex].readNum<4) break;
            master_analysis_status_cmd(data,len);
            g_runNode.devRunMsg[sIndex].readNum = 0;
            break;
        case 0x2001:
            s2001Msg = (status0x2001*)msg->comInfo.info;
            //data_dump("aaaaa",msg->comInfo.info,len-12);
            printf("aaaaaaaaaa %08x,%08x\n",g_runNode.devRunMsg[sIndex].devAppVer,s2001Msg->appVer);
            if(g_runNode.devRunMsg[sIndex].devAppVer != s2001Msg->appVer) {// APP版本不一样时，则上报
                timeout_stop(&g_runNode.devRunMsg[sIndex].firmTime);
                master_analysis_status_cmd(data,len);
                timeout_setValue(&g_runNode.devRunMsg[sIndex].firmTime,UP_STATUS_2001);
                timeout_start(&g_runNode.devRunMsg[sIndex].firmTime);
                g_runNode.devRunMsg[sIndex].devAppVer = s2001Msg->appVer;
            }
            else {
                if(timeout_isOut(&g_runNode.devRunMsg[sIndex].firmTime)){
                    master_analysis_status_cmd(data,len);
                    timeout_setValue(&g_runNode.devRunMsg[sIndex].firmTime,UP_STATUS_2001);
                    timeout_start(&g_runNode.devRunMsg[sIndex].firmTime);
                    printf("ccccccccccccccccc\n");
                }
            }
            break;
        }
    }
    else 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) {
////            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;
    case 0x2061:
        //if(g_iDentity == IDENTITY_SLAVE) break; // 从设备退出
        data_dump("收到数据",data,len);
        sIndex = master_check_dev_table(msg->comInfo.da2061.devTypeS,msg->comInfo.da2061.devSnS);
        if(sIndex == 0xFF) return;
        if(msg->comInfo.da2061.bnewflag != 0)
            fifo_write(&g_4Gtxfifo,data,len); // 直接透传
        timeout_stop(&g_uart485.time);
        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 0x2001: // 获取设备版本上行
            fifo_write(&g_4Gtxfifo,data,len); // 直接透传
            break;
        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 0x2062: // 错误数据
        sIndex = master_check_dev_table(msg->comInfo.lg2062.devTypeS,msg->comInfo.lg2062.devSnS);
        if(sIndex == 0xFF) {
            timeout_stop(&g_uart485.time);
            return;
        }
        fifo_write(&g_4Gtxfifo,data,len);// 直接透传
        timeout_stop(&g_uart485.time);
        break;
    case 0x2063: // 信号采样率上传
        // sIndex = master_check_dev_table(msg->comInfo.lg2063.devTypeS,msg->comInfo.lg2063.devSnS);
        // if(sIndex == 0xFF) {
        //     timeout_stop(&g_uart485.time);
        //     return;
        // }
        fifo_write(&g_4Gtxfifo,data,len);// 直接透传
        timeout_stop(&g_uart485.time);
        break;
        break;
    default: break;
    }
}