/*
* esp8266at.c
*
*
*/

#include "bsp.h"
#include "stdint.h"
#include "string.h"
#include "usart.h"
#include "esp8266at.h"
#include "wificonfig.h"
#include "main.h"

/****************************************************/
#define RTXBUFLEN           1028

static const uint32_t commBaudrates[3] = {WIFI_LOWEST_BAUDRATE,WIFI_HIGH_BAUDRATE,WIFI_HIGHEST_BAUDRATE};

static volatile uint8_t wifiTempBuf[128];
static volatile uint8_t wifiRxBuf[RTXBUFLEN];
static volatile uint8_t wifiTxBuf[RTXBUFLEN];

#if 1
const char* cmd_at                  = "AT";
const char* cmd_at_dis_on           = "ATE1";
const char* cmd_at_dis_off          = "ATE0";
const char* cmd_at_version          = "AT+GMR";
const char* cmd_at_reset            = "AT+RST";
const char* cmd_at_restore          = "AT+RESTORE";
const char* cmd_at_rfpower          = "AT+RFPOWER=80";//(0~82)*0.25dbm
const char* cmd_at_uartcur_set      = "AT+UART_CUR=115200,8,1,0,0";//
//const char* cmd_at_uartdef_set      = "AT+UART_DEF=256000,8,1,0,0";//max default
const char* cmd_at_uartdef_set      = "AT+UART_DEF=921600,8,1,0,0";//max default
//const char* cmd_at_uartdef_set      = "AT+UART_DEF=1382400,8,1,0,0";//max default

const char* cmd_at_modecur_sta      = "AT+CWMODE_CUR=1";
const char* cmd_at_modecur_ap       = "AT+CWMODE_CUR=2";
const char* cmd_at_modedef_sta      = "AT+CWMODE_DEF=1";
const char* cmd_at_modedef_ap       = "AT+CWMODE_DEF=2";
const char* cmd_at_mode_query       = "AT+CWMODE_CUR?";
const char* ans_at_modequery_sta    = "CWMODE_CUR:1";
const char* ans_at_modequery_ap     = "CWMODE_CUR:2";
const char* cmd_at_joinap_cur       = "AT+CWJAP_CUR=\"gd_zwhy\",\"guo123456\"";
const char* cmd_at_joinap_cur_part  = "AT+CWJAP_CUR=\"%s\",\"%s\"";
const char* cmd_at_joinap_def       = "AT+CWJAP_DEF=\"%s\",\"%s\"";
const char* ans_at_joinap           = "WIFI CONNECTED";//WIFI GOT IP
const char* cmd_at_dhcpdef_staon    = "AT+CWDHCP_DEF=0,1";
const char* cmd_at_dhcpdef_staoff   = "AT+CWDHCP_DEF=0,0";
const char* cmd_at_dhcpdef_apon     = "AT+CWDHCP_DEF=1,1";
const char* cmd_at_dhcpdef_apoff    = "AT+CWDHCP_DEF=1,0";
const char* cmd_at_dhcpdef_allon    = "AT+CWDHCP_DEF=2,1";
const char* cmd_at_dhcpdef_alloff   = "AT+CWDHCP_DEF=2,0";
const char* cmd_at_dhcpscope_def    = "AT+CWDHCPS_DEF=1,5,192.168.1.2,192.168.1.10";
const char* cmd_at_dhcps_cur_part   = "AT+CWDHCPS_CUR=1,5,\"%s\",\"%s\"";
const char* cmd_at_autoconnect_on   = "AT+CWAUTOCONN=1";
const char* cmd_at_autoconnect_off  = "AT+CWAUTOCONN=0";
const char* cmd_at_scanap           = "AT+CWLAP";
const char* cmd_at_quitap           = "AT+CWQAP";
const char* cmd_at_setap_cur        = "AT+CWSAP_CUR=<ssid>,<pwd>,<chl>,<ecn>[, <max conn>][,<ssid hidden>]";
const char* cmd_at_setap_cur_part   = "AT+CWSAP_CUR=\"%s_%d\",\"%s\",1,4";
const char* cmd_at_setap_def        = "AT+CWSAP_DEF=<ssid>,<pwd>,<chl>,<ecn>[, <max conn>][,<ssid hidden>]";
const char* cmd_at_staip_query      = "AT+CIPSTA_CUR?";
const char* cmd_at_apip_query      = "AT+CIPAP_CUR?";
const char* ans_at_staip_query      = "CIPSTA_CUR:";
const char* ans_at_apip_query      = "CIPAP_CUR:";
const char* cmd_at_staaddr_cur      = "AT+CIPSTA_CUR=\"192.168.6.100\",\"192.168.6.1\",\"255.255.255.0\"";
const char* cmd_at_staaddr_def      = "AT+CIPSTA_DEF=\"192.168.6.100\",\"192.168.6.1\",\"255.255.255.0\"";
const char* cmd_at_apaddr_cur       = "AT+CIPAP_CUR=\"192.168.4.2\",\"192.168.4.1\",\"255.255.255.0\"";
const char* cmd_at_apaddr_cur_part  = "AT+CIPAP_CUR=\"%s\",\"%s\",\"%s\"";
const char* cmd_at_apaddr_def       = "AT+CIPAP_DEF=\"192.168.1.1\",\"192.168.1.1\",\"255.255.255.0\"";

const char* cmd_at_ip_mux_single    = "AT+CIPMUX=0";
const char* cmd_at_ip_mux_multi     = "AT+CIPMUX=1";
const char* cmd_at_ip_clrbuf_single = "AT+CIPBUFRESET";
const char* cmd_at_ip_clrbuf_multi  = "AT+CIPBUFRESET=%d";
const char* cmd_at_ip_status        = "AT+CIPSTATUS";
const char* cmd_at_ip_addrmac_query = "AT+CIFSR";
const char* ans_at_ip_addrmac_query = "+CIFSR:";
const char* cmd_at_ip_start_tcp     = "AT+CIPSTART=\"TCP\",\"192.168.43.87\",8080";
const char* cmd_at_ip_start_tcp_part = "AT+CIPSTART=\"TCP\",\"%s\",%s";
const char* cmd_at_ip_start_udp     = "AT+CIPSTART=\"UDP\",\"192.168.43.87\",8080";
//////const char* cmd_at_ip_start_udp_part = "AT+CIPSTART=\"UDP\",\"%d.%d.%d.%d\",%d";
const char* cmd_at_ip_start_udp_part = "AT+CIPSTART=\"UDP\",\"%s\",%s";
const char* ans_at_ip_start         = "CONNECT";
const char* cmd_at_ip_close         = "AT+CIPCLOSE";
const char* cmd_at_ip_send_package  = "AT+CIPSEND=";
const char* cmd_at_ip_enter_normal  = "AT+CIPMODE=0";
const char* cmd_at_ip_enter_transp  = "AT+CIPMODE=1";
const char* cmd_at_ip_mode_query    = "AT+CIPMODE?";
const char* ans_at_ip_transp_mode   = "+CIPMODE:1";
const char* ans_at_ip_normal_mode   = "+CIPMODE:0";
const char* cmd_at_ip_start_trans   = "AT+CIPSEND";
const char* ans_at_ip_start_trans   = "AT+CIPSEND";
const char* cmd_at_ip_exit_trans    = "+++";
const char* cmd_at_ip_server_open   = "AT+CIPSERVER=1,8080";//IPMUX=1
const char* cmd_at_ip_server_close  = "AT+CIPSERVER=0";
const char* cmd_at_ip_listinfo      = "AT+CIFSR";
const char* cmd_at_ip_savelink_tcp  = "AT+SAVETRANSLINK=1,\"192.168.6.110\",1002,\"TCP\"";
const char* cmd_at_ip_savelink_udp  = "AT+SAVETRANSLINK=1,\"192.168.6.110\",1002,\"UDP\",1005";
const char* cmd_at_ip_tcptimeout    = "AT+CIPSTO=10";
const char* cmd_at_ip_ping          = "AT+PING=\"192.168.1.101\"";
const char* cmd_at_ip_ping_part   = "AT+PING=\"%s\"";
const char* cmd_at_ip_disinfo_on    = "AT+CIPDINFO=1";
const char* cmd_at_ip_disinfo_off   = "AT+CIPDINFO=0";
#endif

int ESP8266_Send_AT_Cmd(char *cmd, char *ack1, char *ack2, uint32_t time);


typedef enum
{
    CMD_STATE_INIT=0x00000000,
    CMD_STATE_SENDING=0x00000001,
    CMD_STATE_RECEIVING,
    CMD_STATE_ERROR
}eCmdState;
/***/
int ESP8266_Send_AT_Cmd(char *cmd, char *ack1, char *ack2, uint32_t time)
{
    static eCmdState state=CMD_STATE_INIT;
    int ret=0;
    switch(state)
    {
    case CMD_STATE_INIT:
        Wifi_Uart_ClearTxBuf();
        memset((void*)wifiTxBuf,0,RTXBUFLEN);
        sprintf((char*)wifiTxBuf,"%s\r\n", cmd);
        Wifi_Uart_ClearRxBuf();//Must be after the TX buffer clear!!
        memset((void*)wifiRxBuf,0,RTXBUFLEN);
        state = CMD_STATE_SENDING;
    case CMD_STATE_SENDING:
        ret = Wifi_Uart_Send((uint8_t*)wifiTxBuf,strlen((const char*)wifiTxBuf),500);
        if(ret==0)
        {
            return 0xffff;
        }
        if(ack1==NULL && ack2==NULL)
        {
            state=CMD_STATE_INIT;
            return 1;
        }
        state = CMD_STATE_RECEIVING;
    case CMD_STATE_RECEIVING:
        ret=Wifi_Uart_Receive((uint8_t*)wifiRxBuf, RTXBUFLEN,time);
        if(ret==0)
        {
            return 0xffff;
        }

        state = CMD_STATE_INIT;
        if(ack1!=NULL && ack2!=NULL)
        {
            return (NULL != strstr ( (const char*)wifiRxBuf, ack1 ) && NULL != strstr ( (const char*)wifiRxBuf, ack2 ) );
        }
        else if( ack1 != NULL )
            return ( NULL != strstr ( (const char*)wifiRxBuf, ack1 ) );
        else
            return ( NULL != strstr ( (const char*)wifiRxBuf, ack2 ) );
    }
    state = CMD_STATE_INIT;
    return 0xffff;
}


int Wifi_ConfigDefaultAP(void)
{
    uint32_t len=0;

    Wifi_Uart_Send((uint8_t*)cmd_at_modecur_ap,strlen(cmd_at_modecur_ap),1500);

    Wifi_Uart_Send((uint8_t*)cmd_at_rfpower,strlen(cmd_at_rfpower),1000);

    Wifi_Uart_Send((uint8_t*)cmd_at_apaddr_cur,strlen(cmd_at_apaddr_cur),1000);

    //Wifi_Uart_Send(wifiTxBuf, len);
    return len;
}

#if UART_INF_REG==0
int Wifi_testWorkState(void)
{
    int index=0;
    Wifi_reset();
    Delay_ms(2000);
    for(;index<3;index++)
    {
        Wifi_USART_Init(commBaudrates[index]);
        Wifi_Uart_Send((uint8_t*)cmd_at,strlen(cmd_at));
        memset((void*)wifiRxBuf,0,28);
        Wifi_Uart_Receive((uint8_t*)wifiRxBuf, 16);
        if(NULL != strstr((const char*)wifiRxBuf,"OK"))
        {
            break;
        }
    }
    if(index>=3) return -1;

    if(index != 2)
    {
        Wifi_Uart_Send((uint8_t*)cmd_at_uartdef_set,strlen(cmd_at_uartdef_set));
        memset((void*)wifiRxBuf,0,64);
        Wifi_Uart_Receive((uint8_t*)wifiRxBuf, 64);
        if(NULL == strstr((const char*)wifiRxBuf,"OK"))
        {
            return -1;
        }

        Wifi_reset();
        Delay_ms(1000);
        Wifi_USART_Init(commBaudrates[2]);
        Wifi_Uart_Send((uint8_t*)cmd_at,strlen(cmd_at));
        memset((void*)wifiRxBuf,0,28);
        Wifi_Uart_Receive((uint8_t*)wifiRxBuf, 16);
        if(NULL == strstr((const char*)wifiRxBuf,"OK"))
        {
            return -2;
        }
    }
    return 1;
}
#else
int Wifi_testWorkState(void)
{
    static int teststate=0;
    static int index=0;
    int rvlen=0;

    switch(teststate)
    {
    case 0:
        Wifi_USART_Init(commBaudrates[index]);
        teststate=1;
    case 1:
        rvlen = Wifi_reset();
        if(rvlen)
        {//wait for reset
            return 0;
        }
        teststate=2;
    case 2:
		rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at,"OK",NULL,1000);
        if(rvlen==0xffff)
        {//busy
            return 0;
        }
        else if(rvlen==0)
        {//failed
            teststate=0;
            index++;//next
            if(index>=3)
            {//all failed
                index = 0;
                return -1;
            }
            return 0;
        }
        else if(rvlen==1)
        {
            teststate=3;
        }
    case 3:
        if(index!=1)
        {
            rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_uartcur_set,"OK",NULL,1000);
            if(rvlen==0xffff)
            {//busy
                return 0;
            }
            else if(rvlen==0)
            {//failed
                teststate=0;
                index = 0;
                return -1;
            }
            else if(rvlen==1)//Reconnect
            {
                  
                teststate=0;
                return 1;
            }
        }
    default:
        index = 0;
        teststate=0;
        break;
    }
    return 1;
}
#endif

int Wifi_ConfigAp(void)
{
    static int cfgstastate=0;
    static uint32_t cfgstatime=0;
    int rvlen=0;
    uint32_t temp=0;

    switch(cfgstastate)
    {
    case 0:
        rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_modedef_ap,"OK",NULL,500);
        if(rvlen==0xffff)
        {//busy
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cfgstastate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cfgstastate=1;
        }
    case 1:
        /*if(!ESP8266_Send_AT_Cmd((char*)cmd_at_reset,"ready",NULL,500))
        {
            return -2;
        }*/
        rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_reset,NULL,NULL,500);
        if(rvlen==0xffff)
        {//busy
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cfgstastate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cfgstastate=2;
            cfgstatime=HAL_GetTick();
        }
    case 2:
        temp=HAL_GetTick();
        if(temp<cfgstatime)cfgstatime=temp;
        if(temp-cfgstatime<2000)
        {
            return 0;
        }
        cfgstastate=3;
    case 3:
        rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_mode_query,"OK",(char*)ans_at_modequery_ap,500);
        if(rvlen==0xffff)
        {//busy
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cfgstastate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cfgstastate=4;
        }
    default:
        cfgstastate=0;
        break;
    }
    return 1;
}

int Wifi_ConfigSta_1(void)
{
    static int cfgstastate=0;
    static uint32_t cfgstatime=0;
    int rvlen=0;
    uint32_t temp=0;

    switch(cfgstastate)
    {
    case 0:
        rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_modecur_sta,"OK",NULL,500);
        if(rvlen==0xffff)
        {//busy
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cfgstastate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cfgstastate=1;
        }
    case 1:
        rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_mode_query,"OK",(char*)ans_at_modequery_sta,500);
        if(rvlen==0xffff)
        {//busy
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cfgstastate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cfgstastate=4;
        }
    default:
        cfgstastate=0;
        break;
    }
    return 1;
}

int Wifi_ConfigSta(void)
{
    static int cfgstastate=0;
    static uint32_t cfgstatime=0;
    int rvlen=0;
    uint32_t temp=0;

    switch(cfgstastate)
    {
    case 0:
        rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_modedef_sta,"OK",NULL,500);
        if(rvlen==0xffff)
        {//busy
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cfgstastate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cfgstastate=1;
        }
    case 1:
        /*if(!ESP8266_Send_AT_Cmd((char*)cmd_at_reset,"ready",NULL,500))
        {
            return -2;
        }*/
        rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_reset,NULL,NULL,500);
        if(rvlen==0xffff)
        {//busy
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cfgstastate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cfgstastate=2;
            cfgstatime=HAL_GetTick();
        }
    case 2:
        temp=HAL_GetTick();
        if(temp<cfgstatime)cfgstatime=temp;
        if(temp-cfgstatime<2000)
        {
            return 0;
        }
        cfgstastate=3;
    case 3:
        rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_mode_query,"OK",(char*)ans_at_modequery_sta,500);
        if(rvlen==0xffff)
        {//busy
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cfgstastate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cfgstastate=4;
        }
    default:
        cfgstastate=0;
        break;
    }
    return 1;
}


int Wifi_ConnectAp(void)
{
    static int cntapstate=0;
    int rvlen=0;
    switch(cntapstate)
    {
    case 0:
        //rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_joinap_cur,"OK",(char*)ans_at_joinap,5000);
        sprintf((char*)wifiTempBuf,cmd_at_joinap_cur_part,wifiConfig.name,wifiConfig.password);
        rvlen = ESP8266_Send_AT_Cmd((char*)wifiTempBuf,"OK",(char*)ans_at_joinap,5000);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cntapstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cntapstate=1;
            /*if(!ESP8266_Send_AT_Cmd((char*)cmd_at_dhcpdef_staon,"OK",NULL,500))
            {
                return -3;
            }*/
        }
    case 1:
        rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_staip_query, "OK", (char*)ans_at_staip_query, 1500);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cntapstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cntapstate=2;
        }
    case 2:
        rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_ip_mux_single, "OK", NULL, 3000);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cntapstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cntapstate=2;
        }
    default:
        cntapstate=0;
        break;
    }

    return 1;
}

int Wifi_CreateAp(void)
{
    static int cntapstate=0;
    int rvlen=0;
    switch(cntapstate)
    {
    case 0:
        sprintf((char*)wifiTempBuf,cmd_at_setap_cur_part,wifiConfig.name,dwsConfig.address,wifiConfig.password);
        rvlen = ESP8266_Send_AT_Cmd((char*)wifiTempBuf,"OK",NULL, 5000);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cntapstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cntapstate=1;
            /*if(!ESP8266_Send_AT_Cmd((char*)cmd_at_dhcpdef_staon,"OK",NULL,500))
            {
                return -3;
            }*/
        }
    case 1:
        rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_apaddr_cur, "OK", NULL, 1500);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cntapstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cntapstate=2;
        }
    case 2:
        sprintf((char*)wifiTempBuf,cmd_at_dhcps_cur_part,wifiServer.ip,wifiServer.ip);
        rvlen = ESP8266_Send_AT_Cmd((char*)wifiTempBuf,"OK",NULL, 1500);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cntapstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cntapstate=3;
        }
    case 3:
        rvlen = ESP8266_Send_AT_Cmd((char*)cmd_at_ip_mux_single, "OK", NULL, 3000);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cntapstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cntapstate=2;
        }
    default:
        cntapstate=0;
        break;
    }

    return 1;
}


int Wifi_ConnectTcp(void)
{
    static int cnttcpstate=0;
    int rvlen=0;
    switch(cnttcpstate)
    {
    case 2:
        //rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_ip_ping,"OK",NULL,100);
        sprintf((char*)wifiTempBuf,cmd_at_ip_ping_part,wifiServer.ip);
        rvlen=ESP8266_Send_AT_Cmd((char*)wifiTempBuf,"OK",NULL,100);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cnttcpstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cnttcpstate=1;
        }
    case 0:
        //rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_ip_start_tcp,"OK",(char*)ans_at_ip_start,8000);
        sprintf((char*)wifiTempBuf,cmd_at_ip_start_tcp_part,wifiServer.ip,wifiServer.port);
        rvlen=ESP8266_Send_AT_Cmd((char*)wifiTempBuf,"OK",(char*)ans_at_ip_start,5000);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cnttcpstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cnttcpstate=1;
        }
    default:
        cnttcpstate=0;
        break;
    }
    return 1;
}

int Wifi_ConnectUdp(void)
{
    static int cnttcpstate=0;
    int rvlen=0;
    switch(cnttcpstate)
    {
    case 2:
        //rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_ip_ping,"OK",NULL,100);
        sprintf((char*)wifiTempBuf,cmd_at_ip_ping_part,wifiServer.ip);
        rvlen=ESP8266_Send_AT_Cmd((char*)wifiTempBuf,"OK",NULL,100);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cnttcpstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cnttcpstate=1;
        }
    case 0:
        //rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_ip_start_tcp,"OK",(char*)ans_at_ip_start,8000);
        sprintf((char*)wifiTempBuf,cmd_at_ip_start_udp_part,wifiServer.ip,wifiServer.port);
        rvlen=ESP8266_Send_AT_Cmd((char*)wifiTempBuf,"OK",(char*)ans_at_ip_start,5000);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            cnttcpstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            cnttcpstate=1;
        }
    default:
        cnttcpstate=0;
        break;
    }
    return 1;
}

int Wifi_DisconnectTcp(void)
{
    if(!ESP8266_Send_AT_Cmd((char*)cmd_at_ip_close,"OK",NULL,500))
    {
        return -1;
    }

    return 0;
}

int Wifi_EnterTransparentMode(void)
{
    static int entertransparentstate=0;
    int rvlen=0;
    switch(entertransparentstate)
    {
    case 0:
        rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_ip_mode_query,"OK",(char*)ans_at_ip_transp_mode,500);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            entertransparentstate=1;
            return 0;
        }
        else if(rvlen==1)//
        {
            entertransparentstate=2;
            return 0;
        }
    case 1:
        rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_ip_enter_transp,"OK",NULL,500);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            entertransparentstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            entertransparentstate=2;
        }
    case 2:
        rvlen=ESP8266_Send_AT_Cmd((char*)cmd_at_ip_start_trans,NULL,NULL,500);
        if(rvlen==0xffff)
        {
            return 0;
        }
        else if(rvlen==0)
        {//failed
            entertransparentstate=0;
            return -1;
        }
        else if(rvlen==1)//Reconnect
        {
            entertransparentstate=3;
        }
    default:
        entertransparentstate=0;
        break;
    }
    return 1;
}


int Wifi_ExitTransparentMode(void)
{
    int ret;
    do
    {
        ret = Wifi_Uart_Send((uint8_t *)cmd_at_ip_exit_trans, strlen(cmd_at_ip_exit_trans),0);
    }while( ret!=0 );

    if(!ESP8266_Send_AT_Cmd((char*)cmd_at, "OK",NULL, 500))
    {
        return -1;
    }

    return 0;
}

int Wifi_Restore(void)
{
    if(!ESP8266_Send_AT_Cmd((char*)cmd_at_restore,NULL,NULL,10))
    {
        return -1;
    }

    return 0;
}



int Wifi_SendData(uint8_t* buf, int len)
{
    if(buf==NULL || len <=0)return -1;

    int ret;
    if(len>RTXBUFLEN)len=RTXBUFLEN;
#if (WIFI_TRANSPARENT_ENABLED==0)
    //strcpy((char*)wifiTempBuf, cmd_at_ip_clrbuf_single);
    do
    {
        //ret = ESP8266_Send_AT_Cmd((char*)wifiTempBuf,NULL,"OK",0);
        ret = ESP8266_Send_AT_Cmd((char*)cmd_at_ip_clrbuf_single,NULL,"OK",0);
    }while( ret > 1 );
    sprintf((char*)wifiTempBuf, "%s%d", cmd_at_ip_send_package, len);
    do
    {
        ret = ESP8266_Send_AT_Cmd((char*)wifiTempBuf,(char*)ans_at_ip_start_trans,"OK",0);
    }while( ret > 1 );
#endif
    //memset((void*)wifiTxBuf, 0, RTXBUFLEN);
    //memcpy((void*)wifiTxBuf, buf, len);
    //BSP_WDG_Clear();
    do
    {
        ret = Wifi_Uart_Send((uint8_t*)buf, len, 0);
    }while( ret!=0 );
    //BSP_WDG_Clear();
/*#if (WIFI_TRANSPARENT_ENABLED==0)
    strcpy((char*)wifiTempBuf, cmd_at_ip_clrbuf_single);
    do
    {
        ret = ESP8266_Send_AT_Cmd((char*)wifiTempBuf,NULL,"OK",0);
    }while( ret > 1 );
#endif*/
    return ret > 0;
}

int Wifi_ReceiveData(uint8_t* buf, int len)
{
    static int recvState=0;
    if(buf==NULL || len <=0)return -1;

    if(recvState==0)
    {
        if(len>RTXBUFLEN)len=RTXBUFLEN;
        memset((void*)buf, 0, len);
        recvState=1;
    }
    int ret = Wifi_Uart_Receive(buf, len, 100);
    if(ret!=0)
    {
        recvState=0;
    }
    return ret;
}