mini7_V2/DriverInterface/communication.c

#include "onechip_include_header.h"
#include "one_chip_git_inf.h"


char DeviceNum[64] = "mini7 2312230001 v1.1, ";
uint8_t pc_send_wait = 0;     //数据发送等待，0可以立即发送；>0正在发送请等待
uint8_t pc_send_cmd = 0;     //当前发送cmd

static unsigned char seq  =0;


extern uint8_t wifi_tx_buf[WIFI_TX_BUF_SIZE];
extern uint16_t wifi_tx_len;
uint8_t com_tx_buf[WIFI_TX_BUF_SIZE];
unsigned int check_to_pc_busy(void){
    if (sysinf.pc_channel_recv == PC_CONNECT_TYPE_UART) return 1;
    return WIFI_SendIlde();
}

/********************************************************************
 *    uint16_t data_send_to_pc(enum pc_cmd_type cmd, char *data, uint16_t len)
 *
 *描述：发生数据到PC
 *参数：Devicenum 0-发至主机，1发至从机
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
CmdMessage msg;	
int data_send_to_pc(pc_cmd_type cmd, char *data, unsigned short len)
{
    uint16_t check;
    uint16_t sendlen;
    int ret = -1;
    msg.head = 0x55aa;
    msg.seq = CDM_FRAME_TYPE_REQ;
    msg.cmd = cmd;
    msg.tail = 0x5a;
    msg.len = len;
    msg.data = data;
    
	if((len+8) > WIFI_TX_BUF_SIZE){
		 Van_Device_Printf(VAN_LOG_COMM,"send_to_pc :%x  len:%d error ", cmd, len);
		 return  ret;
	}
    if(cmd == PC_CMD_SETIP){
        if(sysinf.pc_channel_recv  == PC_CONNECT_TYPE_UART){
              /*串口不上报 IP配置信息*/
            return  ret;
        }
    }else{
        
        if((sysinf.pc_channel_recv  == PC_CONNECT_TYPE_NULL )&& ((PC_CMD_UPDATETEMP != cmd)&& (PC_CMD_DATASCOPE  != cmd)) ){            
            /*无通信，不上报*/
            return ret;
        }
        if(sysinf.pc_channel_recv  == PC_CONNECT_TYPE_WIFI ){
            if(sysinf.connectTcpFlag == 0){
					    /*网口不上报数据 ,TCP链接未完成*/
							return ret;	
						}

        }
    }
   
    switch(cmd)
    {
        case PC_CMD_QRCODE:
        case PC_CMD_DATA_UPLOAD:
        case PC_CMD_REPORT_RESULT:
			seq++;
			if(0xff == seq){
				seq =1;
			}
            msg.seq = seq;
            break;
        default:    //应答
            break;
    }
	check = checkSum((const unsigned char *)&msg.seq, 4);
	check += checkSum((const unsigned char *)data, len);
	msg.checksum = check & 0xFF;
	msg.tail = (check >> 8);	
	// if(check_to_pc_busy()){		
		
	// }else{
	// 	return ret;
	// }	

    memcpy(&com_tx_buf[0], (uint8_t*)&msg, MSG_CMDFRAME_LEN);
	memcpy(&com_tx_buf[MSG_CMDFRAME_LEN], data, len);
	memcpy(&com_tx_buf[MSG_CMDFRAME_LEN+len],  (uint8_t*)&check, 2);
    sendlen =  MSG_CMDFRAME_LEN+len+2;

	if((sysinf.pc_channel_recv  == PC_CONNECT_TYPE_WIFI || cmd == PC_CMD_SETIP ) && ((PC_CMD_SETWIFI != cmd) && (PC_CMD_UPDATETEMP != cmd) && (PC_CMD_DATASCOPE != cmd)))
	{	
         int result = WIFI_Send_Data(com_tx_buf, sendlen, 1);
         return result < 0 ? result : 0;
	}
	else
	{	
        Van_Debug_UART_Send_DMA((unsigned char *)com_tx_buf, sendlen); //将收到的信息发送出
		memset(com_tx_buf, 0, sizeof(com_tx_buf));
	}
   return 0;
}

int data_send_to_pc_withindex(pc_cmd_type cmd, char *data, unsigned short len, unsigned char index)
{
    uint16_t check;
    if (len > WIFI_TX_BUF_SIZE - 8 || (!data && len)) return -1;
    msg.head = 0x55aa;
    msg.seq = index;
    msg.cmd = cmd;
    msg.tail = 0x5a;
    msg.len = len;
    msg.data = data;


	check = checkSum((const unsigned char *)&msg.seq, 4);
	check += checkSum((const unsigned char *)data, len);
	msg.checksum = check & 0xFF;
	msg.tail = (check >> 8);	

	if((sysinf.pc_channel_recv  == PC_CONNECT_TYPE_WIFI || cmd == PC_CMD_SETIP ) && PC_CMD_SETWIFI != cmd)
	{	
        int result = WIFI_Send_MSG((uint8_t *)&msg, (uint8_t *)data, (uint8_t *)&check, len);
        return result < 0 ? result : 0;
	}
	else
	{	
		memcpy(&com_tx_buf[0], (uint8_t*)&msg, MSG_CMDFRAME_LEN);
		memcpy(&com_tx_buf[MSG_CMDFRAME_LEN], data, len);
		memcpy(&com_tx_buf[MSG_CMDFRAME_LEN+len],  (uint8_t*)&check, 2);
	    uint16_t sendlen = MSG_CMDFRAME_LEN+len+2;
        Van_Debug_UART_Send_DMA((unsigned char *)com_tx_buf, sendlen); //将收到的信息发送出
		memset(com_tx_buf, 0, sizeof(com_tx_buf));

	}
   return 0;
}


void PackDeviceNum(void){		
	int len = 0;
	memset((uint8_t *)&DeviceNum, 0 ,sizeof(DeviceNum));
    uint32_t uid[3];
    uid[0] = HAL_GetUIDw0(); // 读取低32位[reference:16]
    uid[1] = HAL_GetUIDw1(); // 读取中间32位[reference:17]
    uid[2] = HAL_GetUIDw2(); // 读取高32位[reference:18]
#ifdef ONECHIP_MINI_ONE
	my_sprintf(&DeviceNum[len],sizeof(DeviceNum), "Mini7-one,V%d.%d.%d.%d",SOFT_VERSION_1,SOFT_VERSION_2,SOFT_VERSION_3,SOFT_VERSION_4);	
#else 
#ifdef ONECHIP_MINI_PLUS
	my_sprintf(&DeviceNum[len],sizeof(DeviceNum), "Mini7-plus,V%d.%d.%d.%d",SOFT_VERSION_1,SOFT_VERSION_2,SOFT_VERSION_3,SOFT_VERSION_4);	
#else
	my_sprintf(&DeviceNum[len],sizeof(DeviceNum), "Mini7,V%d.%d.%d.%d",SOFT_VERSION_1,SOFT_VERSION_2,SOFT_VERSION_3,SOFT_VERSION_4);		
#endif //ONECHIP_MINI_PLUS
#endif //ONECHIP_MINI_ONE
	strcat(DeviceNum, ",");
	len = strlen(DeviceNum);
	hex_to_ascii((const void *)uid, &DeviceNum[len], 12);	//uid
	strcat(DeviceNum, ",");
	strcat(DeviceNum, (const char *)sysinf.SN);
	strcat(DeviceNum, ",");
#ifdef ONE_CHIP_GIT_SHA
     uint8_t gitinf[10] = {0};
     memcpy(gitinf, ONE_CHIP_GIT_SHA, 9);
	 strcat(DeviceNum, (const char *)gitinf);
#endif  
	Van_Device_Printf(VAN_LOG_INFO,"DeviceNum:%s\n", DeviceNum);
}


/********************************************************************
 *    uint16_t send_Devinf_pc(void)
 *
 *描述：发送设备信息到主机，便于主机下法TCP信息
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
void send_Devinf_pc(void)
{

    uint16_t len = 0;
	len =  strlen(DeviceNum);
	data_send_to_pc(PC_CMD_SETIP,DeviceNum,len);

}

/********************************************************************
 * int handshake_action(unsigned char cmd, unsigned char *parg)
 *
 *描述：握手命令处理
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int handshake_action(unsigned char cmd, unsigned char *parg)
{
    
    sysinf.system_OnlineFlag = true;   
    unsigned int verAddr = FLASH_APP1_ADDR + FLASH_APP_VERSION_OFFSET;  
	PackDeviceNum();
    if(*(uint32_t *)(verAddr) == 0xffffffff){
        /*首次上电，跟新版本号*/        
	    unsigned int len =  strlen(DeviceNum);       
		Flash_WriteBuffer(verAddr, (uint8_t *)DeviceNum, len);
	}
    return 0;
}

void char_replace(unsigned char *str, int size, unsigned char ch, unsigned char replace)
{
    for(int i = 0; i < size; i++)
    {
        if(str[i] == ch)
            str[i] = replace;
    }
}


/********************************************************************
 * int wifi_action(unsigned char cmd, unsigned char *parg)
 *
 *描述：设置wifi命令处理
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int wifi_action(unsigned char cmd, unsigned char *parg)
{
    parg[WIFI_AP_NAME_MAX_LEN+WIFI_AP_PWD_MAX_LEN-1]=0;
    parg[WIFI_AP_NAME_MAX_LEN-1]=0;
    strcpy(sysinf.wifiname, (const char *)parg);
	strcpy(sysinf.password, (const char *)(parg + WIFI_AP_NAME_MAX_LEN));
    // wifi用户名和密码设置
    WIFI_set_ssid();    
	return cfg_save_cfg_param();
}
int setState_action(unsigned char cmd, unsigned char *parg)
{
	unsigned char block = *parg++;
	// unsigned char nextState = *parg;
    // if(SYS_STATE_WORKEND == nextState)
    {
        if(block==0){
                sysinf.psmMaster.state = SW_result_report;
                sysinf.psmMaster.controlword = result_move_card;
        }else{
            /*下发命令，改变从模块状态*/
#ifdef ONECHIP_MINI_ONE
       sysinf.lysis.thermostat_st = THERMOSTAT_END;
        sysinf.lysis.firstin = true;
#endif 
#ifdef ONECHIP_MINI_PLUS
        sysinf.psmSlave.state = SW_result_report;
        sysinf.psmSlave.controlword = result_move_card;
#endif
           
        }
    }
    return 1;
}

int setLog_action(unsigned char cmd, unsigned char *parg)
{
    sysinf.log_level =  *(uint32_t *)(parg+4);
    sysinf.system_debugFlag  = 1;
    sysinf.pc_channel_recv  = PC_CONNECT_TYPE_UART;
    return cfg_save_cfg_param();
}

int setDebug_action(unsigned char cmd, unsigned char *parg)
{
	sysinf.skip_CheckOrRun =  *(uint32_t *)(parg+4);
    sysinf.system_debugFlag  = 1;
    sysinf.pc_channel_recv  = PC_CONNECT_TYPE_UART;
    return 1;
}

/********************************************************************
 * int wifi_action(unsigned char cmd, unsigned char *parg)
 *
 *描述：设置wifi命令处理
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int SN_action(unsigned char cmd, unsigned char *parg)
{
    
	parg[15] = 0;
	strcpy((char *)sysinf.SN, (const char *)parg);	
	PackDeviceNum();
	return cfg_save_cfg_param();
}


/********************************************************************
 * int seq_selftest_action(unsigned char cmd, unsigned char *parg)
 *
 *描述：设备自检处理
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int default_action(unsigned char cmd, unsigned char *parg)
{
    return 1;
}

/********************************************************************
 * int confirm_result_action(unsigned char cmd, unsigned char *parg)
 *
 *描述：设备收到pc的结果响应
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int confirm_result_action(unsigned char cmd, unsigned char *parg)
{
    // if(0 == memcmp(parg,sysinf.psmMaster.card_param_info.pid, 10 )){
    //      sysinf.psmMaster.state  = SW_move_card;
    // }else if (0 == memcmp(parg,sysinf.psmSlave.card_param_info.pid, 10 ))
    // {
    //      sysinf.psmSlave.state  = SW_move_card;
    // }
    return 0;
}


/********************************************************************
 * int default_pc_response(struct CmdMessage *pMsg, unsigned char result)
 *
 *描述：默认回应PC
 *参数：无
 *返回：成功->0 失败->-1
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int default_pc_response(CmdMessage *pMsg, unsigned char result)
{
   	return data_send_to_pc((pc_cmd_type)pMsg->cmd, (char *)&result, 1);
}

/********************************************************************
 * int handshake_response(struct CmdMessage *pMsg, unsigned char result)
 *
 *描述：握手回应
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int handshake_response(CmdMessage *pMsg, unsigned char result)
{
	unsigned short len = 0;
	len = strlen(DeviceNum);
	return data_send_to_pc_withindex((pc_cmd_type)pMsg->cmd, (char*)DeviceNum, len,pMsg->seq);
}

	
int AskState_response(CmdMessage *pMsg, unsigned char result)
{
        stateinfDef st = {0};
        st.amplifState =sysinf.amplifState;
        st.lysisState =sysinf.lysisState;
        st.amplifStateTime = sysinf.amplifStateTime;
        st.lysisStateTime = sysinf.lysisStateTime;
        memcpy(st.SN, &sysinf.SN, 7);

   	data_send_to_pc(PC_CMD_ASKSTATE, (char *)&st, sizeof(stateinfDef));  
    return 0;  
}

int set_response(CmdMessage *pMsg, unsigned char result)
{
//    char wifi_result = 1;
//    data_send_to_pc(PC_CMD_SETWIFI, &wifi_result, 1);
    return 0;
}

int setState_response(CmdMessage *pMsg, unsigned char result)
{
//    char result = 1;
    data_send_to_pc(PC_CMD_SETSTATE, (char *)&result, 1);
    return 0;
}

int swtichWifi_response(CmdMessage *pMsg, unsigned char result)
{
//    char result = 1;
    data_send_to_pc(PC_CMD_SWITCHWIFI, (char *)&result, 1);
    sysinf.pc_channel_recv  = PC_CONNECT_TYPE_NULL;    
    sysinf.system_debugFlag  = 0;
    return 0;
}


int ans_response(CmdMessage *pMsg, unsigned char result)
{	
	/*清空需要上位机应答的消息*/
	switch(pMsg->cmd){
		case PC_CMD_REPORT_REEOR:
			sysinf.updateError = 0;  
			break;
		case PC_CMD_UPDATESTATE:
			sysinf.updateSt = 0;
			break;
		case PC_CMD_QRCODE:
			sysinf.updateQR = false;                
			break;
		case PC_CMD_DATA_UPLOAD:{
			unsigned char *data = (unsigned char *)pMsg->data;			
			unsigned int recdex = 0xfffffff;
//			unsigned char result = *data;
//			unsigned char part = *(data+1);
			if( pMsg->len == 6){
				recdex = *(data+5);
			    recdex = recdex<<8;
				recdex += *(data+4);
			    recdex = recdex<<8;
				recdex += *(data+3);
			    recdex = recdex<<8;
				recdex += *(data+2);
			}else{
				if(seq == pMsg->seq){
					recdex = 0;
				}
			}
			updateData_next(recdex,data);
	    	
		}
			break;	
		case PC_CMD_REPORT_RESULT:{

//			unsigned char result = *data;
//			unsigned char part = *(data+1);	
			clean_reult_next((unsigned char *)pMsg->data);
//			if(result){		
//				/*消息成功，进行跟新*/		
//				clean_reult_next(part);
//			}
		}
			break;		
	}
    return 0;
}

int confirm_qrcode_action(unsigned char cmd, unsigned char *parg)
{
    //先判断主模块，优先给主模块，扫描上报上报也是相同处理    
    svanner_receive_Rec_Start(sysinf.scannerUart);
    if(*parg == 1)
    {
        if((sysinf.psmMaster.state == SW_Scan_Qrcode   ))   //主机空闲，给自己
        {
            sysinf.psmMaster.controlword = Scan_Qrcode_cmd;            
		    Van_Device_Printf(VAN_LOG_INFO,"Master rec start\n\r:");
    	    return 0;
        }else {   
#ifdef ONECHIP_MINI_PLUS         
            if((sysinf.psmSlave.state == SW_Scan_Qrcode )){
                sysinf.psmSlave.controlword = Scan_Qrcode_cmd;                
                Van_Device_Printf(VAN_LOG_INFO,"Slave rec start\n\r:");
                return 0;
            }
#endif
        }
        Van_Device_Printf(VAN_LOG_INFO, "master:%d slave:%d Not in startState\n\r:",sysinf.psmMaster.state,sysinf.psmSlave.state );
        return -1;
    }
	Van_Device_Printf(VAN_LOG_INFO, "rec no macth\n\r:");
    return -1;
}


int confirm_error_action(unsigned char cmd, unsigned char *parg)
{
    return 0;
}


int confirm_data_action(unsigned char cmd, unsigned char *parg)
{
    return 0;
}

/********************************************************************
 * int set_IP_action(uint8_t cmd, uint8_t *parg)
 *
 *描述：设置IP
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int set_IP_action(uint8_t cmd, uint8_t *parg)
{
	if(sysinf.connectTcpFlag == 0){
		/*TCP 链接状态下，不跟新IP地址*/
		memset(sysinf.TCP_IP_Addr,0,sizeof(sysinf.TCP_IP_Addr));
		memset(sysinf.TCP_IP_PORT,0,sizeof(sysinf.TCP_IP_PORT));
		unsigned int data_len = strlen((const char *)parg);
		unsigned int i=0;
		if(parg[i]<'0' || parg[i]>'9'){
			 return 0;
		}
		for(;i<data_len;i++){
			 if(parg[i] != ':'){
				 sysinf.TCP_IP_Addr[i] = parg[i];
			 }else{
				 break;
			 }
		}
		i++;
		unsigned int j =0;
		if(parg[i]<'0' || parg[i]>'9'){
			 return 0;
		}
		for(;i<data_len;i++){
			 if(parg[i] != ':'){
				 sysinf.TCP_IP_PORT[j++] = parg[i];
			 }else{
				 break;
			 }
		}
		if(sysinf.TCP_IP_Addr[0]){		
			sysinf.connectTcpFlag = 1; 
		}
		
		WIFI_set_CloseConnect();
	}


	return 0;

}
int start_update_app_action(uint8_t cmd, uint8_t *parg)
{
	
    iap_load_app(FLASH_BOOTLOAD_ADDR);
	return 0;

}


/********************************************************************
 *    uint16_t send_Devinf_pc(void)
 *
 *描述：发送设备信息到主机，便于主机下法TCP信息
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
void start_update_app_response(CmdMessage *pMsg, uint8_t result)
{

    uint16_t len = 0;
	len =  strlen(DeviceNum);
	data_send_to_pc(PC_CMD_STARTUPDATE,DeviceNum,len);

}
int updateInfo_action(uint8_t cmd, uint8_t *parg)
{
	
	return 1;
}
int updateDate_action(uint8_t cmd, uint8_t *parg)
{
	
	return 1;
}


int updateDate_response(CmdMessage *pMsg, unsigned char result)
{

	unsigned char *data  = (unsigned char *)pMsg->data;
    *(unsigned int *)(data+4) =  *(unsigned int *)data;	
    *(unsigned int *)(data+8) =  result;
	return data_send_to_pc((pc_cmd_type)pMsg->cmd, pMsg->data, 12);
}

int send_temp_parm(uint8_t cmd, uint8_t *parg)
{
#ifdef ONECHIP_MINI_ONE
    sysinf.lysis_idleTemp = *(float *)(parg+4);
    sysinf.lysis_Goal = *(float *)(parg+8);
    sysinf.lysis_HeatTime = *(float *)(parg+12);
    updatParm_lysis();
    cfg_save_cfg_param();
    return 1;
#else
    /* PLUS has no lysis controller; configure heaters with amplifier commands. */
    return 0;
#endif
}
int setTemp_response(CmdMessage *pMsg, uint8_t result)
{
//    char result = 1;
    data_send_to_pc(PC_CMD_SETRUNTEMP, (char *)&result, 1);
    return 0;
}
const struct PCActionPack mPCActionPack[] =
    {
        {
            .cmd = PC_CMD_HANDSHAKE,
            .action = handshake_action,
            .response = handshake_response,
            .datalen = 0,
        },
        {
            .cmd = PC_CMD_SETWIFI,
            .action = wifi_action,
            .response = set_response,
            .datalen = 0xff,
        },
        {
            .cmd = PC_CMD_SETSN,
            .action = SN_action,
            .response = handshake_response,
            .datalen = 7,
        },
        {
            .cmd = PC_CMD_QRCODE,
            .action = confirm_qrcode_action,
            .response = ans_response,
            .datalen = 0xff,
        },
        {
            .cmd = PC_CMD_SNANDCARD,
            .action = confirm_error_action,
            .datalen = 1,
        },
        {
            .cmd = PC_CMD_REPORT_RESULT,
            .action = confirm_result_action,
            .response = ans_response,
            .datalen = 0xff,
        },
        {
            .cmd = PC_CMD_REPORT_REEOR,
            .action = confirm_error_action,
            .response = ans_response,
            .datalen = 0xff,
        },
        {
            .cmd = PC_CMD_DATA_UPLOAD,
            .action = confirm_data_action,
            .response = ans_response,
            .datalen = 0xff,
        },
        {
            .cmd = PC_CMD_SETIP,
            .action = set_IP_action,
            .response = NULL,
            .datalen = 0xff,
        },
        {
            .cmd = PC_CMD_UPDATESTATE,
            .action = confirm_data_action,
            .response = ans_response,
            .datalen = 0xff,
        },
        {
            .cmd = PC_CMD_ASKSTATE,
            .action = confirm_data_action,
            .response = AskState_response,
            .datalen = 0xff,
        },
        {
            .cmd = PC_CMD_SETSTATE,
            .action = setState_action,
            .response = setState_response,
            .datalen = 0xff,
        },
        {
            .cmd = PC_CMD_SWITCHWIFI,
            .action = default_action,
            .response = swtichWifi_response,
            .datalen = 0xff,
        },

        {
            .cmd = PC_CMD_SETRUNTEMP,
            .action = send_temp_parm,
            .response = setTemp_response,
            .datalen = 0xff,
        },

        {
            .cmd = PC_CMD_STARTUPDATE,
            .action = start_update_app_action,
            .response = NULL,
            .datalen = 0xff,
        },

        {
            .cmd = UINON_CMD_SET_DEBUG,
            .action = setDebug_action,
            .response = default_pc_response,
            .datalen = 0xff,
        },
        {
            .cmd = UINON_CMD_SET_LOG,
            .action = setLog_action, 
            .response = default_pc_response,
            .datalen = 0xff,
        },
        

};

void pc_resend_del(uint8_t seq){
	// struct CmdMessage *pMessage = (struct CmdMessage *)wifi_tx_buf;
	// if(pMessage->seq == seq){
	// 	wifi_tx_len = 0;
	// 	memset(wifi_tx_buf, 0, sizeof(wifi_tx_buf));
	// }
}

/********************************************************************
 * void query_pc_cmd(struct CmdMessage *pMsg)
 *
 *描述：处理PC命令
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
void query_pc_cmd(CmdMessage *pMsg)
{
    for (unsigned char i = 0; i < sizeof(mPCActionPack)/sizeof(mPCActionPack[0]); i++)
    {
        if (mPCActionPack[i].cmd == pMsg->cmd && (mPCActionPack[i].datalen == pMsg->len || mPCActionPack[i].datalen == 0xff)) //防止接收到其他设备的数据帧
        {
            // if(pc_send_cmd == mPCActionPack[i].cmd)
            //     pc_send_wait = 0;
            Van_Device_Printf(VAN_LOG_COMM,"\n<-- pc cmd %x %d \n", pMsg->cmd, pMsg->seq);
            if(mPCActionPack[i].cmd != 1)
            {
            	pc_resend_del(pMsg->seq);
            }
			pMsg->data[pMsg->len] = 0;
            unsigned char ret = mPCActionPack[i].action(mPCActionPack[i].cmd, (unsigned char *)pMsg->data);
            if (mPCActionPack[i].response)
            {
                mPCActionPack[i].response(pMsg, ret);
            }
			
            break;
        }
    }
}







/********************************************************************
 * int handshake_action(uint8_t cmd, uint8_t *parg)
 *
 *描述：握手命令处理
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int con_heat_action(uint8_t cmd, uint8_t *parg )
{
//    CmdMessage *pMsg = (CmdMessageDef *)parg;
    CmdMessage *pMsg = (CmdMessage *)parg;;
    // miniConfigPram *pram = (miniConfigPram *)pMsg->data;
    uint8_t * pdata = (uint8_t *)pMsg->data;
    switch(pMsg->cmd){
        case UINON_CMD_MOTORMOVE:{	
            
			sysinf.timeinner =  *(float *)(pMsg->data+4) * 100;
			sysinf.swingspeed =  *(float *)(pMsg->data+8);
			sysinf.swingtime =  *(float *)(pMsg->data+12) * 100;
			// sysinf.swingtimeRight =  *(float *)(pMsg->data+16) * 100;
			// sysinf.swingtimePause =  *(float *)(pMsg->data+20) * 100;	
			if((1 == *(int *)(pMsg->data+pMsg->len - 4))){
				cfg_save_cfg_param();	
				Motor_Init();
			}else{				
				Motor_mix(sysinf.timeinner,sysinf.swingspeed,sysinf.swingtime,0,0);
			}		
		    data_send_to_pc((pc_cmd_type)pMsg->cmd, pMsg->data,  pMsg->len);
        }break;			
        case UINON_CMD_MOTORTRETURN:{		
            Motor_reset();
            data_send_to_pc( (pc_cmd_type)pMsg->cmd, pMsg->data,	pMsg->len);
        }break;				
        case UINON_CMD_MOTORGETPRAM:{  
            char data[24];            
            *(float *)(data+0) = 0;
			*(float *)(data+4) = sysinf.timeinner/100;
			*(float *)(data+8) = sysinf.swingspeed;
			*(float *)(data+12) = sysinf.swingtime /100;		
            pMsg->data = data;
            pMsg->len = sizeof(data);
            data_send_to_pc( (pc_cmd_type)pMsg->cmd, pMsg->data,	pMsg->len);
        }break;				
        case UINON_CMD_THEROM_GET:{		
            char data[40];
#ifdef ONECHIP_MINI_ONE
            *(float *)(data+0) = 0;
            *(float *)(data+4) = sysinf.lysis_offset;	
            *(float *)(data+8) = sysinf.lysis_overHeat;	
            *(float *)(data+12) = sysinf.lysis_overHeatTime;	
            *(float *)(data+16) = sysinf.lysis_Kp;	
            *(float *)(data+20) = sysinf.lysis_Ki;	
            *(float *)(data+24) = sysinf.lysis_Kd;		
            *(float *)(data+28) = sysinf.lysis.setgaol;
            *(float *)(data+32) = sysinf.lysis.idletemp;	
            *(float *)(data+36) = sysinf.lysis.worktime/10;	
#endif  
            pMsg->data = data;
            pMsg->len = sizeof(data);
            data_send_to_pc( (pc_cmd_type)pMsg->cmd, pMsg->data,	pMsg->len);
        }break;			
        case UINON_CMD_THEROM_OFFSET:{		

#ifdef ONECHIP_MINI_ONE		
            sysinf.lysis_Kp  = *(float *)(pdata+4);
            sysinf.lysis_Ki = *(float *)(pdata+8);
            sysinf.lysis_Kd     = *(float *)(pdata+12);
            sysinf.lysis_overHeat  = *(float *)(pdata+16);
            sysinf.lysis_overHeatTime = *(float *)(pdata+20);
            sysinf.lysis_offset  = *(float *)(pdata+24);
            updatParm_lysis();
            cfg_save_cfg_param();
#endif  						
            data_send_to_pc((pc_cmd_type)pMsg->cmd, pMsg->data,	pMsg->len);
        }break;		
        case UINON_CMD_AMPLIF_GET:{		
            char data[44];	
			unsigned int ch = 	*(int *)(pdata);
            if(ch==0){               
                *(float *)(data+0) = 0;
                *(float *)(data+4) = sysinf.amplif_Kp;	
                *(float *)(data+8) = sysinf.amplif_Ki;	
                *(float *)(data+12) = sysinf.amplif_Kd;	
                *(float *)(data+16) = sysinf.PreHeatTime;	
                *(float *)(data+20) = sysinf.holdTemp;	
                *(float *)(data+24) = sysinf.readyTemp;		
                *(float *)(data+28) = sysinf.PresetTempVal;	
                *(float *)(data+32) = sysinf.PresetTempTime;	
                *(float *)(data+36) = sysinf.adJTarget;	
                *(float *)(data+40) = sysinf.SetTempVal; 
            }else{    
#ifdef ONECHIP_MINI_PLUS      
                if(ch==1){          
                    *(float *)(data+0) = 1;
                    *(float *)(data+4) = sysinf.amplif_Kp_Slave;	
                    *(float *)(data+8) = sysinf.amplif_Ki_Slave;	
                    *(float *)(data+12) = sysinf.amplif_Kd_Slave;	
                    *(float *)(data+16) = sysinf.PreHeatTime_Slave;	
                    *(float *)(data+20) = sysinf.holdTemp_Slave;	
                    *(float *)(data+24) = sysinf.readyTemp_Slave;		
                    *(float *)(data+28) = sysinf.PresetTempVal_Slave;	
                    *(float *)(data+32) = sysinf.PresetTempTime_Slave;	
                    *(float *)(data+36) = sysinf.adJTarget_Slave;	
                    *(float *)(data+40) = sysinf.SetTempVal_Slave;                     
                }     
#endif
            }	
            pMsg->data = data;
            pMsg->len = sizeof(data);
            data_send_to_pc( (pc_cmd_type)pMsg->cmd, pMsg->data,	pMsg->len);
        }break;			
        case UINON_CMD_AMPLIF_SET:{		
			unsigned int ch = 	*(int *)(pdata);
            if(ch==0){                
                sysinf.amplif_Kp  = *(float *)(pdata+4);
                sysinf.amplif_Ki = *(float *)(pdata+8);
                sysinf.amplif_Kd     = *(float *)(pdata+12);
                sysinf.PreHeatTime  = *(float *)(pdata+16);
                sysinf.holdTemp = *(float *)(pdata+20);
                sysinf.readyTemp  = *(float *)(pdata+24);
                sysinf.PresetTempVal  = *(float *)(pdata+28);
                sysinf.PresetTempTime  = *(float *)(pdata+32);
                sysinf.adJTarget  = *(float *)(pdata+36);
                sysinf.SetTempVal  = *(float *)(pdata+40);   
                updatParm_heater_master();
            }else{    
#ifdef ONECHIP_MINI_PLUS      
                if(ch==1){
                    sysinf.amplif_Kp_Slave  = *(float *)(pdata+4);
                    sysinf.amplif_Ki_Slave = *(float *)(pdata+8);
                    sysinf.amplif_Kd_Slave     = *(float *)(pdata+12);
                    sysinf.PreHeatTime_Slave  = *(float *)(pdata+16);
                    sysinf.holdTemp_Slave = *(float *)(pdata+20);
                    sysinf.readyTemp_Slave  = *(float *)(pdata+24);
                    sysinf.PresetTempVal_Slave  = *(float *)(pdata+28);
                    sysinf.PresetTempTime_Slave  = *(float *)(pdata+32);
                    sysinf.adJTarget_Slave  = *(float *)(pdata+36);
                    sysinf.SetTempVal_Slave  = *(float *)(pdata+40); 
                    updatParm_Slave_master();
                } 
#endif
            }					
            data_send_to_pc((pc_cmd_type)pMsg->cmd, pMsg->data,	pMsg->len);
            cfg_save_cfg_param();
        }break;
        case UINON_CMD_THEROM_GOAL:{	
#ifdef ONECHIP_MINI_ONE   				
            float goal =  *(float *)(pMsg->data+4) ; 
            set_lysis(goal);
#endif
            data_send_to_pc((pc_cmd_type)pMsg->cmd, pMsg->data,	pMsg->len);
        }break;
        // case UINON_CMD_THEROM_CHECK:{
        //         pMsg->data[0] =Therm_Check();
        //     data_send_to_pc((pc_cmd_type)pMsg->cmd, pMsg->data,  pMsg->len);
        // }break;
    }
    return 0;
}
const struct PCActionPack mUnionActionPack[] =
    {   {
            .cmd = UINON_CMD_MOTORMOVE,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_MOTORTRETURN,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_MOTORGETPRAM,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_TEMP_ADJ,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_TEMP_PID,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_TEMP_ADJ_GET,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_TEMP_PID_GET,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_TEMP_START,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_TEMP_STOP,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_THEROM_GOAL,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_THEROM_OFFSET,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_THEROM_GET,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_AMPLIF_SET,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_AMPLIF_GET,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_THEROM_PID,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_THEROM_OVERHEAT,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_THEROM_OVERCOOL,
            .action = con_heat_action,
        },
        {
            .cmd = UINON_CMD_TEMP_DEBUG,
            .response = handshake_response,
        },

};






void deal_mUnion_cmd(CmdMessage *pMsg)
{
	for (uint8_t i = 0; i < sizeof(mUnionActionPack)/sizeof(mUnionActionPack[0]); i++)
	{
		if (mUnionActionPack[i].cmd == pMsg->cmd ) 
		{			
            
            Van_Device_Printf(VAN_LOG_COMM,"\n<-- pc cmd %x %d \n", pMsg->cmd, pMsg->seq);
			uint8_t ret = mUnionActionPack[i].action( pMsg->cmd,(uint8_t *)pMsg);
			if (mUnionActionPack[i].response)
			{
				mUnionActionPack[i].response(pMsg, ret);
			}
			break;
		}
	}
}


void update_work(void) {
    float temp, pwm;
    unsigned int st;
    if (sysinf.log_level & VAN_LOG_TEMP) {
        char data[28] = {0};
        get_master_st(&temp, &st, &pwm);
        *(unsigned int *)(data+0) = st;
        *(float *)(data+4) = temp;
        *(float *)(data+8) = pwm;
#ifdef ONECHIP_MINI_ONE
        get_lysis_st(&temp, &st, &pwm);
#else
        get_slave_st(&temp, &st, &pwm);
#endif
        *(unsigned int *)(data+12) = st;
        *(float *)(data+16) = temp;
        *(float *)(data+20) = pwm;
        *(float *)(data+24) = sysinf.cabinTem;
        data_send_to_pc(PC_CMD_UPDATETEMP, data, sizeof(data));
    }
}