mini7_V2/DriverInterface/ESP32_WROOM_32D.c

#include "ESP32_WROOM_32D.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
extern int Flag3S;


#define g_uMsgCmdFrameLen (6)
extern uint8_t Devicenum;
extern uint8_t g_wifi_rx_buf[WIFI_RX_BUF_SIZE];
extern uint32_t g_wifi_rx_last;
extern uint32_t g_wifi_rx_head;
extern uint32_t g_wifi_rx_last_tick;   /* 最近一次收到ESP数据的时间戳(10ms单位) */
uint8_t wifi_tx_buf[WIFI_TX_BUF_SIZE];
uint16_t wifi_tx_len;

static int wifi_state = 0;  //WiFi模块当前状态
static int wifi_ack_delay = 0;  //WiFi应答等待
static int wifi_set_ssid = 0;  //WiFi应答SSID设置

uint32_t unlink_time = 0;
extern uint32_t pc_link_timeout;

char TCP_IP_PORT[8]  = {"8001"};
char MAC_ADDR[20]  = {0};
uint32_t broadDevFlag = 0;
extern uint8_t pc_channel_recv;
static int resendtime = 0;

uint16_t WriteComm2(char *data, uint16_t len)
{
    //return UART_Write(UART2, data, len);
    HAL_UART_Transmit((UART_HandleTypeDef *)sysinf.ESPUart,(const uint8_t *)data, len,1000);
	// HAL_UART_Transmit_DMA((UART_HandleTypeDef *)sysinf.ESPUart,(const uint8_t *)data, len);
	return 0;
}


/*WIFI单次发送指令*/
void ESP32_Send_AT_Cmd(char *cmd,uint32_t time)
{
    char buff[128] = {0};

    strcpy(buff, cmd);
    strcat(buff, "\r\n");

    Van_Device_Printf(VAN_LOG_WIFI,"\nW--> %s", buff); 

  	WriteComm2(buff, strlen(buff));

    wifi_ack_delay = time;
}
void ESP32_AT(void)
{
    ESP32_Send_AT_Cmd("AT",5000);
}
/*恢复出厂设置*/
void ESP32_AT_Restore(void)
{
	ESP32_Send_AT_Cmd("AT+RESTORE",500);
}
/*复位*/
void ESP32_AT_RST(void)
{
    ESP32_Send_AT_Cmd("AT+RST",8000);
}
/*上电自动连接AP*/
void ESP32_AT_AUTOCONN(void)
{
    ESP32_Send_AT_Cmd("AT+CWAUTOCONN=0",5000);
}

/*WIFI AP/STA/AP+STA模式选择*/
void ESP32_Net_Mode_Choose(ENUM_Net_ModeTypeDef enumMode)
{
    switch ( enumMode )
    {
        case STA:
            ESP32_Send_AT_Cmd ( "AT+CWMODE=1", 5000 );
				break;
        case AP:
            ESP32_Send_AT_Cmd ( "AT+CWMODE=2",  5000 );
				break;
        case STA_AP:
            ESP32_Send_AT_Cmd ( "AT+CWMODE=3",  5000 );
				break;
        default:
        break;
    }
}
/*WIFI加入AP*/
void ESP32_JoinAP( char * pSSID, char * pPassWord, char * pMacAddr)
{
    char cCmd [128];
    my_sprintf ( cCmd, sizeof(cCmd), "AT+CWJAP=\"%s\",\"%s\",\"%s\"", pSSID, pPassWord,pMacAddr);
    ESP32_Send_AT_Cmd( cCmd,5000 );
}

/*WIFI建立AP*/
void ESP32_SetupAP( char * pSSID, char * pPassWord)
{
    char cCmd [40];
    my_sprintf ( cCmd,sizeof(cCmd),  "AT+CWSAP=\"%s\",\"%s\"", pSSID, pPassWord );
	ESP32_Send_AT_Cmd( cCmd, 5000 );
}

/*WIFI查询IP*/
void ESP32_GetIp(void)
{
	ESP32_Send_AT_Cmd( "AT+CIPSTA?", 5000 );
}

/*WIFI禁止自动连接*/
void ESP32_DisAutoLink(void)
{
	ESP32_Send_AT_Cmd( "AT+CWAUTOCONN=0", 5000 );
}

void ESP32_CWLAP(char * pSSID)
{
    char cCmd [80];
    my_sprintf ( cCmd, sizeof(cCmd), "AT+CWLAP=\"%s\"", pSSID);
		ESP32_Send_AT_Cmd( cCmd, 5000 );
}



/*WIFI关闭回显*/
void ESP32_EchoOff(void)
{
	ESP32_Send_AT_Cmd( "ATE0", 5000 );
}
/*WIFI初始化*/
void ESP32_Init(void)
{
	ESP32_Send_AT_Cmd( "+++", 5000 );
}

/*WIFI 单/多连接*/
void ESP32_Enable_MultipleId (uint8_t enumEnUnvarnishTx )
{
    char cCmd [20];
    my_sprintf ( cCmd, sizeof(cCmd), "AT+CIPMUX=%d", ( enumEnUnvarnishTx ? 1 : 0 ) );
    ESP32_Send_AT_Cmd ( cCmd, 5000 );

}
/*WIFI AP作为服务端开启或关闭,1---开启服务：0---关闭服务*/
void ESP32_AP_Server (uint8_t open)
{
   char cCmd [40];
   my_sprintf ( cCmd,sizeof(cCmd), "AT+CIPSERVER=%d", open);
   ESP32_Send_AT_Cmd( cCmd,  5000 );
}
/*WIFI STA选择TCP或UDP协议*/
void ESP32_Link_Server(ENUM_NetPro_TypeDef enumE, char * ip, char * ComNum, ENUM_ID_NO_TypeDef id)
{
    char cStr [100] = { 0 }, cCmd [60];
    switch (  enumE )
    {
        case enumTCP:
          my_sprintf ( cStr, sizeof(cCmd), "\"%s\",\"%s\",%s,6", "TCP", ip, ComNum );
          break;
        case enumUDP:
          my_sprintf ( cStr,sizeof(cCmd),  "\"%s\",\"%s\",%s,9090,0", "UDP", ip, ComNum );
          break;
        default:
          break;
    }
    if ( id < 5 )
        my_sprintf ( cCmd,sizeof(cCmd),  "AT+CIPSTART=%d,%s", id, cStr);
    else
        my_sprintf ( cCmd, sizeof(cCmd), "AT+CIPSTART=%s", cStr );
    ESP32_Send_AT_Cmd ( cCmd,5000 );
}

/*WIFI透传*/
void ESP32_UnvarnishSend ( void )
{
    ESP32_Send_AT_Cmd( "AT+CIPMODE=1",  5000 );//设置透传模式
}
/*WIFI停止TCP*/
void ESP32_STOPTCP ( ENUM_ID_NO_TypeDef id )
{
  char cCmd [60];
  my_sprintf ( cCmd,sizeof(cCmd), "AT+CIPCLOSE=%d", id);
  ESP32_Send_AT_Cmd ( cCmd,  20000 );
}

/*退出透传*/
void ESP32_ExitUnvarnishSend( void )
{
    ESP32_Send_AT_Cmd("+++", 5000);
}

///*设置默认波特率为460800*/
//void ESP32_SET_BUAR(void)
//{
//	ESP32_Send_AT_Cmd("AT+UART_DEF=460800,8,1,0,0","OK",NULL,500);
//}


/********************************************************************
 * int WIFI_Send_Data(uint8_t *data, uint8_t len, uint8_t flag)
 *
 *描述：通过WIFI发送数据，异步
 *参数：data:数据
 *参数：len:数据长度
 *参数：flag:1：立即发送，0：暂存
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
int WIFI_Send_Data(uint8_t *data, uint16_t len, uint8_t flag)
{
    char cStr [40] = {0};

    if (wifi_state < WIFI_TRANS)
        return -1;

    if(wifi_ack_delay > 0)
        return -2;

    if(wifi_tx_len)
        return -3;

	if(len > WIFI_TX_BUF_SIZE){
		 Van_Device_Printf(VAN_LOG_WIFI,"WIFI_Send len:%d error ", len);
		return -1;
	}
    memcpy(&wifi_tx_buf[wifi_tx_len], data, len);
    wifi_tx_len += len;
    
    if(flag)
    {
        wifi_ack_delay = 3000;
        my_sprintf ( cStr, sizeof(cStr),"AT+CIPSEND=0,%d", wifi_tx_len );
        ESP32_Send_AT_Cmd ( cStr,  3000 );
        return wifi_tx_len;
    }

    return 0;
}

int WIFI_Send_MSG(uint8_t*msgHead,uint8_t *data, uint8_t * crc, uint16_t len)
{
    char cStr [40] = {0};

    if (wifi_state != WIFI_TRANS)
        return -1;

    if(wifi_ack_delay > 0)
        return -2;

    if(wifi_tx_len > 0)
        return -3;

    memcpy(&wifi_tx_buf[0], msgHead, g_uMsgCmdFrameLen);
    memcpy(&wifi_tx_buf[g_uMsgCmdFrameLen], data, len);
    memcpy(&wifi_tx_buf[g_uMsgCmdFrameLen+len], crc, 2);
    wifi_tx_len = g_uMsgCmdFrameLen+len+2;
    wifi_ack_delay = 3000;
    my_sprintf ( cStr, sizeof(cStr),"AT+CIPSEND=0,%d", wifi_tx_len );
    ESP32_Send_AT_Cmd ( cStr,  3000 );
    return wifi_tx_len;
}

int WIFI_SendIlde(void){

    if(wifi_tx_len == 0)
		return 0;

    if (wifi_state < WIFI_TRANS)
        return 0;

    if(wifi_ack_delay > 0)
        return 0;
	
    return 1;

}

int WIFI_ReSend(void)
{

    char cStr [40] = {0};
    if(wifi_tx_len == 0)
		return 0;

    if (wifi_state < WIFI_TRANS)
        return -1;

    if(wifi_ack_delay > 0)
        return -2;
	
    wifi_ack_delay = 3000;
    my_sprintf ( cStr, sizeof(cStr),"AT+CIPSEND=0,%d", wifi_tx_len );
    ESP32_Send_AT_Cmd ( cStr,  3000 );
	
    return 0;
}


//wifi修改SSID
void WIFI_set_ssid(void)
{
    wifi_ack_delay = 0;
    wifi_state = WIFI_POWEROFF;
    wifi_set_ssid = 1;

    if(wifi_tx_len > 0)
    {
        WriteComm2((char *)wifi_tx_buf, wifi_tx_len);
        wifi_tx_len = 0;
    }        
}


//wifi修改SSID
void WIFI_set_CloseConnect(void)
{
 
	wifi_state = WIFI_CLOSE;  
}

// //在内存中查找字符串
// char* find_str(void *src, int size, char *str)
// {
// 	char *p = (char*)src;
// 	int len = strlen((const char *)str);

// 	if(len < 1)
// 		return p;

// 	for(int i = 0; i < size; i++)
// 	{
// 		if(p[i] == *str)
// 		{
// 			if( 0 == memcmp(&p[i], str, len))
// 			{
// 				return &p[i];
// 			}
// 		}
// 	}

// 	return NULL;
// }



//在内存中查找字符串
char* find_str_loop(void *src, int size, uint32_t *start, uint32_t end, char *str) {
    if (src == NULL || start == NULL || str == NULL || size <= 0)
        return NULL;

    unsigned char *buf = (unsigned char*)src;
    int head = *start;
    int len = strlen(str);

    // 空串直接返回当前位置（不移动头指针）
    if (len == 0) {
        return (char*)(buf + head);
    }

    // 计算有效数据长度
    int valid_len;
    if (end >= head)
        valid_len = end - head;
    else
        valid_len = (size - head) + end;

    // 若有效数据长度小于目标串长度，不可能匹配
    if (valid_len < len)
        return NULL;

    // 从 head 开始遍历所有可能的起始位置（不包括 end）
    int pos = head;
    while (pos != end) {
        // 检查从 pos 开始的 len 个字节是否与 str 匹配
        int i;
        for (i = 0; i < len; i++) {
            int idx = (pos + i) % size;
            if (buf[idx] != (unsigned char)str[i])
                break;
        }
        if (i == len) {  // 完全匹配
            // 更新头指针为匹配串之后的位置
            *start = (pos + len) % size;
            return (char*)(buf + pos);
        }
        // 移动到下一个起始位置
        pos = (pos + 1) % size;
        // 如果移动后到达 end，提前终止（有效数据遍历完毕）
        // 但 while 条件会处理，可省略
    }

    // 未找到
    return NULL;
}

/********************************************************************
 *                         WIFI_recv_deal()
 *
 *描述：接收帧解析
 *参数：无
 *返回：无
 *其他：无
 *--------------------------------------------------------------------
 *记录：
 ********************************************************************/
void WIFI_recv_deal(void)
{
    char *p;
    int data_len = g_wifi_rx_last>g_wifi_rx_head?(g_wifi_rx_last-g_wifi_rx_head):(WIFI_RX_BUF_SIZE+g_wifi_rx_last-g_wifi_rx_head);
    // int udp_data_len = 0;
    char* data = (char*)g_wifi_rx_buf;
    if((data_len < 5)&&(wifi_state != WIFI_TRANS))
        return;

    //判断是否接收完成
    if(wifi_state > WIFI_LISTEN)
    {
        if(data[g_wifi_rx_last-1] != '\n' && data[g_wifi_rx_last-2] != '\n')
        {
            return;
        }
    }

    switch (wifi_state)
    {
	//指令模式
    case WIFI_POWEROFF:
    case WIFI_ERROR:
        if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last,"ready") ||
            NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last,"boot"))
		{
			wifi_state = WIFI_POWERON;
            wifi_ack_delay = 0;
			memset(wifi_tx_buf,0,sizeof(wifi_tx_buf));
			wifi_tx_len = 0;
            //  wifi_receive_clear();
		} 
        break;
    case WIFI_POWERON:
    case WIFI_INIT:
    case WIFI_STATION:
    case WIFI_DISAUTO:
    case WIFI_LINK_AP:
    case WIFI_GET_IP:
    case WIFI_SETMUX:
    case WIFI_LISTEN:		
        if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "OK\r\n"))
		{
    	    Van_Device_Printf(VAN_LOG_WIFI,"\nW<-- %s", data);
            wifi_ack_delay = 0;	
			if(WIFI_LISTEN == wifi_state){
				/*上电需要广播地址*/			
				broadDevFlag = 1;
				sysinf.s10_flag = 1;	                
                resendtime = 0;
                memset(wifi_tx_buf, 0, sizeof(wifi_tx_buf));
                wifi_tx_len = 0;
				// if(sysinf.connectTcpFlag == 1){
				// 	if(wifi_tx_len){
				// 		char cStr [40] = {0};
				//         my_sprintf ( cStr,sizeof(cStr), "AT+CIPSEND=0,%d", wifi_tx_len );
				//         ESP32_Send_AT_Cmd ( cStr,  3000 );
				// 	}
				// 	// sysinf.pc_link_timeout = 0;	
                //     // sysinf.pc_channel_recv  = PC_CONNECT_TYPE_WIFI; 
				// }	
                // wifi_receive_clear();
			}
			wifi_state++;
			resendtime = 0;            
            HAL_Delay(1000);			
            // 	
		}
        break;
    case WIFI_CWLAP:{
        char* strStart = find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last,sysinf.wifiname);
        uint32_t apHeader = g_wifi_rx_head;
        if(NULL != strStart)
		{
            if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "OK\r\n")){   
                /*循环始终需要OK,找到OK后，恢复APhead位置，重新搜寻mac*/    
                g_wifi_rx_head =  apHeader;       
                Van_Device_Printf(VAN_LOG_WIFI,"\nW<-- %s", data);
                wifi_ack_delay = 0;		
                strStart+=strlen(sysinf.wifiname);
                strStart =find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last,",\""); 
                unsigned int startPos = ((unsigned int)strStart-(unsigned int)g_wifi_rx_buf + 2)%WIFI_RX_BUF_SIZE;/*跳过,\*/
                for(unsigned i=0;i<17;i++){
                    MAC_ADDR[i] = g_wifi_rx_buf[(i+startPos)%WIFI_RX_BUF_SIZE]; 
                }
                MAC_ADDR[18] = 0;
                wifi_state++; 
            }
				
            //  wifi_receive_clear();		
		}
    }        
        break;
    //数据模式
    case WIFI_TRANS:
        //收到AT+CIPSEND回应，可发送数据  
        if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "CLOSED"))			
		{      
    		Van_Device_Printf(VAN_LOG_WIFI,"\nW<-- %d %s", data_len,data);
 		    wifi_state = WIFI_LISTEN;
             wifi_ack_delay = 0;//从发送写指令，到此才算发送完成            
 			broadDevFlag = 0;
		}
		else if	((NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "ERROR"))||
			(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last,"SEND FAIL")))
		{    
			if(resendtime < MAX_RESEND_TIME){				
				char cStr [40] = {0};
				my_sprintf ( cStr,sizeof(cStr), "AT+CIPSEND=0,%d", wifi_tx_len );
				ESP32_Send_AT_Cmd ( cStr,  3000 );
				resendtime ++;
			}else{
				wifi_state = WIFI_POWEROFF;
				wifi_ack_delay = 0;
			}
			//  wifi_receive_clear();
		} else if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "SEND OK"))
		{
        	//收到AT+CIPSEND回应，可发送数据
		    Van_Device_Printf(VAN_LOG_WIFI,"\n--> SEND OK", wifi_tx_len); 
            wifi_ack_delay = 0;//从发送写指令，到此才算发送完成
			resendtime = 0;
			memset(wifi_tx_buf, 0, sizeof(wifi_tx_buf));
            wifi_tx_len = 0;
            //  wifi_receive_clear();
		}
		 else if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "OK\r\n"))
		{
             wifi_receive_clear();
		    Van_Device_Printf(VAN_LOG_WIFI,"\n--> OK W %d", wifi_tx_len); 
			WriteComm2((char *)wifi_tx_buf, wifi_tx_len+1);
            wifi_ack_delay = 3000;
		}
		//  else if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, ">"))
		// {
        //      wifi_receive_clear();
		//     Van_Device_Printf(VAN_LOG_WIFI,"\n--> > W %d", wifi_tx_len); 
		// 	WriteComm2((char *)wifi_tx_buf, wifi_tx_len+1);
        //     wifi_ack_delay = 3000;
		// }

		if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "DISCONNECT"))
		{
		    Van_Device_Printf(VAN_LOG_WIFI,"\nW--> %s", data); 
			wifi_state = WIFI_POWEROFF;
            wifi_ack_delay = 0;
		}
        
        //收到PC数据
        p = find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "+IPD,0,");
        if(NULL != p)
		{
            int iProcLen = DecodeNew(&uart0_massage,uart0_data,g_wifi_rx_buf, &g_wifi_rx_head,g_wifi_rx_last,WIFI_RX_BUF_SIZE);
            if (iProcLen > 0)   {                        
                sysinf.pc_channel_recv  = PC_CONNECT_TYPE_WIFI; 
                sysinf.pc_link_timeout = 0;
				uart0_massage.data = (char *)uart0_data;    
                query_pc_cmd(&uart0_massage);
                wifi_receive_clear();
            }    
            //  wifi_receive_clear();
 //           set_pc_chanel_recv(1);
 //   	    b2b_recv_data(p, udp_data_len);
		}

        break;    
    case WIFI_CLOSE:{
        if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "CLOSED\r\n"))
		{
			wifi_state = WIFI_LISTEN;
            wifi_ack_delay = 0;	
		}		
	}
        break;
    default:
        break;
    }
    if(WIFI_TRANS != wifi_state){
        wifi_receive_clear();
    }
	
}


void WIFI_send_deal(void)
{
    static uint8_t try_count = 0;
    static uint8_t try_con = 0;
    static uint32_t wifi_start_delay = 0;
    
    static uint8_t res_count = 0;
    uint8_t wifi_result = 0;

    //启动超时
    if(wifi_state < WIFI_LISTEN && wifi_start_delay++ > 120*10)
    {
        wifi_start_delay = 0;
        wifi_state = WIFI_POWEROFF;
        wifi_ack_delay = 0;
    }

    //等待模块应答
    if(wifi_ack_delay > 0)
    {
        wifi_ack_delay -= 100;
        return;
    }
	if(resendtime >= MAX_RESEND_TIME){
        wifi_state = WIFI_POWEROFF;		
	}
	if((WIFI_TRANS != wifi_state )|| ((WIFI_TRANS == wifi_state)&& wifi_tx_len )){
		resendtime++;
	}
    switch (wifi_state)
    {
    case WIFI_POWEROFF:
    case WIFI_ERROR:
        ESP32_AT_RST();
        wifi_start_delay = 0;
		resendtime = 0;
        try_count = 0;
		if(sysinf.connectTcpFlag){
			/*持续5次均不能链接到tcp，状态回退，重启链接udp*/
			res_count++;
			if(res_count > 5){
				sysinf.connectTcpFlag = 0;
			}
		}
        break;
    case WIFI_POWERON:
        ESP32_AT();
        break;
    case WIFI_INIT:
        ESP32_EchoOff();
        break;
    case WIFI_STATION:
        ESP32_Net_Mode_Choose(STA);
        break;
    case WIFI_DISAUTO:
        ESP32_DisAutoLink();
        try_count = 0;
		resendtime = 0;
        break;
    case WIFI_CWLAP:
        ESP32_CWLAP(sysinf.wifiname);
        try_count++;
		if(try_count == MAX_RESEND_TIME)
        {
            wifi_state = WIFI_POWEROFF;
            if(wifi_set_ssid == 1)
            {
                wifi_set_ssid = 0;
           		wifi_result = 0xff;
               data_send_to_pc(PC_CMD_SETWIFI,  (char *)&wifi_result, 1);
            }
            Van_Device_Printf(VAN_LOG_ERROR, "no wifi AP:%s\n\r",sysinf.wifiname);
        }
        try_con = 0;
		resendtime = 0;
        break;
    case WIFI_LINK_AP:
        ESP32_JoinAP(sysinf.wifiname, sysinf.password,MAC_ADDR);
        try_con++ ;
		if(try_con == MAX_RESEND_TIME)
        {
            wifi_state = WIFI_POWEROFF;
            if(wifi_set_ssid == 1)
            {
                wifi_set_ssid = 0;
           		wifi_result = 0xfe;
               data_send_to_pc(PC_CMD_SETWIFI, (char *)&wifi_result, 1);
            }
            Van_Device_Printf(VAN_LOG_ERROR, "can't jonn AP:%s %s\n\r",sysinf.wifiname,sysinf.password);
        }
        break;
    case WIFI_GET_IP:
        ESP32_GetIp();
        if(wifi_set_ssid == 1)
        {
            wifi_set_ssid = 0;
            wifi_result = 1;
           data_send_to_pc(PC_CMD_SETWIFI,  (char *)&wifi_result, 1);
        }
        break;
    case WIFI_SETMUX:
        ESP32_Enable_MultipleId(1);
        break;
    case WIFI_LISTEN:
		if(sysinf.connectTcpFlag){
			if(resendtime < MAX_RESEND_TIME)
	        { 	
	        	ESP32_Link_Server(enumTCP,sysinf.TCP_IP_Addr, sysinf.TCP_IP_PORT, Multiple_ID_0);
			}else{			
				/*多次TCP未链接，链接UDP*/
//            	connectTcpFlag = 0;
//				resendtime = 0;
				memset(wifi_tx_buf, 0, sizeof(wifi_tx_buf));
	            wifi_tx_len = 0;
			}        	
		}else{
			if(resendtime < MAX_RESEND_TIME)
	        { 	
	        	ESP32_Link_Server(enumUDP,User_ESP32_UDPServer_IP, User_ESP32_UDPServer_PORT, Multiple_ID_0);
			}
		}
        break;
    case WIFI_TRANS:
			if(resendtime < MAX_RESEND_TIME)
	        { 	
	        if(wifi_tx_len){
					char cStr [40] = {0};                    
                    Van_Device_Printf(VAN_LOG_WIFI,"\nbuflen:%d %d %s",g_wifi_rx_head,g_wifi_rx_last, g_wifi_rx_buf);  
					my_sprintf ( cStr,sizeof(cStr),"AT+CIPSEND=0,%d", wifi_tx_len );
					ESP32_Send_AT_Cmd ( cStr,  3000 );
				}			
			}
			if(sysinf.connectTcpFlag){
				/*tcp链接上，复位计数清零*/
				res_count = 0;
			}
        break;
    case WIFI_CLOSE:
        ESP32_STOPTCP(Single_ID_0);
        break;
    
    default:
        wifi_state = WIFI_ERROR;
        break;
    }

}

/* ========================================================================
 * 热点配网(SoftAP WiFi配网)状态机
 *  触发 : 按键长按30s -> WIFI_provision_request() (usr_motor.c)
 *  流程 : 复位ESP32 -> AP模式(AT+CWMODE=2) -> 建热点
 *         OneChip_Mini7 / test1234 (192.168.4.1/255.255.255.0)
 *         -> AT+CIPAP? 查询热点IP -> AT+CWDHCP? 查询DHCP状态
 *         -> AT+CIPMUX=1 -> AT+CIPSERVER=1,8002 启动TCP服务
 *         -> 手机连接热点,经TCP 8002下发:
 *            {"ssid":"Onechip_602","password":"onchip1003"}
 *         -> 解析JSON, ssid->sysinf.wifiname, password->sysinf.password
 *         -> cfg_save_cfg_param() 保存到Flash
 *         -> 复位ESP32进入正常STA模式(按新配置自动连接)
 *  说明 : 热点地址192.168.4.1/255.255.255.0为ESP32 SoftAP默认值,无需配置
 * ===================================================================== */
#define WIFI_PROV_AP_SSID        "OneChip_Mini7"   /* 热点名称 */
#define WIFI_PROV_AP_PWD         "test1234"        /* 热点密码 */
#define WIFI_PROV_AP_CHANNEL     6                 /* 信道 */
#define WIFI_PROV_AP_ECN         3                 /* 加密:3=WPA2_PSK */
#define WIFI_PROV_TCP_PORT       8002              /* TCP服务端口 */

#define WIFI_PROV_CMD_TIMEOUT    500               /* 单条AT指令超时:5s(10ms) */
#define WIFI_PROV_RST_TIMEOUT    1000              /* AT+RST等待ready:10s */
#define WIFI_PROV_LISTEN_TIMEOUT 30000             /* 等待配网数据总超时:300s */
#define WIFI_PROV_MAX_RETRY      3                 /* 指令失败重试次数 */
#define WIFI_PROV_RX_IDLE_TIMEOUT 100               /* 无有效IPD残留数据清空时限:1s(10ms) */

typedef enum
{
    WIFI_PROV_IDLE = 0,   /* 空闲 */
    WIFI_PROV_START,      /* 启动初始化 */
    WIFI_PROV_RST,        /* 复位ESP32,重启进入AP主机模式 */
    WIFI_PROV_WAIT_READY, /* 等待模块重启完成 */
    WIFI_PROV_MODE,       /* AT+CWMODE=2 设置AP模式 */
    WIFI_PROV_SAP,        /* AT+CWSAP 建立热点 */
    WIFI_PROV_IP_Q,       /* AT+CIPAP? 查询SoftAP接口IP(默认192.168.4.1) */
    WIFI_PROV_DHCP_Q,     /* AT+CWDHCP? 查询DHCP使能状态 */
    WIFI_PROV_MUX,        /* AT+CIPMUX=1 打开多连接 */
    WIFI_PROV_SERVER,     /* AT+CIPSERVER=1,8002 启动TCP服务 */
    WIFI_PROV_LISTEN,     /* 等待手机下发配网JSON */
    WIFI_PROV_ACK_SEND,   /* AT+CIPSEND 向手机应答 */
    WIFI_PROV_ACK_DATA,   /* 等待'>'并发送应答数据 */
    WIFI_PROV_SAVE,       /* 保存配置到Flash */
    WIFI_PROV_DONE,       /* 配网完成,复位进入正常模式 */
} wifi_prov_state_t;

static volatile uint8_t wifi_prov_request = 0;  /* 配网请求标志(可被ISR置位) */
static uint8_t  wifi_prov_active  = 0;         /* 配网进行中 */
static uint8_t  wifi_prov_state   = WIFI_PROV_IDLE;
static uint8_t  wifi_prov_retry   = 0;
static uint8_t  wifi_prov_wait    = 0;         /* 1=正在等待应答 */
static uint8_t  wifi_prov_json_ok = 0;         /* 解析到的配置是否有效 */
static uint8_t  wifi_prov_linkid  = 0;         /* TCP链路ID */
static uint32_t wifi_prov_tick    = 0;         /* 起始时间戳(10ms单位) */
static uint32_t wifi_prov_timeout = 0;         /* 等待超时(10ms单位) */
static char     wifi_prov_ipd[WIFI_RX_BUF_SIZE];/* +IPD载荷累积缓存(JSON) */
static uint16_t wifi_prov_ipd_len = 0;
static char     wifi_prov_ack[WIFI_RX_BUF_SIZE];/* 应答JSON */

static void wifi_prov_enter(void);
static void wifi_prov_exit(void);
static void wifi_prov_abort(void);

/* 配网进行中? */
uint8_t WIFI_provision_active(void)
{
    return wifi_prov_active;
}

/* 请求进入热点配网模式(按键长按30s调用,允许在中断中调用) */
uint8_t WIFI_provision_request(void)
{
    if (wifi_prov_active != 0)
        return 0;   /* 已在配网中 */
    wifi_prov_request = 1;
    return 1;
}

/* 配网状态机内部发送AT指令 */
static void wifi_prov_send_cmd(const char *cmd, uint32_t timeout10ms)
{
    char buff[128] = {0};

    strcpy(buff, cmd);
    strcat(buff, "\r\n");
    Van_Device_Printf(VAN_LOG_WIFI, "\nP--> %s", buff);
    WriteComm2(buff, strlen(buff));

    wifi_prov_wait    = 1;
    wifi_prov_tick    = sysinf.conter10ms;
    wifi_prov_timeout = timeout10ms;
}

/* 从ESP接收环中提取一个完整的+IPD报文载荷并追加到累积缓存
 * 返回: 1=取到完整报文; 0=暂无完整报文(继续等待);
 *      -1=帧头/载荷异常(不打印、不清空、不消费,继续等待直到总超时退出) */
static int wifi_prov_capture_ipd(void)
{
    uint32_t head  = g_wifi_rx_head;
    uint32_t last  = g_wifi_rx_last;
    uint32_t avail = (last + WIFI_RX_BUF_SIZE - head) % WIFI_RX_BUF_SIZE;
    int pos = -1;
    uint32_t i;

    if (avail == 0)
        return 0;

    /* 查找"+IPD,"头 */
    for (i = 0; (i + 5) <= avail; i++)
    {
        uint32_t p = (head + i) % WIFI_RX_BUF_SIZE;
        if (g_wifi_rx_buf[p] == '+' &&
            g_wifi_rx_buf[(p + 1) % WIFI_RX_BUF_SIZE] == 'I' &&
            g_wifi_rx_buf[(p + 2) % WIFI_RX_BUF_SIZE] == 'P' &&
            g_wifi_rx_buf[(p + 3) % WIFI_RX_BUF_SIZE] == 'D' &&
            g_wifi_rx_buf[(p + 4) % WIFI_RX_BUF_SIZE] == ',')
        {
            pos = (int)i;
            break;
        }
    }
    if (pos < 0)
        return 0;   /* 缓冲内无+IPD报文 */

    i = (uint32_t)(pos + 5);
    if (i >= avail)
        return 0;   /* 帧头不完整,继续等待 */

    /* 解析头: +IPD,<linkID>,<len>: */
    if (g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] < '0' ||
        g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] > '9')
        return -1;   /* linkid非数字,帧损坏 */
    {
        uint32_t linkid = 0;
        while (i < avail &&
               g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] >= '0' &&
               g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] <= '9')
        {
            linkid = linkid * 10 + (uint32_t)(g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] - '0');
            i++;
        }
        if (i >= avail)
            return 0;   /* linkid未完,继续等待 */
        if (g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] != ',')
            return -1;   /* 缺少逗号分隔,帧损坏 */
        wifi_prov_linkid = (uint8_t)linkid;
        i++;
        if (i >= avail)
            return 0;
        if (g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] < '0' ||
            g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] > '9')
            return -1;   /* 长度非数字,帧损坏 */
        {
            uint32_t pktlen = 0;
            while (i < avail &&
                   g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] >= '0' &&
                   g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] <= '9')
            {
                pktlen = pktlen * 10 + (uint32_t)(g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] - '0');
                i++;
            }
            if (i >= avail)
                return 0;   /* len未完,继续等待 */
            if (g_wifi_rx_buf[(head + i) % WIFI_RX_BUF_SIZE] != ':')
                return -1;   /* 缺少冒号分隔,帧损坏 */
            i++;    /* 跳过 ':' */
            if (pktlen == 0)
                return -1;   /* 空载荷异常 */
            if (avail < i + pktlen)
                return 0;   /* 载荷尚未收完,继续等待 */

            if ((uint16_t)(wifi_prov_ipd_len + pktlen) < sizeof(wifi_prov_ipd))
            {
                uint32_t k;
                for (k = 0; k < pktlen; k++)
                {
                    char c = (char)g_wifi_rx_buf[(head + i + k) % WIFI_RX_BUF_SIZE];
                    if (c == '\r' || c == '\n')  /* 去掉行结束符 */
                        continue;
                    wifi_prov_ipd[wifi_prov_ipd_len++] = c;
                }
                wifi_prov_ipd[wifi_prov_ipd_len] = '\0';
            }
            else
            {
                /* 载荷超限无法累积: 丢弃该帧载荷,重新接收 */
                wifi_prov_ipd_len = 0;
                wifi_prov_ipd[0]  = '\0';
            }
            /* 消费该报文 */
            g_wifi_rx_head = (head + i + pktlen) % WIFI_RX_BUF_SIZE;
            return 1;
        }
    }
}

/* 解析配网JSON: {"ssid":"xxx","password":"xxx"}
 * 返回: 0=成功; -1=失败 */
static int wifi_prov_parse_json(const char *json, char *ssid, uint16_t ssidCap,
                                char *pwd, uint16_t pwdCap)
{
    cJSON *root = NULL;
    cJSON *it   = NULL;
    int rlt     = -1;

    if (json == NULL || json[0] != '{' || ssid == NULL || pwd == NULL)
        return -1;
    ssid[0] = '\0';
    pwd[0]  = '\0';

    root = cJSON_Parse(json);
    if (root == NULL)
        return -1;

    it = cJSON_GetObjectItem(root, "ssid");
    if (it == NULL || !cJSON_IsString(it) || it->valuestring == NULL ||
        it->valuestring[0] == '\0')
        goto out;   /* 必须包含非空ssid */
    if (strlen(it->valuestring) >= (size_t)ssidCap)
        goto out;   /* ssid超长 */
    strcpy(ssid, it->valuestring);

    it = cJSON_GetObjectItem(root, "password");
    if (it != NULL && cJSON_IsString(it) && it->valuestring != NULL)
    {
        if (strlen(it->valuestring) >= (size_t)pwdCap)
            goto out;   /* 密码超长 */
        strcpy(pwd, it->valuestring);   /* 允许开放网络密码为空 */
    }
    rlt = 0;

out:
    cJSON_Delete(root);
    return rlt;
}

/* 生成应答JSON */
static void wifi_prov_build_ack(uint8_t accepted, const char *reason)
{
    if (accepted)
    {
        my_sprintf(wifi_prov_ack, sizeof(wifi_prov_ack),
                   "{\"v\":1,\"status\":\"accepted\",\"sn\":\"%s\"}\r\n",
                   sysinf.SN);
    }
    else
    {
        if (reason == NULL)
            reason = "invalid";
        my_sprintf(wifi_prov_ack, sizeof(wifi_prov_ack),
                   "{\"v\":1,\"status\":\"rejected\",\"reason\":\"%s\"}\r\n",
                   reason);
    }
}

/* 进入热点配网模式 */
static void wifi_prov_enter(void)
{
    wifi_prov_active  = 1;
    wifi_prov_state   = WIFI_PROV_START;
    wifi_prov_retry   = 0;
    wifi_prov_wait    = 0;
    wifi_prov_linkid  = 0;
    wifi_prov_json_ok = 0;
    wifi_prov_ipd_len = 0;
    wifi_prov_ipd[0]  = '\0';

    memset(wifi_tx_buf, 0, sizeof(wifi_tx_buf));
    wifi_tx_len    = 0;
    wifi_ack_delay = 0;
    wifi_state     = WIFI_POWEROFF;   /* 暂停正常wifi流程 */
    wifi_receive_clear();

    Van_Device_Printf(VAN_LOG_WIFI,
                      "\r\n[Provision] enter, AP=%s pwd=%s port=%d",
                      WIFI_PROV_AP_SSID, WIFI_PROV_AP_PWD, WIFI_PROV_TCP_PORT);
    beep_set(BEEP_SCANOK);   /* 提示进入配网 */
}

/* 退出热点配网,回到正常STA流程 */
static void wifi_prov_exit(void)
{
    wifi_prov_active  = 0;
    wifi_prov_request = 0;
    wifi_prov_state   = WIFI_PROV_IDLE;
    wifi_prov_wait    = 0;
    wifi_prov_ipd_len = 0;
    wifi_prov_ipd[0]  = '\0';

    memset(wifi_tx_buf, 0, sizeof(wifi_tx_buf));
    wifi_tx_len    = 0;
    wifi_ack_delay = 0;
    wifi_receive_clear();

    /* 交给正常流程:WIFI_POWEROFF会先AT+RST复位模块,再按新配置重连 */
    WIFI_set_ssid();
    Van_Device_Printf(VAN_LOG_WIFI, "\r\n[Provision] exit to normal STA");
}

/* 配网失败,恢复到正常STA模式 */
static void wifi_prov_abort(void)
{
    Van_Device_Printf(VAN_LOG_WIFI, "\r\n[Provision] abort, exit to normal STA");
    wifi_prov_exit();
}

/* 检查AT指令应答;收到OK后切到okState;出错则重试,超过次数退出配网
 * 返回: 1=收到OK并已切状态; 0=仍在等待; -1=失败(已重发或已中止) */
static int wifi_prov_check_cmd_resp(uint8_t okState)
{
    if (NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE, &g_wifi_rx_head,
                              g_wifi_rx_last, "OK\r\n"))
    {
        wifi_receive_clear();
        wifi_prov_wait  = 0;
        wifi_prov_retry = 0;
        wifi_prov_state = okState;
        return 1;
    }
    if (NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE, &g_wifi_rx_head,
                              g_wifi_rx_last, "ERROR") ||
        (uint32_t)(sysinf.conter10ms - wifi_prov_tick) >= wifi_prov_timeout)
    {
        wifi_receive_clear();
        wifi_prov_wait = 0;
        if (++wifi_prov_retry < WIFI_PROV_MAX_RETRY)
            return -1;   /* 由状态机重发指令 */
        wifi_prov_abort();
        return -1;
    }
    return 0;
}

/* 查询类AT指令处理: 发送AT+CIPAP?/AT+CWDHCP?后等待回复,收到OK(或超时)后
 * 将完整应答打印到调试日志并切到okState状态
 * 返回: 0=仍在等待; 1=已收到回复并切状态 */
static uint8_t wifi_prov_query_done(uint8_t okState)
{
    char tmp[WIFI_RX_BUF_SIZE];
    uint32_t head = g_wifi_rx_head;
    uint32_t last = g_wifi_rx_last;
    uint32_t n = 0;

    if (wifi_prov_wait == 0)
        return 0;

    /* 线性化接收缓冲,便于查找与打印 */
    while (head != last && n < (uint32_t)(WIFI_RX_BUF_SIZE - 1))
    {
        tmp[n++] = (char)g_wifi_rx_buf[head];
        head = (head + 1) % WIFI_RX_BUF_SIZE;
    }
    tmp[n] = '\0';

    if (strstr(tmp, "OK") != NULL ||
        (uint32_t)(sysinf.conter10ms - wifi_prov_tick) >= wifi_prov_timeout)
    {
        /* 打印查询结果(含OK结尾),确认热点IP与DHCP状态 */
        Van_Device_Printf(VAN_LOG_WIFI, "\r\n[Provision] <-%s", tmp);
        wifi_receive_clear();
        wifi_prov_wait  = 0;
        wifi_prov_retry = 0;
        wifi_prov_state = okState;
        return 1;
    }
    return 0;
}

/* 热点配网状态机主处理(每次进入WIFI_process调用) */
static void wifi_prov_process(void)
{
    switch (wifi_prov_state)
    {
    case WIFI_PROV_IDLE:
    default:
        break;

    /* 启动初始化 */
    case WIFI_PROV_START:
        wifi_receive_clear();
        wifi_prov_ipd_len = 0;
        wifi_prov_ipd[0]  = '\0';
        wifi_prov_wait    = 0;
        wifi_prov_state   = WIFI_PROV_RST;
        break;

    /* 1. 复位ESP32,重启进入AP主机模式 */
    case WIFI_PROV_RST:
        wifi_prov_send_cmd("AT+RST", WIFI_PROV_RST_TIMEOUT);
        wifi_prov_state   = WIFI_PROV_WAIT_READY;
        wifi_prov_retry   = 0;
        break;

    case WIFI_PROV_WAIT_READY:
        if (NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE, &g_wifi_rx_head,
                                  g_wifi_rx_last, "ready") ||
            NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE, &g_wifi_rx_head,
                                  g_wifi_rx_last, "boot"))
        {
            wifi_receive_clear();
            wifi_prov_state = WIFI_PROV_MODE;
        }
        else if ((uint32_t)(sysinf.conter10ms - wifi_prov_tick) >= wifi_prov_timeout)
        {
            wifi_receive_clear();
            if (++wifi_prov_retry < WIFI_PROV_MAX_RETRY)
                wifi_prov_state = WIFI_PROV_RST;   /* 重试复位 */
            else
                wifi_prov_abort();
        }
        break;

    /* 2. 设置AP模式 */
    case WIFI_PROV_MODE:
        if (wifi_prov_wait != 0)
            wifi_prov_check_cmd_resp(WIFI_PROV_SAP);
        else
            wifi_prov_send_cmd("AT+CWMODE=2", WIFI_PROV_CMD_TIMEOUT);
        break;

    /* 3. 建立热点: 名称OneChip_Mini7, 密码test1234 */
    case WIFI_PROV_SAP:
    {
        char cStr[128] = {0};
        if (wifi_prov_wait != 0)
            wifi_prov_check_cmd_resp(WIFI_PROV_IP_Q);
        else
        {
            my_sprintf(cStr, sizeof(cStr), "AT+CWSAP=\"%s\",\"%s\",%d,%d",
                       WIFI_PROV_AP_SSID, WIFI_PROV_AP_PWD,
                       WIFI_PROV_AP_CHANNEL, WIFI_PROV_AP_ECN);
            wifi_prov_send_cmd(cStr, WIFI_PROV_CMD_TIMEOUT);
        }
        break;
    }

    /* 4. 查询SoftAP接口IP(默认192.168.4.1),确认热点地址 */
    case WIFI_PROV_IP_Q:
        if (wifi_prov_wait != 0)
            wifi_prov_query_done(WIFI_PROV_DHCP_Q);
        else
            wifi_prov_send_cmd("AT+CIPAP?", WIFI_PROV_CMD_TIMEOUT);
        break;

    /* 5. 查询DHCP使能状态(确认AP侧能分配192.168.4.x) */
    case WIFI_PROV_DHCP_Q:
        if (wifi_prov_wait != 0)
            wifi_prov_query_done(WIFI_PROV_MUX);
        else
            wifi_prov_send_cmd("AT+CWDHCP?", WIFI_PROV_CMD_TIMEOUT);
        break;

    /* 6. 打开多连接 */
    case WIFI_PROV_MUX:
        if (wifi_prov_wait != 0)
            wifi_prov_check_cmd_resp(WIFI_PROV_SERVER);
        else
            wifi_prov_send_cmd("AT+CIPMUX=1", WIFI_PROV_CMD_TIMEOUT);
        break;

    /* 7. 启动TCP服务端: 端口8002 */
    case WIFI_PROV_SERVER:
    {
        char cStr[48] = {0};
        if (wifi_prov_wait != 0)
        {
            if (wifi_prov_check_cmd_resp(WIFI_PROV_LISTEN) == 1)
                wifi_prov_tick = sysinf.conter10ms;  /* 记录开始等待配网的时间 */
        }
        else
        {
            my_sprintf(cStr, sizeof(cStr), "AT+CIPSERVER=1,%d", WIFI_PROV_TCP_PORT);
            wifi_prov_send_cmd(cStr, WIFI_PROV_CMD_TIMEOUT);
        }
        break;
    }

    /* 8. 等待手机经TCP下发配网JSON(总超时300s) */
    case WIFI_PROV_LISTEN:
        if ((uint32_t)(sysinf.conter10ms - wifi_prov_tick) >= WIFI_PROV_LISTEN_TIMEOUT)
        {
            Van_Device_Printf(VAN_LOG_WIFI, "\r\n[Provision] wait cfg timeout");
            wifi_prov_wait  = 0;
            wifi_prov_state = WIFI_PROV_DONE;   /* 超时未收到配置,直接退出 */
            break;
        }
        /* 接收并解析+IPD报文 */
        {
            int ipdRlt = wifi_prov_capture_ipd();
            if (ipdRlt > 0)
            {
                if (wifi_prov_ipd_len >= (uint16_t)(sizeof(wifi_prov_ipd) - 2))
                {
                    /* 累积超限,丢弃重收 */
                    wifi_receive_clear();
                    wifi_prov_ipd_len = 0;
                    wifi_prov_ipd[0]  = '\0';
                }
            }
            else
            {
                /* 存在接收数据但未解析出有效+IPD,且距最近接收超1s: 打印残留并清空 */
                if (g_wifi_rx_head != g_wifi_rx_last &&
                    (uint32_t)(sysinf.conter10ms - g_wifi_rx_last_tick) >= WIFI_PROV_RX_IDLE_TIMEOUT)
                {
                    Van_Device_Printf(VAN_LOG_WIFI, "\r\n%s", g_wifi_rx_buf);
                    wifi_receive_clear();
                    wifi_prov_ipd_len = 0;
                    wifi_prov_ipd[0]  = '\0';
                }
            }
        }
        /* 累积到完整JSON后解析 */
        if (wifi_prov_ipd_len > 0 &&
            wifi_prov_ipd[0] == '{' &&
            wifi_prov_ipd[wifi_prov_ipd_len - 1] == '}')
        {
            char ssid[sizeof(sysinf.wifiname)];
            char pwd[sizeof(sysinf.password)];
            if (wifi_prov_parse_json(wifi_prov_ipd, ssid, (uint16_t)sizeof(ssid),
                                     pwd, (uint16_t)sizeof(pwd)) == 0)
            {
                memset(sysinf.wifiname, 0, sizeof(sysinf.wifiname));
                memset(sysinf.password, 0, sizeof(sysinf.password));
                strcpy(sysinf.wifiname, ssid);
                strcpy(sysinf.password, pwd);
                wifi_prov_json_ok = 1;
                Van_Device_Printf(VAN_LOG_WIFI, "\r\n[Provision] got cfg: ssid=%s pwd=%s",
                                  sysinf.wifiname, sysinf.password);
            }
            else
            {
                wifi_prov_json_ok = 0;
                Van_Device_Printf(VAN_LOG_WIFI, "\r\n[Provision] bad json: %s",
                                  wifi_prov_ipd);
            }
            wifi_prov_build_ack(wifi_prov_json_ok, "invalid");
            wifi_prov_state = WIFI_PROV_ACK_SEND;
        }
        break;

    /* 9. 向手机应答(accepted/rejected) */
    case WIFI_PROV_ACK_SEND:
    {
        char cStr[48] = {0};
        Van_Device_Printf(VAN_LOG_WIFI, "\r\nack json: %s",
                                  wifi_prov_ack);
        wifi_receive_clear();
        my_sprintf(cStr, sizeof(cStr), "AT+CIPSEND=%d,%d",
                   wifi_prov_linkid, (int)strlen(wifi_prov_ack));
        wifi_prov_send_cmd(cStr, WIFI_PROV_CMD_TIMEOUT);
        /* CIPSEND属非透传"先握手后发数": 复位wait,由ACK_DATA收到OK后真正发载荷 */
        wifi_prov_wait = 0;
        wifi_prov_state = WIFI_PROV_ACK_DATA;
        break;
    }

    case WIFI_PROV_ACK_DATA:
        if (wifi_prov_wait == 0)
        {
            /* 等待 'OK\r\n' 提示符后发送应答数据 */
            if(NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE ,&g_wifi_rx_head, g_wifi_rx_last, "OK\r\n"))
            {
                wifi_receive_clear();
                wifi_prov_wait      = 1;
                wifi_prov_tick      = sysinf.conter10ms;
                wifi_prov_timeout   = WIFI_PROV_CMD_TIMEOUT;
                WriteComm2(wifi_prov_ack, strlen(wifi_prov_ack));
            }
            else if (NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE, &g_wifi_rx_head,
                                           g_wifi_rx_last, "ERROR") ||
                     NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE, &g_wifi_rx_head,
                                           g_wifi_rx_last, "CLOSED") ||
                     (uint32_t)(sysinf.conter10ms - wifi_prov_tick) >= wifi_prov_timeout)
            {
                /* 应答失败或超时,继续后续流程 */
                Van_Device_Printf(VAN_LOG_WIFI, "\r\n%s", g_wifi_rx_buf);
                wifi_receive_clear();
                wifi_prov_wait = 0;
                wifi_prov_state = (wifi_prov_json_ok != 0) ? WIFI_PROV_SAVE : WIFI_PROV_LISTEN;
                wifi_prov_ipd_len = 0;
                wifi_prov_ipd[0]  = '\0';
                if (wifi_prov_json_ok == 0)
                    wifi_prov_tick = sysinf.conter10ms;  /* 重新计时 */
            }
        }
        else
        {
            /* 等待SEND OK */
            if (NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE, &g_wifi_rx_head,
                                      g_wifi_rx_last, "SEND OK") ||
                NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE, &g_wifi_rx_head,
                                      g_wifi_rx_last, "ERROR") ||
                NULL != find_str_loop(g_wifi_rx_buf, WIFI_RX_BUF_SIZE, &g_wifi_rx_head,
                                      g_wifi_rx_last, "CLOSED") ||
                (uint32_t)(sysinf.conter10ms - wifi_prov_tick) >= wifi_prov_timeout)
            {
                Van_Device_Printf(VAN_LOG_WIFI, "\r\n%s", g_wifi_rx_buf);
                wifi_receive_clear();
                wifi_prov_wait = 0;
                wifi_prov_state = (wifi_prov_json_ok != 0) ? WIFI_PROV_SAVE : WIFI_PROV_LISTEN;
                wifi_prov_ipd_len = 0;   /* 无效配置则清空缓存重新等待 */
                wifi_prov_ipd[0]  = '\0';
                if (wifi_prov_json_ok == 0)
                    wifi_prov_tick = sysinf.conter10ms;  /* 重新计时 */
            }
        }
        break;

    /* 10. 保存配网参数到Flash */
    case WIFI_PROV_SAVE:
    {
        uint8_t saveRlt = cfg_save_cfg_param();
        Van_Device_Printf(VAN_LOG_WIFI, "\r\n[Provision] cfg_save_cfg_param=%d", saveRlt);
        wifi_prov_state = WIFI_PROV_DONE;
        break;
    }

    /* 11. 配网完成: 复位ESP32进入正常模式 */
    case WIFI_PROV_DONE:
        wifi_prov_exit();
        break;
    }
}


//wifi任务
void WIFI_process()
{
    /* 热点配网模式优先处理 */
    if (wifi_prov_request != 0 || wifi_prov_active != 0)
    {
        if (wifi_prov_request != 0)
        {
            wifi_prov_request = 0;
            wifi_prov_enter();
        }
        wifi_prov_process();
        return;
    }

    if(sysinf.pc_channel_recv == 2  &&  wifi_state > WIFI_SETMUX){
        /*串口状态下，不走wifi处理*/
        return;
    }
    WIFI_recv_deal();

    WIFI_send_deal();
}

static uint32_t m_pow_n(uint32_t m, int32_t n)
{
    uint32_t i = 0, ret = 1;
    if (n < 0) return 0;
    for (i = 0; i < n; i++)
    {
        ret *= m;
    }
    return ret;
}

// 返回值为打印字符的个数
// 支持%d，%o, %x，%s，%c，%f（只打印6位数字）
int my_sprintf(char *pdes,unsigned int len, const char* str, ...)
{
    if (str == NULL) return -1;

	  uint32_t ret_num = 0;// 返回打印字符的个数
    char* pStr = (char*)str;// 指向str
    int ArgIntVal = 0;  // 接收整型
    uint32_t ArgHexVal = 0;// 接十六进制
    char* ArgStrVal = NULL;  // 接收字符型
    double ArgFloVal = 0.0; // 接受浮点型
    uint32_t val_seg = 0;   // 数据切分
    uint32_t val_temp = 0;  // 临时保存数据
    int cnt = 0;       // 数据长度计数
    int cnt_float = 0;       // 数据长度计数
    
    va_list pArgs; // 定义va_list类型指针，用于存储参数的地址
    va_start(pArgs, str); // 初始化pArgs
    while (*pStr != '\0')
    {
        switch (*pStr)
        {
        case ' ':
        case '\r':
        case '\n':
            *pdes++ = (*pStr); ret_num++; break;
        case '\t':
            *pdes++ =(*pStr); ret_num += 4; break;
        case '%':
            pStr++;
            // % 格式解析

			if('.' == *pStr)
			{
            	pStr++;
				cnt_float = *pStr - '0';// %.Nf，输出指定位数小数
                pStr++;
			}
			
            switch (*pStr)
            {
            case '%':
                *pdes++ =('%');// %%，输出%
                ret_num++;
                pStr++;
				continue;
            case 'c':
                ArgIntVal = va_arg(pArgs, int);// %c，输出char
                *pdes++ =((char)ArgIntVal);
                ret_num++;
                pStr++;
				continue;
            case 'd':
                // 接收整型
                ArgIntVal = va_arg(pArgs, int);
                if (ArgIntVal < 0)// 如果为负数打印，负号
                {
                    ArgIntVal = -ArgIntVal;// 取相反数

                    *pdes++ =('-');
                    ret_num++;
                }
                val_seg = ArgIntVal;// 赋值给 val_seg处理数据
                // 计算ArgIntVal长度
                if (ArgIntVal)
                {
                    while (val_seg) {
                        cnt++;
                        val_seg /= 10;
                    }
                }
                else cnt = 1;// 数字0的长度为1

                ret_num += cnt;// 字符个数加上整数的长度

                // 将整数转为单个字符打印
                while (cnt)
                {
                    val_seg = ArgIntVal / m_pow_n(10, cnt - 1);
                    ArgIntVal %= m_pow_n(10, cnt - 1);
                    *pdes++ =((char)val_seg + '0');
                    cnt--;
                }
                pStr++;
                continue;
            case 'o':
                // 接收整型
                ArgIntVal = va_arg(pArgs, int);
                if (ArgIntVal < 0)// 如果为负数打印，负号
                {
                    ArgIntVal = -ArgIntVal;// 取相反数

                    *pdes++ =('-');
                    ret_num++;
                }
                val_seg = ArgIntVal;// 赋值给 val_seg处理数据
                // 计算ArgIntVal长度
                if (ArgIntVal)
                {
                    while (val_seg) {
                        cnt++;
                        val_seg /= 8;
                    }
                }
                else cnt = 1;// 数字0的长度为1

                ret_num += cnt;// 字符个数加上整数的长度

                // 将整数转为单个字符打印
                while (cnt)
                {
                    val_seg = ArgIntVal / m_pow_n(8, cnt - 1);
                    ArgIntVal %= m_pow_n(8, cnt - 1);
                    *pdes++ =((char)val_seg + '0');
                    cnt--;
                }
                pStr++;
				continue;
            case 'x':
                // 接收16进制
                ArgHexVal = va_arg(pArgs, uint32_t);
                val_seg = ArgHexVal;
                // 计算ArgIntVal长度
                if (ArgHexVal)
                {
                    while (val_seg) {
                        cnt++;
                        val_seg /= 16;
                    }
                }
                else cnt = 1;// 数字0的长度为1

                ret_num += cnt;// 字符个数加上整数的长度
                // 将整数转为单个字符打印
                while (cnt)
                {
                    val_seg = ArgHexVal / m_pow_n(16, cnt - 1);
                    ArgHexVal %= m_pow_n(16, cnt - 1);
                    if (val_seg <= 9)
                        *pdes++ =((char)val_seg + '0');
                    else
                    {
						//*pdes++ =((char)val_seg - 10 + 'a'); //小写字母
                        *pdes++ =((char)val_seg - 10 + 'A');
                    }
                    cnt--;
                }
                pStr++;
				continue;
            case 'b':
                // 接收整型
                ArgIntVal = va_arg(pArgs, int);
                val_seg = ArgIntVal;
                // 计算ArgIntVal长度
                if (ArgIntVal)
                {
                    while (val_seg) {
                        cnt++;
                        val_seg /= 2;
                    }
                }
                else cnt = 1;// 数字0的长度为1

                ret_num += cnt;// 字符个数加上整数的长度
                // 将整数转为单个字符打印
                while (cnt)
                {
                    val_seg = ArgIntVal / m_pow_n(2, cnt - 1);
                    ArgIntVal %= m_pow_n(2, cnt - 1);
                    *pdes++ =((char)val_seg + '0');
                    cnt--;
                }
                pStr++;
				continue;
            case 's':
                // 接收字符
                ArgStrVal = va_arg(pArgs, char*);
                ret_num += (uint32_t)strlen(ArgStrVal);
                while (*ArgStrVal)
                {
                    *pdes++ =(*ArgStrVal);
                    ArgStrVal++;
                }

                pStr++;
				continue;

            case 'f':
                // 接收浮点型 保留6为小数，不采取四舍五入
                ArgFloVal = va_arg(pArgs, double);
                val_seg = (uint32_t)ArgFloVal;// 取整数部分
                val_temp = val_seg;      // 临时保存整数部分数据
                ArgFloVal = ArgFloVal - val_seg;// 得出余下的小数部分
                // 计算整数部分长度
                if (val_seg)
                {
                    while (val_seg) {
                        cnt++;
                        val_seg /= 10;
                    }
                }
                else cnt = 1;// 数字0的长度为1
                ret_num += cnt;// 字符个数加上整数的长度
                // 将整数转为单个字符打印
                while (cnt)
                {
                    val_seg = val_temp / m_pow_n(10, cnt - 1);
                    val_temp %= m_pow_n(10, cnt - 1);
                    *pdes++ =((char)val_seg + '0');
                    cnt--;
                }
                // 打印小数点
                *pdes++ =('.');
                ret_num++;
                // printf("\r\n %f\r\n", ArgFloVal);
				if(cnt_float == 0)
                	cnt_float = 6;
					
                // 开始输出小数部分
                //ArgFloVal *= 1000000;
                ArgFloVal *= m_pow_n(10, cnt_float);

                val_temp = (int)ArgFloVal;// 取整数部分
                while (cnt_float)
                {
                    val_seg = val_temp / m_pow_n(10, cnt_float - 1);
                    val_temp %= m_pow_n(10, cnt_float - 1);
                    *pdes++ =((char)val_seg + '0');
                    cnt_float--;
                }
                ret_num += 6;
                pStr++;
				continue;
            default:// % 匹配错误，暂输出空格
				*pdes++ =(' '); ret_num++;
				break;
            }
			break;


        default:
            *pdes++ =(*pStr); ret_num++;
            break;
        }
        pStr++;
		if(ret_num > len){
			break;
		}
    }
    va_end(pArgs);// 结束取参数

    *pdes++ = 0;

    return ret_num;
}