bool SendMtkBinCmd(u8 *strCmd)
{
        int len = 0,ret = 0;
        unsigned char outBuffer[256];
    
	// At initial, the protocol setting of the communication UART is supposed to be PMTK protocol.
	// Since EPO data are transferred using MTK Binary Packet, you have to change the protocol setting to MTK Binary Protocol
	// before starting EPO Transfer Protocol. You can use PMTK command 253 to change the UART protocol setting.
	// Please refer to 7.1 for the details of PMTK command 253.

        Ql_memset(outBuffer,0,sizeof(outBuffer));                
        Ql_memcpy((void *)outBuffer, strCmd, Ql_strlen(strCmd));
        len = Ql_strlen(outBuffer);
        outBuffer[len++] = 0x0D;
        outBuffer[len++] = 0x0A;
        outBuffer[len] = '\0';   
   
	/*send the data of outBuffer to the GPS module example L70 ect. */
        ret = Ql_UART_Write(m_gnssUartPort,outBuffer,len);
        if (ret < len)
        {
            APP_DEBUG("SendMtkBinCmd Only part of bytes are written, %d/%d \r\n", ret, len);
            return FALSE;
        }
        
        return TRUE;	

}
static s32 ReadSerialPort(Enum_SerialPort port, /*[out]*/u8* pBuffer, /*[in]*/u32 bufLen)
{
    s32 rdLen = 0;
    s32 rdTotalLen = 0;
    int loopi = 0;
    if (NULL == pBuffer || 0 == bufLen)
    {
        return -1;
    }
    Ql_memset(pBuffer, 0x0, bufLen);
    while (1)
    {
        rdLen = Ql_UART_Read(port, pBuffer + rdTotalLen, bufLen - rdTotalLen);       
        if (rdLen <= 0)  // All data is read out, or Serial Port Error!
        {
            break;
        }
        rdTotalLen += rdLen;
        // Continue to read...
    }
    if (rdLen < 0) // Serial Port Error!
    {
        APP_DEBUG("Fail to read from port[%d]\r\n", port);
        return -99;
    }
    return rdTotalLen;
}
void callback_socket_read(s32 socketId, s32 errCode, void* customParam )
{
    s32 ret;
    if(errCode)
    {
        APP_DEBUG("<--CallBack: socket read failure,(sock=%d,error=%d)-->\r\n",socketId,errCode);
        APP_DEBUG("<-- Close socket.-->\r\n");
        Ql_SOC_Close(socketId);
        m_socketid = -1;
        if(errCode == SOC_BEARER_FAIL)  
        {
            m_tcp_state = STATE_GPRS_DEACTIVATE;
        }
        else
        {
            m_tcp_state = STATE_GPRS_GET_DNSADDRESS;
        }  
        return;
    }


    Ql_memset(m_recv_buf, 0, RECV_BUFFER_LEN);
    do
    {
        ret = Ql_SOC_Recv(socketId, m_recv_buf, RECV_BUFFER_LEN);

        if((ret < 0) && (ret != -2))
        {
            APP_DEBUG("<-- Receive data failure,ret=%d.-->\r\n",ret);
            APP_DEBUG("<-- Close socket.-->\r\n");
            Ql_SOC_Close(socketId); //you can close this socket  
            m_socketid = -1;
            m_tcp_state = STATE_SOC_CREATE;
            break;
        }
        else if(ret == -2)
        {
            //wait next CallBack_socket_read
            break;
        }
        else if(ret < RECV_BUFFER_LEN)
        {
            APP_DEBUG("<--Receive data from sock(%d),len(%d):%s\r\n",socketId,ret,m_recv_buf);
            break;
        }else if(ret == RECV_BUFFER_LEN)
        {
            APP_DEBUG("<--Receive data from sock(%d),len(%d):%s\r\n",socketId,ret,m_recv_buf);
        }
    }while(1);
}
void custom_at_handler(void)
{
    char *p=NULL;
    AT_Response response = INVAT;
    u8 off;

    if (!pData)
        return;

    p = pData;
    response = parse_at_response(&off);
    p+=off;

    switch(response)
    {
        case CPIN:
        {
            if (Ql_strncmp(p," READY",6)==0)
            {
                Ql_sprintf((char *)buffer,"\r\nCPIN is ready\r\n");
                Ql_SendToUart(ql_uart_port1, (u8*)buffer,Ql_strlen(buffer));
                Ql_sprintf((char *)buffer,"\r\nSet timer for 5 second\r\n");
                Ql_SendToUart(ql_uart_port1, (u8*)buffer,Ql_strlen(buffer));
                
                timer.timeoutPeriod = Ql_SecondToTicks(5);
                Ql_StartTimer(&timer);
                
            }else if (Ql_strncmp(p," SIM PIN",8)==0)
            {
                Ql_sprintf((char *)buffer,"\r\nSIM PIN is needed\r\n");
                Ql_SendToUart(ql_uart_port1, (u8*)buffer,Ql_strlen(buffer));
                
                Ql_memset(atbuffer,0,100);
                Ql_sprintf((char *)atbuffer,"AT+CPIN=1234\n");
                Ql_SendToModem(ql_md_port1,atbuffer,Ql_strlen((char *)atbuffer));    
            }
            break;
        }
        
        default:
            break;
    }
}
void page_response(HttpHeader *header){
	bool reset=FALSE;
	bool prepare=TRUE;
    char* action=header->action;
    OUTD("action=%s",action);
	Ql_memset(__data_buf,0,4096);
	Ql_memset(__s_buf,0,10240);
    
    if (Ql_strstr(header->action, "/")) {
		get_main_page( __est_connection ? "System state is start":"System state stop");
        OUTD("main page",NULL);
	}
	else if (Ql_strstr(action,"reboot")) {
		get_rebot_page();
		reset=TRUE;
	}
	else if (Ql_strstr(action,"settings?")) {
		char* pch=NULL;
		char* last=NULL;
		//OUTD("parse setting action:%s",pch);
		pch=strtok_r(action+9,"&",&last);
	  //OUTD("parse command:%s",pch);
     while (pch!=NULL) {
        setCommand(pch);
        pch=strtok_r(NULL,"&",&last);
		//OUTD("parse command:%s",pch);
    }
	
     WriteSettings();
	 ReadSettings();
	 get_main_page("Save settings controller is OK");
	}
	else if (Ql_strstr(action,"date?")) {
		bool sdt=SetLocDate(action+5);
		get_main_page(sdt ? "Set date and time is OK":"Error set date and time");
	}
	else if (Ql_strstr(action,"stop")) {
		StopEstConnection();
		get_main_page("Recive command Stop");
	}
	else if (Ql_strstr(action,"run")) {
		nSTATE=STATE_EST_SOCKET_CREATE;
		get_main_page("Recive command Start");
	}
	else if (Ql_strstr(action,"log")) {
		u16 size=0;
		ReadLogFile(&size);
		Ql_sprintf(__s_buf,__download_page,size);
		//Ql_strcpy(&__s_buf[Ql_strlen(__s_buf)],__buf_log);
		
		Ql_memcpy(&__s_buf[Ql_strlen(__s_buf)],__buf_log,size);
		OUTD("__download_page:%d file size:%d buffer-len:%d",Ql_strlen(__download_page),size,Ql_strlen(__s_buf));
		
		prepare=FALSE;
	}
    else if (Ql_strstr(action, "autorize")) {
        Ql_sprintf(__s_buf,__autorize,0);
        prepare=FALSE;
        OUTD("set autorize",NULL);
    }
    else {
		get_error_page();
		Ql_sprintf(__s_buf,__error_page,0);
		prepare=FALSE;
	}
	if (prepare) {
        //if (header->set_cookie) {
          //   Ql_sprintf(__s_buf, __ok_page, Ql_strlen(__data_buf),"\r\nSet-Cookie: __ztp=987654321\r\n"); 
        //}
        Ql_sprintf(__s_buf, __ok_page, Ql_strlen(__data_buf)); 
		Ql_strcpy(&__s_buf[Ql_strlen(__s_buf)],__data_buf);
        OUTD("sbuf:%d dbuf:%d",Ql_strlen(__s_buf),Ql_strlen(__data_buf));
        
	}
	if (reset) {
		Ql_Sleep(10000);
		Ql_Reset(0);
	}
}
void CallBack_socket_read(u8 contexid, s8 sock, bool result, s32 error){
    u8 len=0;
    s32 index=0;
    s32 ret=0;
    //OUTLOG("resive from socket:%d",sock);
    //Ql_memset(__socketBuffer,0,LEN_SOCKET_BUFFER);
    //len=Ql_SocketRecv(sock,(u8*)&__socketBuffer[0],LEN_SOCKET_BUFFER);
	//if (len>0) {
		if (sock==__est_connector_socket) {
            Ql_memset(__socketBuffer,0,LEN_SOCKET_BUFFER);
            len=Ql_SocketRecv(sock,(u8*)&__socketBuffer[0],LEN_SOCKET_BUFFER);
            if (len>0) {
                unreplace(&__socketBuffer[0],len);
                if (!__waitConfirm){
                    nSTATE = STATE_SOCKET_SEND; 
                    __toSend=0;
                  Ql_StopGPTimer();
                }
                 __countRepeat=0;
                 __start_empty_tmr=Ql_GetRelativeTime();
            }
         }
        else{
           // __socketBuffer[len] = '\0'; 
           //read_request((char*)__socketBuffer, sock); 
            index=findClientBySockid(sock);

            ret=__client[index].read_handle_callback(contexid,sock,result,error,index);
            //OUTD("size recive:%d",ret);
            if (ret>0) {
                  if (__client[index].protocol==HTTP) {
                    if (parse_header((char*)__client[index].recvBuffer,(u32)__client[index].pRecvCurrentPos)) {
                        //OUTD("header:%s",__client[index].recvBuffer);
                        if (__header.method==GET) {
                           if (!__header.authorization) {
                                    Ql_strcpy(__header.action,"autorize");
                           }
                           page_response(); 
                            __client[index].send_handle(sock,__s_buf);
                        }
                        else if (__header.method==POST) {
                                OUTD("len:%d",__header.length);
                          }
                      }
                   }
                   else if (__client[index].protocol==STREAM) {
                       OUTD("stream",NULL);
                        Ql_SendToUart(ql_uart_port3,__client[index].recvBuffer,ret);
                    }
                   else if ( __client[index].protocol==UPGRADE) {
                        s32 init=0;
                        int pp=(u16)(__client[index].pRecvCurrentPos);
                        if (Ql_strstr((char*)&__client[index].recvBuffer[pp-3],"END")) {
                            OUTD("end file is:%s",&__client[index].recvBuffer[pp]);
                            init = Ql_Fota_App_Write_Data(ret-3, (s8 *)__client[index].recvBuffer);
                            OUTD("write fota:%d", init); 
                            init=Ql_Fota_App_Finish();
                            __client[index].send_handle(sock,init==0 ? "0":"1");
                            OUTD("finish write:%d", init); 
                            if (init==0) {
                                init=Ql_Fota_Update();
                            }
                        }
                        else{
                            init = Ql_Fota_App_Write_Data(ret, (s8 *)__client[index].recvBuffer);
                            __client[index].send_handle(sock,init==0 ? "0":"1");
                            OUTD("fota write:%d", init); 
                        }
                }
            }
        }
}
void ql_entry()
{
    bool           keepGoing = TRUE;
    QlEventBuffer  flSignalBuffer;
    s32 period = 10;

    Ql_DebugTrace("at: ql_entry\r\n");
    
    Ql_SetDebugMode(BASIC_MODE);   
    Ql_OpenModemPort(ql_md_port1);       

    Ql_memset(atbuffer,0,100);
    //Ql_sprintf((char *)atbuffer,"AT+QLOCPU=0\n");
    Ql_sprintf((char *)atbuffer,"AT+CPIN?\n");
    Ql_SendToModem(ql_md_port1,atbuffer,Ql_strlen((char*)atbuffer));    
         
    while(keepGoing)
    {    
        Ql_GetEvent(&flSignalBuffer);
        switch(flSignalBuffer.eventType)
        {
            case EVENT_TIMER:
            {
                Ql_sprintf((char *)buffer,"\r\nTimer expired\r\n");
                Ql_SendToUart(ql_uart_port1, (u8*)buffer,Ql_strlen(buffer));

                Ql_memset(atbuffer,0,100);
                Ql_sprintf((char *)atbuffer,"AT+QAUDCH=1\n");
                Ql_SendToModem(ql_md_port1,atbuffer,Ql_strlen((char *)atbuffer));
                //Ql_PlayAudio(QL_AUDIO_EMS_TADA,0);    
                
                break;
            }
            
            case EVENT_MODEMDATA:
            {                
                Ql_DebugTrace("\r\nEVENT_MODEMDATA type=%d \r\n",flSignalBuffer.eventData.modemdata_evt.type);
                if (flSignalBuffer.eventData.modemdata_evt.type==DATA_AT)
                {
                    pData = (char*)flSignalBuffer.eventData.modemdata_evt.data;
                    custom_at_handler();            
                }
                break;
            }
            
            case EVENT_UARTDATA:
            {            
                Ql_DebugTrace("\r\nEVENT_UARTDATA PORT=%d\r\n",flSignalBuffer.eventData.uartdata_evt.port);
                Ql_DebugTrace("\r\nuart data =%s\r\n",flSignalBuffer.eventData.uartdata_evt.data);        
                break;            
            }
            
            case EVENT_SERIALSTATUS:
            {
                bool val = flSignalBuffer.eventData.portstatus_evt.val;
                u8 port = flSignalBuffer.eventData.portstatus_evt.port;
                u8 type = flSignalBuffer.eventData.portstatus_evt.type;

                Ql_DebugTrace("EVENT_SERIALSTATUS port=%d type=%d val=%d\r\n",port,type,val);
                break;
            }
            
            default:
                break;
        }
    }
}
static void CallBack_UART_Hdlr(Enum_SerialPort port, Enum_UARTEventType msg, bool level, void* customizedPara)
{
    //APP_DEBUG("CallBack_UART_Hdlr: port=%d, event=%d, level=%d, p=%x\r\n", port, msg, level, customizedPara);
    u32 rdLen=0;
    s32 ret;
    char *pData= NULL;
    char *p=NULL;
    char *p1=NULL;
    char *p2=NULL;
    bool    bRet = FALSE;
    
    switch (msg)
    {
        case EVENT_UART_READY_TO_READ:
        {
            if(UART_PORT1 == port)
            {  
                do
                {                   
                    Ql_memset(m_RxBuf_mcuUart, 0x0, sizeof(m_RxBuf_mcuUart));
                    rdLen = Ql_UART_Read(port, m_RxBuf_mcuUart, sizeof(m_RxBuf_mcuUart));
                    pData = m_RxBuf_mcuUart;
                    /*set last tail data eq 0*/
                    pData[rdLen + 1] = '\0';                    
                   
                    /*cmd: DEPO*/
                    p = Ql_strstr(pData,"DEPO");                    
                    if (p)
                    {
                        APP_DEBUG(textBuf,"\r\nDEPO \r\n");
                        bRet = SendMtkBinCmd("$PMTK253,1,0*37");
                        if(!bRet)
                        {
                            APP_DEBUG(textBuf,"\r\n Send $PMTK Error \r\n");
                            break;
                        }
                        else
                        {
                            bRet = VerifyFileAndSendFirstEpoPacket(s_s8FilePath);
                             if(!bRet)
                            {
                                APP_DEBUG(textBuf,"\r\n VerifyFile Error \r\n");                                
                                break;
                            }
                             else
                             {
                                APP_DEBUG(textBuf,"Update EPO Progress Start £º\r\n");
                             }
                        }
                        break;
                    }

                    
                    /*cmd:  QueryAvailableStorage=UFS*/
                    p = Ql_strstr(pData,"QueryAvailableStorage");
                    if (p)
                    {
                        if(Ql_strstr(pData,"=UFS"))
                        {
                            s64 size;
                            size = Ql_FS_GetFreeSpace(1);        // UFS
                            APP_DEBUG(textBuf,"QueryAvailableStorage=%lld\r\n",size);   
                                    
                        }else if(Ql_strstr(pData,"=SD"))
                        {
                            s64 size;
                            size = Ql_FS_GetFreeSpace(2);  //SD
                            APP_DEBUG(textBuf,"QueryAvailableStorage=%lld\r\n",size); 
                        }else if(Ql_strstr(pData,"=RAM"))
                        {
                            s64 size;
                            size = Ql_FS_GetFreeSpace(3);  //RAM
                            APP_DEBUG(textBuf,"QueryAvailableStorage=%lld\r\n",size); 
                        }else
                        {
                            APP_DEBUG(textBuf,"QueryAvailableStorage param error!\r\n"); 
                        }
                        break;
                    }
                    
                    /*cmd: WriteFile=password.txt*/
                    p = Ql_strstr(pData,"WriteFile=");
                    if (p)
                    {
                        s32 s32Res = -1;
                        u32 uiFlag = 0;
                        u32 i=0;
                        char stmpdir[100],dir[100];
                        char *p1[100];
                        //u32 filesize = 10240;
                        u32 filesize = 276480;

                        p = Ql_strstr(pData, "=");
                        (*p) = '\0';
                        p++;

                        Ql_memset(s_s8FilePath, 0, sizeof(s_s8FilePath));  //File Name
                        Ql_strcpy((char *)s_s8FilePath, p);

                        uiFlag |= QL_FS_READ_WRITE;
                        uiFlag |= QL_FS_CREATE;

                        flag = 1;                     

                        if(Ql_strncmp((char*)s_s8FilePath,"RAM:",4))
                        {
                            ret = Ql_FS_Open((u8*)s_s8FilePath, uiFlag);
                            
                        }
                        else
                        {
                           ret = Ql_FS_OpenRAMFile((u8*)s_s8FilePath, uiFlag,filesize); 
                        }
                        if(ret >= QL_RET_OK)
                        {
                            filehandle = ret;
                        }

                        APP_DEBUG(textBuf,"filehandle=%d\r\n",filehandle);

                        break;
                    }


                    //Receiving data and StopWrite
                    if (flag)
                    {

                        u32 writeedlen;
                        p = Ql_strstr(pData,"StopWrite");
                        if (p)
                        {
                            Ql_FS_Close(filehandle);
                            filehandle = -1;
                            flag =0;
                            APP_DEBUG(textBuf,"Ql_WriteFinish()\r\n");

                            break;
                        }
                        ret = Ql_FS_Write(filehandle, (u8*)pData, rdLen, &writeedlen);
                        if(ret== QL_RET_OK)
                        {
                            //APP_DEBUG(textBuf,"Ql_File()=%d: writeedlen=%d,Download times=%d\r\n",ret, writeedlen,flag++);

                        }else if(ret == QL_RET_ERR_FILEDISKFULL)
                        {
                            Ql_FS_Close(filehandle);
                            filehandle = -1;
                            flag =0;
                            APP_DEBUG(textBuf,"Storage Full,close file! ret=%d\r\n",ret);
                            break;
                        }else
                        {
                            Ql_FS_Close(filehandle);
                            filehandle = -1;
                            flag =0;
                            APP_DEBUG(textBuf,"write error,close file!ret=%d \r\n",ret);
                            break;
                        }
                    }                                
                   

                    /*cmd: AT Command*/

                    if (Ql_strstr(pData,"AT")||Ql_strstr(pData,"at") || Ql_strstr(pData,"At") || Ql_strstr(pData,"aT"))
                    {
                        //APP_DEBUG(textBuf,"%s", pData);
                        Ql_UART_Write(VIRTUAL_PORT1,(u8*)pData,rdLen);
                        
                        break;
                    }
                    
                }while(rdLen > 0);

            }
            else if(UART_PORT3 == port)
            {
                s32 totalBytes = ReadSerialPort(port, m_RxBuf_gnssUART, sizeof(m_RxBuf_gnssUART));                
                if (totalBytes <= 0)
                {
                    APP_DEBUG("<-- No data in gnssUART buffer! -->\r\n");
                    return;
                }
                
                 ReadAckAndSendEpoPacket(m_RxBuf_gnssUART,totalBytes);

            }   
           else if((VIRTUAL_PORT1 == port) || (VIRTUAL_PORT2 == port))
            {
                s32 ret,totalBytes;

                totalBytes = ReadSerialPort(port, m_RxBuf_VirtualPort, sizeof(m_RxBuf_VirtualPort));
                if (totalBytes <= 0)
                {
                    APP_DEBUG("<-- No data in virtural UART buffer! -->\r\n");
                    return;
                }
                Ql_UART_Write(UART_PORT1,(u8*)m_RxBuf_VirtualPort,totalBytes);

            }
            
            break;
        }
        default:
            break;
    }
}
void ql_entry(void)
{
    s32 ret;
    bool keepGoing = TRUE;
    bool isContinued = FALSE;
    u32 cnt = 0; 
    
    Ql_DebugTrace("OpenCPU: Hello TTS !\r\n\r\n");    /* Print out messages through DEBUG port */
    Ql_SetDebugMode(BASIC_MODE);    /* Only after the device reboots, 
                                     *  the set debug-mode takes effect. 
                                     */

    // Initialize TTS, and register callback function
    Ql_TTS_Initialize(&Callback_TTS_Play);
    
    while(keepGoing)
    {
        Ql_GetEvent(&g_event);
        switch(g_event.eventType)
        {
            case EVENT_UARTDATA:
            {
                // TODO: receive and handle data from UART
                ascii* pChar;
                s16  strLen;
                PortData_Event* pDataEvt = (PortData_Event*)&g_event.eventData.uartdata_evt;

                /* Change audio path (Command: audio path=0/1/2)
                *  0 = the main audio path
                *  1 = earphone audio path
                *  2 = loudspeaker audio path
                */ 
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "audio path=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u8 audPath;
                    char* p1;
                    char* p2;
                    Ql_DebugTrace((char*)pDataEvt->data);
                    p1 = Ql_strstr((char*)pDataEvt->data, "=");
                    p2 = Ql_strstr((char*)pDataEvt->data, "\r\n");
                    Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                    memcpy(g_buffer, p1 + 1, p2 - p1 -1);
                    if (Ql_strcmp(g_buffer, "1") == 0)
                    {
                        audPath = QL_AUDIO_PATH_HEADSET;
                    }
                    else if (Ql_strcmp(g_buffer, "2") == 0)
                    {
                        audPath = QL_AUDIO_PATH_LOUDSPEAKER;
                    }
                    else
                    {
                        audPath = QL_AUDIO_PATH_NORMAL;
                    }
                    if (!Ql_VoiceCallChangePath(audPath))
                    {
                        Ql_DebugTrace("Fail to change audio path.\r\n");
                    }
                    else
                    {
                        Ql_DebugTrace("Change audio path to %d.\r\n", audPath);
                    }
                    break;
                }

                // Start tts speech (Command: start tts=...)
                strLen = Ql_sprintf(g_buffer, "start tts=");
                ret = Ql_strncmp((char*)pDataEvt->data, g_buffer, strLen);
                if (0 == ret)
                {
                    char* pCh = NULL;
                    pCh = Ql_strstr((char*)pDataEvt->data, "=");
                    if (pCh != NULL)
                    {
                        Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                        Ql_strncpy(g_buffer, pCh + 1, pDataEvt->len - (pCh - (char*)pDataEvt->data + 1) - 2);
                        Ql_DebugTrace("Ql_TTS_Play(), len=%d\r\n", Ql_strlen(g_buffer));
                        ret = Ql_TTS_Play((u8*)g_buffer, sizeof(g_buffer));
                        if (ret < 0)
                        {
                            Ql_DebugTrace("Fail to play TTS.\r\n");
                            break;
                        }
                        else
                        {
                            Ql_DebugTrace("Playing finished.\r\n");
                        }
                    }
                    break;
                }
                
                // Stop TTS (Command: stop tts)
                Ql_memset(g_buffer, 0x0, Ql_strlen(g_buffer));
                strLen = Ql_sprintf(g_buffer, "stop tts\r\n");
                ret = Ql_strncmp((char*)pDataEvt->data, g_buffer, strLen);
                if (0 == ret)
                {
                    Ql_DebugTrace(g_buffer);
                    Ql_TTS_Stop();
                    break;
                }
                
                // Query TTS' status (Command: tts?)
                Ql_memset(g_buffer, 0x0, Ql_strlen(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts?\r\n");
                ret = Ql_strncmp((char*)pDataEvt->data, g_buffer, strLen);
                if (0 == ret)
                {
                    Ql_DebugTrace(g_buffer);
                    ret = Ql_TTS_Query();
                    switch (ret)
                    {
                    	case TTS_STATUS_IDLE:
                            Ql_DebugTrace("TTS: idle\r\n");
                    	    break;
                    	case TTS_STATUS_PLAYING:
                    	    Ql_DebugTrace("TTS: playing\r\n");
                    	    break;
                    	default:
                    	    Ql_DebugTrace("Fail to query TTS' status. Error code: %d\r\n", ret);
                    	    break;
                    }
                    break;
                }

                // Set volume (Command: tts vol=0..100)
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts vol=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u8 ttsVol;
                    char* p1;
                    char* p2;
                    Ql_DebugTrace((char*)pDataEvt->data);
                    p1 = Ql_strstr((char*)pDataEvt->data, "=");
                    p2 = Ql_strstr((char*)pDataEvt->data, "\r\n");
                    Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                    memcpy(g_buffer, p1 + 1, p2 - p1 -1);
                    ttsVol = Ql_atoi(g_buffer);
                    ttsVol = (ttsVol > 100) ? 100 : ttsVol;
                    Ql_SetVolume_Ex(VOL_TYPE_MEDIA, QL_AUDIO_PATH_HEADSET, ttsVol);
                    break;
                }
                
               // Set TTS Style 
               // Set TTS fastest voice speed
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts Style1=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u32 ret;
                    ret = Ql_TTS_SetStyle(TTS_PARAM_VOICE_SPEED,TTS_SPEED_MAX);
                    Ql_DebugTrace("Set TTS fastest voice speed.\r\n");
                    break;
                }
                // Set TTS minimized volume.
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts Style2=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u32 ret;
                    ret = Ql_TTS_SetStyle(TTS_PARAM_VOLUME,TTS_VOLUME_MIN);
                    Ql_DebugTrace("Set TTS minimized volume.\r\n");
                    break;
                }
                // Set TTS voice effect --eccentric
                Ql_memset(g_buffer, 0x0, sizeof(g_buffer));
                strLen = Ql_sprintf(g_buffer, "tts Style3=");
                pChar = Ql_strstr((char*)pDataEvt->data, g_buffer);
                if (pChar)
                {
                    u32 ret;
                    ret = Ql_TTS_SetStyle(TTS_PARAM_VEMODE,TTS_VEMODE_ECCENTRIC);
                    Ql_DebugTrace("Set TTS voice effect --eccentric.\r\n");
                    break;
                }
            }

            /*************************************
            *  'Case' another EVENT if needed.
            *
            **************************************/
            
            default:
                break;
        }
    }
}
bool VerifyFileAndSendFirstEpoPacket(u8 *strFilePath)
{
    int ret = 0,filesize = 0;
    int sendLen = 0;
        
    if((strFilePath == NULL) || (Ql_strlen(strFilePath) == 0))
    {
         APP_DEBUG("VerifyFileAndSendFirstEpoPacket, strFilePath %s \r\n", strFilePath);             
        return FALSE;
    }
    ret = Ql_FS_Check((char*)strFilePath);
    if(ret != QL_RET_OK)
    {
        APP_DEBUG("Ql_FS_Check, strFilePath %s error \r\n", strFilePath);            
        return FALSE;
    }
    filesize = Ql_FS_GetSize((char*)strFilePath);       
    if(filesize < 0)
    {
        APP_DEBUG("Ql_FS_GetSize, filesize %d error \r\n ", filesize);            
        return FALSE;
    }       
    if (Ql_strncmp((char*)strFilePath,"RAM:", 4))
    {
        g_pEpoFile = Ql_FS_Open((char*)strFilePath, QL_FS_READ_ONLY);
    }
    else
    {
        g_pEpoFile = Ql_FS_OpenRAMFile((char*)strFilePath, QL_FS_READ_ONLY, filesize);
    }        
    // Read in the EPO file, and then verify the validity of EPO data. If the input EPO file is not in valid MTK EPO format, the
    // programmer shall terminate the process.
    if(g_pEpoFile < 0)
    {
        Ql_FS_Close(g_pEpoFile);
        APP_DEBUG("Ql_FS_OpenRAMFile, g_pEpoFile %d error \r\n ", g_pEpoFile);            
        return FALSE;
    }
    else
    {
        if (!fgEPO_Verify_File(g_pEpoFile))
        {
            Ql_FS_Close(g_pEpoFile);
            APP_DEBUG("fgEPO_Verify_File, g_pEpoFile %d error \r\n", g_pEpoFile);                    
            return FALSE;
        }
    }                    
    // Get total number of MTK_BIN_EPO packets that will be sent.
    g_i4NumSvEpoPkt =  i2EPO_Get_Num_Pkt(g_pEpoFile);       
    // Start EPO Data Transfer Protocol to send EPO data
    // fgEPO_Get_One_Pkt takes out three SAT data from the EPO file and encapsulated them in a MTK_BIN_EPO packet
    // with appropriate EPO SEQ number.
    // In order to save the total transferring time, we suggest to generate current EPO packet first, and then wait for
    // MTK_BIN_ACK_EPO acknowledge of the previous MTK_BIN_EPO packet from the GPS receiver.
    // The function fgEPO_Get_One_Pkt must be implemented by the programmer.
    g_u2LastEpoSeq = 0;
    g_u2EpoSeq = 0;
    Ql_memset(g_szPktData,0,sizeof(g_szPktData));
    if (fgEPO_Get_One_Pkt(g_u2EpoSeq, g_pEpoFile, g_szPktData))
    {
        sendLen =  MTKBIN_3EPO_PKT_LNG;
        ret = Ql_UART_Write(m_gnssUartPort,g_szPktData,sendLen);
        if (ret < sendLen)
        {
            APP_DEBUG("VerifyFileAndSendFirstEpoPacket Only part of bytes are written, %d/%d \r\n", ret, sendLen);            
            return FALSE;
        }
        // Update sequence number
        g_u2LastEpoSeq = g_u2EpoSeq;
        g_u2EpoSeq++;
        return TRUE;
    }
    else
    {
        APP_DEBUG("VerifyFileAndSendFirstEpoPacket fgEPO_Get_One_Pkt error \r\n");
        return FALSE;
    }

}
static void proc_handle(char *pData,s32 len)
{
    char *p = NULL;
    char parambuf[100];

    //command: Reset=<type>
    p = Ql_strstr(pData,"Reset=");
    if (p)
    {
        Ql_memset(parambuf, 0, 100);
        if (Analyse_Command(pData, 1, '>', parambuf))
        {
            APP_DEBUG("<--Parameter Error.-->\r\n");
            return;
        }

        if (Ql_atoi(parambuf) != 0)//must be 0
        {
            APP_DEBUG("<--Parameter Error.-->\r\n");
            return;
        }

        APP_DEBUG("<--Set Reset Parameter Successfully<%d>.-->\r\n",Ql_atoi(parambuf));
        Ql_Sleep(100);
        Ql_Reset(Ql_atoi(parambuf));
        return;
    }

    //command: Sleep=<msec>
    p = Ql_strstr(pData,"Sleep=");
    if (p)
    {
        s32 ret;
        ST_Time time,*tm;
        Ql_memset(parambuf, 0, 100);
        if (Analyse_Command(pData, 1, '>', parambuf))
        {
            APP_DEBUG("<--Parameter Error.-->\r\n");
            return;
        }

        APP_DEBUG("<--Set Sleep Parameter Successfully<%d>.-->\r\n",Ql_atoi(parambuf));
        APP_DEBUG("<--Start sleeping-->\r\n");

        Ql_Sleep(Ql_atoi(parambuf));
        APP_DEBUG("<--sleeping over-->\r\n");

        return;
    }

    //command: Read Module UID
    p = Ql_strstr(pData,"Read Module UID");
    if (p)
    {
        s32 i, uidLen;
        u8 moduleUID[100];
        u8 tmpbuf[100];

        Ql_memset(moduleUID, 0, sizeof(moduleUID));
        Ql_memset(tmpbuf, 0, sizeof(tmpbuf));

        uidLen = Ql_GetUID(moduleUID, sizeof(moduleUID));
        for (i = 0; i < uidLen; i++)
        {
            Ql_sprintf(tmpbuf + i*2, "%02X", moduleUID[i]);
        }
        APP_DEBUG("<--Module UID=0x%s,len=%d-->\r\n", tmpbuf, uidLen);
        return;
    }

    //command: Get Core Version
    p = Ql_strstr(pData,"Get Core Version");
    if (p)
    {
        s32 ret;
        u8 tmpbuf[100];

        Ql_memset(tmpbuf, 0, sizeof(tmpbuf));
        ret = Ql_GetCoreVer((u8*)tmpbuf, sizeof(tmpbuf));
        if(ret > 0)
        {
            APP_DEBUG("<--Core Version:%s-->\r\n", tmpbuf);
        } else
        {
            APP_DEBUG("<--Get Core Version Failure.-->\r\n");
        }
        return;
    }

    //command: Get SDK Version
    p = Ql_strstr(pData,"Get SDK Version");
    if (p)
    {
        s32 ret;
        u8 tmpbuf[100];

        Ql_memset(tmpbuf, 0, sizeof(tmpbuf));
        ret = Ql_GetSDKVer((u8*)tmpbuf, sizeof(tmpbuf));
        if(ret > 0)
        {
            APP_DEBUG("<--SDK Version:%s.-->\r\n", tmpbuf);
        } else
        {
            APP_DEBUG("<--Get SDK Version Failure.-->\r\n");
        }
        return;
    }

    //command: Get Ms Since PwrOn
    p = Ql_strstr(pData,"Get Ms Since PwrOn");
    if (p)
    {
        u64 totalMS;
        totalMS = Ql_GetMsSincePwrOn();

        APP_DEBUG("<--Get Ms Since PwrOn:=%lld.-->\r\n", totalMS);

        return;
    }

//command: Ql_SleepEnable  set the module into sleep mod
    p= Ql_strstr(pData,"Ql_SleepEnable");
    if(p)
    {
        s32 ret;
        APP_DEBUG("<-- Ql_SleepEnable=%d -->\r\n", ret);
        ret = Ql_SleepEnable();
        return;
    }

//
    p= Ql_strstr(pData,"Ql_SleepDisable");
    if(p)
    {
        s32 ret;
        APP_DEBUG("<-- Ql_SleepDisable=%d -->\r\n", ret);
        ret = Ql_SleepDisable();
        return;
    }

    //command:Ql_SecureData_Store=<n> , n=1~13.
    p= Ql_strstr(pData,"Ql_SecureData_Store=");
    if(p)
    {
        s32 ret;
        u8 index;

        Ql_memset(parambuf, 0, 100);
        if (Analyse_Command(pData, 1, '>', parambuf))
        {
            APP_DEBUG("<--Parameter Error.-->\r\n");
            return;
        }

        index = Ql_atoi(parambuf);
        if(index <1 || index >13)
        {
            APP_DEBUG("<--Parameter n Error.-->\r\n");
            return;
        }
        ret = Ql_SecureData_Store(index, (u8*)&test,sizeof(test));
        APP_DEBUG("<-- Ql_SecureData_Store(index=%d, value=%d, data size=%d)=%d -->\r\n", index,test.reset.Period,sizeof(Global_SYS_Cfg),ret);
        return;
    }

    //command:Ql_SecureData_Read=<n> , n=1~13.
    p= Ql_strstr(pData,"Ql_SecureData_Read=");
    if(p)
    {
        s32 ret;
        u8 index;

        Ql_memset(parambuf, 0, 100);
        if (Analyse_Command(pData, 1, '>', parambuf))
        {
            APP_DEBUG("<--Parameter Error.-->\r\n");
            return;
        }

        index = Ql_atoi(parambuf);
        if(index <1 || index >13)
        {
            APP_DEBUG("<--Parameter n Error.-->\r\n");
            return;
        }
        ret = Ql_SecureData_Read(index, (u8*)&tempTest,sizeof(Global_SYS_Cfg));
        APP_DEBUG("<-- Ql_SecureData_Read =%d \r\n test.version:%s test.data=%s  test.reset.timeDelay =%d-->\r\n",ret, tempTest.version,tempTest.data,tempTest.reset.timeDelay);
        return;
    }
    return;
}
bool parse_header(void *clients,HttpHeader *http_header){
	char *param;
	char *value;
	char *last;
	char *ph;
	char* bon_val = NULL;
	char header[1024 * 2];
    char*lens=NULL;
    QlClient *client=(QlClient*)clients;
	char* head = Ql_strstr((char*)client->recvBuffer, "\r\n\r\n");
	if (head) {
       
        http_header->set_cookie=FALSE;
        http_header->authorization=FALSE;
        Ql_memset(http_header->action,0,100);
        Ql_memset(http_header->boundary,0,200);
        Ql_memset(http_header->cookie,0,200);
        Ql_memset(http_header->data,0,10 * 1024);
        http_header->length=0;
         Ql_strcpy(http_header->cookie, "NONE"); 
		int head_len = (char*)head - ((char*)client->recvBuffer);
		int body_len = (int)(client->pRecvCurrentPos) - head_len - 4;
		Ql_memcpy(header, client->recvBuffer, head_len);
		ph = strtok_r(header, "\r\n", &last);
		char* lst;
		if (Ql_strstr(ph, "GET")!=NULL)
		{
			char* act = strtok_r(ph+4, " ", &lst);
			if (Ql_strlen(act)>1) 
                Ql_strcpy(http_header->action, act+1); 
            else
                Ql_strcpy(http_header->action, act); 
			http_header->method = GET;
            OUTD("action:%s",http_header->action);
		}
		if (Ql_strstr(ph, "POST")!=NULL) {
			http_header->method = POST;
			char* act = strtok_r(ph+5, " ", &lst);
            if (Ql_strlen(act)>1) 
                Ql_strcpy(http_header->action, act+1); 
            else
                Ql_strcpy(http_header->action, act); 
		}
		while (1)
		{
			ph = strtok_r(NULL, "\r", &last);
			if (ph == NULL) {
				return TRUE;
			}
			param = strtok_r(ph + 1, ":", &value);
			if (Ql_strstr(param, "Content-Type")) {
				char* bon = Ql_strstr(value, "boundary");
				bon_val = bon + 9;
				Ql_strcpy(http_header->boundary, bon_val);
			}
			else if ((lens = Ql_strstr(param, "Cookie"))!=NULL)
			{
                char* cookie;
                if ((cookie=Ql_strstr(value,"__ztp"))!=NULL) {
                    Ql_strcpy(http_header->cookie, cookie+6); 
                    http_header->authorization=TRUE;
                    http_header->set_cookie=FALSE;
                }
			}
			else if ((lens = Ql_strstr(param, "Content-Length"))!=NULL) {
				char* slen = lens + 16;
				int len_head = Ql_atoi(slen);
				http_header->length = len_head;
				if (len_head == body_len){
					OUTD("data full",NULL);
                }
                else
                {
                    OUTD("not full data.wait:%d have:%d", len_head, body_len);
                    return FALSE;
                }
              }
            else if ((lens = Ql_strstr(param, "Authorization"))!=NULL) {
                /*char* slen = lens + 21;
                unsigned char dbuf[50];
                Ql_memset(dbuf,0,50);
                decode_b64((unsigned char*)slen,dbuf);
                OUTD("decode buf:%s",dbuf);
                param = strtok_r((char*)dbuf, ":", &value);
                if (Ql_strstr(param,"admin") && Ql_strstr(value,"admin")) {
                    OUTD("Autorization user:%s pswd:%s",param,value);
                    http_header->authorization=TRUE;
                    http_header->set_cookie=TRUE;
                }*/
            }
        }
		}
	else
	{
        return FALSE;
	}
}
void ql_entry(void)
{
    bool keepGoing = TRUE;
    s32 ret;
    s32 i;
    char notes[50];
    
    OUT_DEBUG(debug_buffer,"sms: ql_entry\r\n");
    Ql_SetDebugMode(ADVANCE_MODE);
    Ql_OpenModemPort(ql_md_port1);
    Ql_SMS_Callback cb_func={CallBack_NewSMS,CallBack_SendSMS,CallBack_DeleteSMS,                 //public
                                       CallBack_ReadPDUSMS,CallBack_NewFlashPDUSMS,CallBack_PDUStatusReport,               //pdu
                                       CallBack_ReadTextSMS,CallBack_NewFlashTextSMS,CallBack_TextStatusReport};           //text
    ret=Ql_SMSInitialize(&cb_func);
    
    OUT_DEBUG(debug_buffer,"\r\nQl_SMSInitialize=%d\r\n",ret);
    //OUT_DEBUG(debug_buffer,"CallBack_ReadPDUSMS=%X\r\n",CallBack_ReadPDUSMS);
    while(keepGoing)
    {    
        Ql_GetEvent(&g_event);
        switch(g_event.eventType)
        {
            case EVENT_MODEMDATA:
            {
                //TODO: receive and hanle data from CORE through virtual modem port
                PortData_Event* pPortEvt = (PortData_Event*)&g_event.eventData.modemdata_evt;
                OUT_DEBUG(debug_buffer,"%s", pPortEvt->data);
                break;
            }
            
            case EVENT_UARTDATA:
            {
                char* pChar=NULL;
                char* pChar2=NULL;
                PortData_Event* pDataEvt = (PortData_Event*)&g_event.eventData.uartdata_evt;

                //Ql_SetSMSStorage=(0-3)
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_SetSMSStorage=");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u8 storage;
                    pChar+=17;
                    storage=Ql_atoi(pChar);
                    ret=Ql_SetSMSStorage(storage);
                    OUT_DEBUG(debug_buffer,"\r\nQl_SetSMSStorage(storage=%d)=%d\r\n",storage,ret);
                    break;
                }
                
                //Ql_GetSMSStorageInfo
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_GetSMSStorageInfo");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u8 current_mem,used,total;
                    ret=Ql_GetSMSStorageInfo(&current_mem, &used, &total);
                    OUT_DEBUG(debug_buffer,"\r\nQl_GetSMSStorageInfo(current_mem=%d,used=%d,total=%d)=%d\r\n",
                                                            current_mem,used,total,ret);
                    break;
                }

                //Ql_SetInfoCentreNum="<sca number>" eg:Ql_SetInfoCentreNum="+8613800551500"
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_SetInfoCentreNum=\"");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    pChar+=21;
                    pChar2 = Ql_strstr(pChar,"\"");
                    *pChar2=0; 
                    ret=Ql_SetInfoCentreNum((u8*)pChar);
                    OUT_DEBUG(debug_buffer,"\r\nQl_SetInfoCentreNum(sca_num=%s)=%d\r\n", pChar,ret);
                    break;
                }
                
                //Ql_GetInfoCentreNum
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_GetInfoCentreNum");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u8 sca_number[40];
                    u8 type;
                    ret=Ql_GetInfoCentreNum(sca_number,&type);
                    OUT_DEBUG(debug_buffer,"\r\nQl_GetInfoCentreNum(sca_number=\"%s\",type=%d)=%d\r\n",
                                                            sca_number,type,ret);
                    break;
                }
                
                //Ql_SetNewSMSDirectToTE=(0,1)
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_SetNewSMSDirectToTE=");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u8 op;
                    pChar+=23;
                    op=Ql_atoi(pChar);
                    ret=Ql_SetNewSMSDirectToTE(op);
                    OUT_DEBUG(debug_buffer,"\r\nQl_SetNewSMSDirectToTE(op=%d)=%d\r\n",op,ret);
                    break;
                }

                //Ql_SetSMSFormat=(0,1)
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_SetSMSFormat=");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u8 format;
                    pChar+=16;
                    format=Ql_atoi(pChar);
                    ret=Ql_SetSMSFormat(format);
                    OUT_DEBUG(debug_buffer,"\r\nQl_SetSMSFormat(format=%d)=%d\r\n",format,ret);
                    break;
                }

                //Ql_ReadSMS=(1,300),(0,1)
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_ReadSMS=");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u16 index;
                    u8 mode;
                    pChar+=11;
                    index=Ql_atoi(pChar);
                    pChar=Ql_strstr(pChar, ",");
                    pChar++;
                    mode=Ql_atoi(pChar);
                    ret=Ql_ReadSMS(index,mode);
                    OUT_DEBUG(debug_buffer,"\r\nQl_ReadSMS(index=%d,mode=%d)=%d\r\n",index,mode,ret);
                    break;
                }
                 
                //Ql_DeleteSMS=(1,300),(0,4)
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_DeleteSMS=");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u16 index;
                    u8 flag;
                    pChar+=13;
                    index=Ql_atoi(pChar);
                    pChar=Ql_strstr(pChar, ",");
                    pChar++;
                    flag=Ql_atoi(pChar);
                    ret=Ql_DeleteSMS(index,flag);
                    OUT_DEBUG(debug_buffer,"\r\nQl_DeleteSMS(index=%d,flag=%d)=%d\r\n",index,flag,ret);
                    break;
                }

                //Ql_ListSMS=(0,4)
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_ListSMS=");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u8 by_status;
                    u16 sms_count=0;                    
                    QlSMSListNode sms_list[MAX_LIST_NODE_COUNT];  //MAX_LIST_NODE_COUNT should be set large enough
                    pChar+=11;
                    by_status=Ql_atoi(pChar);
                    
                    ret=Ql_ListSMS(sms_list, MAX_LIST_NODE_COUNT, by_status, &sms_count);
                    OUT_DEBUG(debug_buffer,"\r\nQl_ListSMS(by_status=%d,node_count=%d,sms_count=%d)=%d\r\n",
                        by_status,MAX_LIST_NODE_COUNT,sms_count,ret);
                    if(0==ret)
                    {
                        for(i=0;i<sms_count;i++)
                        {
                            OUT_DEBUG(debug_buffer,"index=%d,status=%d\r\n",sms_list[i].index,sms_list[i].status);
                        }
                    }
                    break;
                }

                //Ql_GetUnReadSMS=(0,1)
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_GetUnReadSMS=");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u8 mode;
                    pChar+=16;
                    mode=Ql_atoi(pChar);
                    ret=Ql_GetUnReadSMS(mode);
                    OUT_DEBUG(debug_buffer,"\r\nQl_GetUnReadSMS(mode=%d)=%d\r\n",mode,ret);
                    break;
                }
                
                //Ql_SendPDUSMS
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_SendPDUSMS");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u8 pdu_len;
                    u8 pdu_string[]={0x00,       //Set aside for SCA
                                                 0x31,      //FO
                                                 0xff,      //Set aside for MR   
                                                 /*
                                                 0x05,      //DA Length
                                                 0x81,      //DA type
                                                 0x01,      
                                                 0x80,
                                                 0xf6,      //DA:10086
                                                 */
                                                 0x0b,     //DA Length
                                                 0x81,     //DA type
                                                 0x31,
                                                 0x58,
                                                 0x15,
                                                 0x64,
                                                 0x79,
                                                 0xf3,    //DA:13855146973
                                                 
                                                 0x00,      //PID
                                                 0x00,      //DCS
                                                 0x47,      //VP
                                                 0x07,      //UDH
                                                 0xd1,
                                                 0x7a,
                                                 0x79,
                                                 0x4c,
                                                 0x2f,
                                                 0xb3,
                                                 0x01      //UD:Quectel, GSM 7-bit coding
                                             };
                    pdu_len=sizeof(pdu_string);
                    
                    ret=Ql_SendPDUSMS(pdu_string,pdu_len);
                    OUT_DEBUG(debug_buffer,"\r\nQl_SendPDUSMS(pdu_len=%d)=%d\r\n",pdu_len,ret);
                    if(0==ret)
                    {
                        for(i=0;i<pdu_len;i++)
                        {
                            OUT_DEBUG(debug_buffer,"%02X",pdu_string[i]);
                        }
                        OUT_DEBUG(debug_buffer,"\r\n");
                    }
                    break;
                }
                           

                //Ql_SetTextSMSPara=(0-2),(0,1),(0,1)
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_SetTextSMSPara=");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    u8 chset,isflashsms,status_report;
                    pChar+=18;
                    chset=Ql_atoi(pChar);
                    pChar=Ql_strstr(pChar, ",");
                    pChar++;
                    isflashsms=Ql_atoi(pChar);
                    pChar=Ql_strstr(pChar, ",");
                    pChar++;
                    status_report=Ql_atoi(pChar);
                    
                    ret=Ql_SetTextSMSPara(chset, isflashsms, status_report);
                    OUT_DEBUG(debug_buffer,
                       "\r\nQl_SetTextSMSPara(chset=%d,isflashsms=%d,status_report=%d)=%d\r\n",chset,isflashsms,status_report,ret);
                    break;
                }
                
                //Ql_SendTextSMS="<phone number>"
                Ql_memset(notes, 0x0, sizeof(notes));
                Ql_sprintf(notes, "Ql_SendTextSMS=\"");
                pChar = Ql_strstr((char*)pDataEvt->data, notes);
                if (NULL != pChar)
                {
                    pChar+=16;
                    pChar2 = Ql_strstr(pChar,"\"");
                    *pChar2=0; 
                    ret=Ql_SendTextSMS((u8*)pChar,(u8*)"Welcome to use Quectel module!",
                        Ql_strlen((u8*)"Welcome to use Quectel module!"));
                    OUT_DEBUG(debug_buffer, "\r\nQl_SendTextSMS(phone_num=\"%s\")=%d\r\n",pChar,ret);
                    break;
                }
                
                Ql_SendToModem(ql_md_port1, (u8*)pDataEvt->data, pDataEvt->len);
                break;
            }
            default:
                break;
        }
    }
}
static void Callback_Timer(u32 timerId, void* param)
{
    if (TIMEOUT_90S_TIMER_ID == timerId)
    {
        APP_DEBUG("<--90s time out!!!-->\r\n");
        APP_DEBUG("<-- Close socket.-->\r\n");
        
        Ql_SOC_Close(m_socketid);
        m_socketid = -1;

        m_tcp_state = STATE_GPRS_DEACTIVATE;

        timeout_90S_monitor = FALSE;
    }
    else if (TCP_TIMER_ID == timerId)
    {
        //APP_DEBUG("<--...........m_tcp_state=%d..................-->\r\n",m_tcp_state);
        switch (m_tcp_state)
        {
            case STATE_NW_GET_SIMSTATE:
            {
                s32 simStat = 0;
                //if (Ql_NW_GetSIMCardState()== Ql_SIM_NORMAL)
                RIL_NW_GetSIMCardState(&simStat);
                if (simStat == SIM_STAT_READY)
                {
                    m_tcp_state = STATE_NW_QUERY_STATE;
                    APP_DEBUG("<--SIM card status is normal!-->\r\n");
                }else
                {
                //    Ql_Timer_Stop(TCP_TIMER_ID);
                    APP_DEBUG("<--SIM card status is unnormal!-->\r\n");
                }
                break;
            }        
            case STATE_NW_QUERY_STATE:
            {
                s32 creg = 0;
                s32 cgreg = 0;
                //Ql_NW_GetNetworkState(&creg, &cgreg);
                ret = RIL_NW_GetGSMState(&creg);
                ret = RIL_NW_GetGPRSState(&cgreg);
                APP_DEBUG("<--Network State:creg=%d,cgreg=%d-->\r\n",creg,cgreg);
                if((cgreg == NW_STAT_REGISTERED)||(cgreg == NW_STAT_REGISTERED_ROAMING))
                {
                    m_tcp_state = STATE_GPRS_REGISTER;
                }
                break;
            }
            case STATE_GPRS_REGISTER:
            {
                ret = Ql_GPRS_Register(0, &callback_gprs_func, NULL);
                if (GPRS_PDP_SUCCESS == ret)
                {
                    APP_DEBUG("<--Register GPRS callback function successfully.-->\r\n");
                    m_tcp_state = STATE_GPRS_CONFIG;
                }else if (GPRS_PDP_ALREADY == ret)
                {
                    APP_DEBUG("<--GPRS callback function has already been registered,ret=%d.-->\r\n",ret);
                    m_tcp_state = STATE_GPRS_CONFIG;
                }else
                {
                    APP_DEBUG("<--Register GPRS callback function failure,ret=%d.-->\r\n",ret);
                }
                break;
            }
            case STATE_GPRS_CONFIG:
            {
                Ql_strcpy(m_gprsCfg.apnName, m_apn);
                Ql_strcpy(m_gprsCfg.apnUserId, m_userid);
                Ql_strcpy(m_gprsCfg.apnPasswd, m_passwd);
                m_gprsCfg.authtype = 0;
                ret = Ql_GPRS_Config(0, &m_gprsCfg);
                if (GPRS_PDP_SUCCESS == ret)
                {
                    APP_DEBUG("<--configure GPRS param successfully.-->\r\n");
                }else
                {
                    APP_DEBUG("<--configure GPRS param failure,ret=%d.-->\r\n",ret);
                }
                
                m_tcp_state = STATE_GPRS_ACTIVATE;
                break;
            }
            case STATE_GPRS_ACTIVATE:
            {
                m_tcp_state = STATE_GPRS_ACTIVATING;
                ret = Ql_GPRS_Activate(0);
                if (ret == GPRS_PDP_SUCCESS)
                {
                    APP_DEBUG("<--Activate GPRS successfully.-->\r\n");
                    m_tcp_state = STATE_GPRS_GET_DNSADDRESS;
                }else if (ret == GPRS_PDP_WOULDBLOCK)
                {
                     APP_DEBUG("<--Waiting for the result of GPRS activated.,ret=%d.-->\r\n",ret);
                    //waiting Callback_GPRS_Actived
                }else if (ret == GPRS_PDP_ALREADY)
                {
                    APP_DEBUG("<--GPRS has already been activated,ret=%d.-->\r\n",ret);
                    m_tcp_state = STATE_GPRS_GET_DNSADDRESS;
                }else//error
                {
                    APP_DEBUG("<--Activate GPRS failure,ret=%d.-->\r\n",ret);
                    m_tcp_state = STATE_GPRS_ACTIVATE;
                }
                break;
            }
            case STATE_GPRS_GET_DNSADDRESS:
            {            
                u8 primaryAddr[16] = {0};
                u8 bkAddr[16] = {0};
                ret =Ql_GPRS_GetDNSAddress(0, (u32*)primaryAddr,  (u32*)bkAddr);
                if (ret == GPRS_PDP_SUCCESS)
                {
                    APP_DEBUG("<--Get DNS address successfully,primaryAddr=%d.%d.%d.%d,bkAddr=%d.%d.%d.%d-->\r\n",primaryAddr[0],primaryAddr[1],primaryAddr[2],primaryAddr[3],bkAddr[0],bkAddr[1],bkAddr[2],bkAddr[3]);            
                    m_tcp_state = STATE_GPRS_GET_LOCALIP;
                }else
                {
                     APP_DEBUG("<--Get DNS address failure,ret=%d.-->\r\n",ret);
                    m_tcp_state = STATE_GPRS_DEACTIVATE;
                }
                break;
            }
            case STATE_GPRS_GET_LOCALIP:
            {
                u8 ip_addr[5];
                Ql_memset(ip_addr, 0, 5);
                ret = Ql_GPRS_GetLocalIPAddress(0, (u32 *)ip_addr);
                if (ret == GPRS_PDP_SUCCESS)
                {
                    APP_DEBUG("<--Get Local Ip successfully,Local Ip=%d.%d.%d.%d-->\r\n",ip_addr[0],ip_addr[1],ip_addr[2],ip_addr[3]);
                    m_tcp_state = STATE_CHACK_SRVADDR;
                }else
                {
                    APP_DEBUG("<--Get Local Ip failure,ret=%d.-->\r\n",ret);
                }
                break;
            }
            case STATE_CHACK_SRVADDR:
            {
                Ql_memset(m_ipaddress,0,5);
                ret = Ql_IpHelper_ConvertIpAddr(m_SrvADDR, (u32 *)m_ipaddress);
                if(ret == SOC_SUCCESS) // ip address, xxx.xxx.xxx.xxx
                {
                    APP_DEBUG("<--Convert Ip Address successfully,m_ipaddress=%d,%d,%d,%d-->\r\n",m_ipaddress[0],m_ipaddress[1],m_ipaddress[2],m_ipaddress[3]);
                    m_tcp_state = STATE_SOC_REGISTER;
                    
                }else  //domain name
                {
                    ret = Ql_IpHelper_GetIPByHostName(0, 0, m_SrvADDR, Callback_GetIpByName);
                    if(ret == SOC_SUCCESS)
                    {
                        APP_DEBUG("<--Get ip by hostname successfully.-->\r\n");
                    }
                    else if(ret == SOC_WOULDBLOCK)
                    {
                        APP_DEBUG("<--Waiting for the result of Getting ip by hostname,ret=%d.-->\r\n",ret);
                        //waiting CallBack_getipbyname
                    }
                    else
                    {
                        APP_DEBUG("<--Get ip by hostname failure:ret=%d-->\r\n",ret);
                        if(ret == SOC_BEARER_FAIL)  
                        {
                             m_tcp_state = STATE_GPRS_DEACTIVATE;
                        }
                        else
                        {
                             m_tcp_state = STATE_GPRS_GET_DNSADDRESS;
                        } 
                    }
                }
                break;
            }
            case STATE_SOC_REGISTER:
            {
                ret = Ql_SOC_Register(callback_soc_func, NULL);
                if (SOC_SUCCESS == ret)
                {
                    APP_DEBUG("<--Register socket callback function successfully.-->\r\n");
                    m_tcp_state = STATE_SOC_CREATE;
                }else if (SOC_ALREADY == ret)
                {
                    APP_DEBUG("<--Socket callback function has already been registered,ret=%d.-->\r\n",ret);
                    m_tcp_state = STATE_SOC_CREATE;
                }else
                {
                    APP_DEBUG("<--Register Socket callback function failure,ret=%d.-->\r\n",ret);
                }
                break;
            }
            case STATE_SOC_CREATE:
            {
                m_socketid = Ql_SOC_Create(0, SOC_TYPE_TCP);
                if (m_socketid >= 0)
                {
                    APP_DEBUG("<--Create socket id successfully,socketid=%d.-->\r\n",m_socketid);
                    m_tcp_state = STATE_SOC_CONNECT;
                }else
                {
                    APP_DEBUG("<--Create socket id failure,error=%d.-->\r\n",m_socketid);
                }
                break;
            }
            case STATE_SOC_CONNECT:
            {
                m_tcp_state = STATE_SOC_CONNECTING;
                ret = Ql_SOC_Connect(m_socketid,(u32) m_ipaddress, m_SrvPort);
                if(ret == SOC_SUCCESS)
                {
                    APP_DEBUG("<--The socket is already connected.-->\r\n");
                    m_tcp_state = STATE_SOC_SEND;
                    
                }else if(ret == SOC_WOULDBLOCK)
                {
                      if (!timeout_90S_monitor)//start timeout monitor
                      {
                        Ql_Timer_Start(TIMEOUT_90S_TIMER_ID, TIMEOUT_90S_PERIOD, FALSE);
                        timeout_90S_monitor = TRUE;
                      }
                      APP_DEBUG("<--Waiting for the result of socket connection,ret=%d.-->\r\n",ret);
                      //waiting CallBack_getipbyname
                      
                }else //error
                {
                    APP_DEBUG("<--Socket Connect failure,ret=%d.-->\r\n",ret);
                    APP_DEBUG("<-- Close socket.-->\r\n");
                    Ql_SOC_Close(m_socketid);
                    m_socketid = -1;
                    
                    if(ret == SOC_BEARER_FAIL)  
                    {
                        m_tcp_state = STATE_GPRS_DEACTIVATE;
                    }
                    else
                    {
                        m_tcp_state = STATE_GPRS_GET_DNSADDRESS;
                    }
                }
                break;
            }
            case STATE_SOC_SEND:
            {
                if (!Ql_strlen(m_send_buf))//no data need to send
                    break;
                
                m_tcp_state = STATE_SOC_SENDING;
                
                do
                {
                    ret = Ql_SOC_Send(m_socketid, m_pCurrentPos, m_remain_len);
                    APP_DEBUG("<--Send data,socketid=%d,number of bytes sent=%d-->\r\n",m_socketid,ret);
                    if(ret == m_remain_len)//send compelete
                    {
                        m_remain_len = 0;
                        m_pCurrentPos = NULL;
                        m_nSentLen += ret;
                        m_tcp_state = STATE_SOC_ACK;
                        break;
                    }
                    else if((ret <= 0) && (ret == SOC_WOULDBLOCK)) 
                    {
                        //waiting CallBack_socket_write, then send data;     
                        break;
                    }
                    else if(ret <= 0)
                    {
                        APP_DEBUG("<--Send data failure,ret=%d.-->\r\n",ret);
                        APP_DEBUG("<-- Close socket.-->\r\n");
                        Ql_SOC_Close(m_socketid);//error , Ql_SOC_Close
                        m_socketid = -1;

                        m_remain_len = 0;
                        m_pCurrentPos = NULL; 
                        if(ret == SOC_BEARER_FAIL)  
                        {
                            m_tcp_state = STATE_GPRS_DEACTIVATE;
                        }
                        else
                        {
                            m_tcp_state = STATE_GPRS_GET_DNSADDRESS;
                        }
                        break;
                    }
                    else if(ret < m_remain_len)//continue send, do not send all data
                    {
                        m_remain_len -= ret;
                        m_pCurrentPos += ret; 
                        m_nSentLen += ret;
                    }
                }while(1);
                break;
            }
            case STATE_SOC_ACK:
            {
                u64 ackedNumCurr;
                ret = Ql_SOC_GetAckNumber(m_socketid, &ackedNumCurr);
                if (ret < 0)
                {
                    checkErr_AckNumber(ret);
                }
                if (m_nSentLen == ackedNumCurr)
                {
                    if (timeout_90S_monitor) //stop timeout monitor
                    {
                        Ql_Timer_Stop(TIMEOUT_90S_TIMER_ID);
                        timeout_90S_monitor = FALSE;
                    }
                    
                    APP_DEBUG("<-- ACK Number:%llu/%llu. Server has received all data. -->\r\n\r\n", m_nSentLen, ackedNumCurr);

                    Ql_memset(m_send_buf,0,SEND_BUFFER_LEN);
                    m_tcp_state = STATE_SOC_SEND;
                }
                else
                {
                    if (!timeout_90S_monitor)//start timeout monitor
                    {
                        Ql_Timer_Start(TIMEOUT_90S_TIMER_ID, TIMEOUT_90S_PERIOD, FALSE);
                        timeout_90S_monitor = TRUE;
                    }
                    
                    APP_DEBUG("<-- ACK Number:%llu/%llu from socket[%d] -->\r\n", ackedNumCurr, m_nSentLen, m_socketid);
                }
                break;
            }
            case STATE_GPRS_DEACTIVATE:
            {
                APP_DEBUG("<--Deactivate GPRS.-->\r\n");
                Ql_GPRS_Deactivate(0);
                break;
            }
            default:
                break;
        }    
    }
}
static void proc_handle(char *pData,s32 len)
{
    char *p = NULL;
    s32 iret;
    u8 srvport[10];

    //command: Set_APN_Param=<APN>,<username>,<password>
    p = Ql_strstr(pData,"Set_APN_Param=");
    if (p)
    {
        Ql_memset(m_apn, 0, 10);
        if (Analyse_Command(pData, 1, '>', m_apn))
        {
            APP_DEBUG("<--APN Parameter Error.-->\r\n");
            return;
        }
        Ql_memset(m_userid, 0, 10);
        if (Analyse_Command(pData, 2, '>', m_userid))
        {
            APP_DEBUG("<--APN Username Parameter Error.-->\r\n");
            return;
        }
        Ql_memset(m_passwd, 0, 10);
        if (Analyse_Command(pData, 3, '>', m_passwd))
        {
            APP_DEBUG("<--APN Password Parameter Error.-->\r\n");
            return;
        }
        
        APP_DEBUG("<--Set APN Parameter Successfully<%s>,<%s>,<%s>.-->\r\n",m_apn,m_userid,m_passwd);

        return;
    }
    
    //command: Set_Srv_Param=<srv ip>,<srv port>
    p = Ql_strstr(pData,"Set_Srv_Param=");
    if (p)
    {
        Ql_memset(m_SrvADDR, 0, SRVADDR_BUFFER_LEN);
        if (Analyse_Command(pData, 1, '>', m_SrvADDR))
        {
            APP_DEBUG("<--Server Address Parameter Error.-->\r\n");
            return;
        }
        Ql_memset(srvport, 0, 10);
        if (Analyse_Command(pData, 2, '>', srvport))
        {
            APP_DEBUG("<--Server Port Parameter Error.-->\r\n");
            return;
        }
        m_SrvPort = Ql_atoi(srvport);
        APP_DEBUG("<--Set TCP Server Parameter Successfully<%s>,<%d>.-->\r\n",m_SrvADDR,m_SrvPort);

        m_tcp_state = STATE_NW_GET_SIMSTATE;
        APP_DEBUG("<--Restart the TCP connection process.-->\r\n");

        return;
    }

    //if not command,send it to server
    m_pCurrentPos = m_send_buf;
    Ql_strcpy(m_pCurrentPos + m_remain_len, pData);
    
    m_remain_len = Ql_strlen(m_pCurrentPos);
    
}
void ql_entry()
{
    bool           keepGoing = TRUE;
    QlEventBuffer  flSignalBuffer;
    char *p=NULL;
    char *p1=NULL;
    char *pData= NULL;

    Ql_memset(data_p, '*', DATA_LEN);
    
    data_p[0] = 'B';
    data_p[1] = 'e';
    data_p[2] = 'g';
    data_p[3] = 'i';
    data_p[4] = 'n';


    data_p[DATA_LEN-3] = 'E';
    data_p[DATA_LEN-2] = 'n';
    data_p[DATA_LEN-1] = 'D';

    Ql_SetDebugMode(BASIC_MODE);
    Ql_DebugTrace("tcpip: ql_entry\r\n");

    Ql_GprsNetworkInitialize(0,  0, &callback_func);
    Ql_GprsNetworkInitialize(1,  1, &callback_func);

    while(keepGoing)
    {    
        Ql_GetEvent(&flSignalBuffer);
        switch(flSignalBuffer.eventType)
        {
            case EVENT_UARTDATA:
            {
                pData = (char*)flSignalBuffer.eventData.uartdata_evt.data;
                pData[flSignalBuffer.eventData.uartdata_evt.len+1] = '\0';

                /*APNSet=0-1*/
                p = Ql_strstr(pData,"APNSet=");
                if (p)
                {
                    s32 ret;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    ret = Ql_GprsAPNSet(Ql_atoi(p), (u8*)"CMNET", (u8*)"", (u8*)"", CallBack_GprsAPNSet);
                    OUT_DEBUG(textBuf,"Ql_GprsAPNSet(%d)=%d\r\n",Ql_atoi(p),ret);
                    break;
                }

                /*APNGet=0-1*/
                p = Ql_strstr(pData,"APNGet=");
                if (p)
                {
                    s32 ret;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    ret = Ql_GprsAPNGet(Ql_atoi(p), CallBack_GprsAPNGet);
                    OUT_DEBUG(textBuf,"Ql_GprsAPNGet(%d)=%d\r\n",Ql_atoi(p),ret);
                    break;
                }

                /*NetworkActive=0-1*/
                p = Ql_strstr(pData,"NetworkActive=");
                if (p)
                {
                    s32 ret;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    ret = Ql_GprsNetworkActive(Ql_atoi(p));
                    OUT_DEBUG(textBuf,"Ql_GprsNetworkActive(contxtid=%d)=%d\r\n",Ql_atoi(p),ret);
                    break;
                }

                /*NetworkDeactive=0-1*/
                p = Ql_strstr(pData,"NetworkDeactive=");
                if (p)
                {
                    s32 ret;
                    p = Ql_strstr(pData,"=");
                    p += 1;

                    //you must close socket
                    if(socketonly[Ql_atoi(p)] >= 0)
                    {
                        Ql_SocketClose(socketonly[Ql_atoi(p)]);
                        socketonly[Ql_atoi(p)] = 0xFF;
                        send_dataLen[Ql_atoi(p)] = 0;
                    }
                    

                    if(udponly[Ql_atoi(p)] >= 0)
                    {
                        Ql_SocketClose(udponly[Ql_atoi(p)]);
                        udponly[Ql_atoi(p)] = 0xFF;
                        send_dataLen[Ql_atoi(p)] = 0;
                    }

                    ret = Ql_GprsNetworkDeactive(Ql_atoi(p));
                    OUT_DEBUG(textBuf,"Ql_GprsNetworkDeactive(contxtid=%d)=%d\r\n",Ql_atoi(p),ret);
                    break;
                }

                /*NetworkGetState=0-1*/
                p = Ql_strstr(pData,"NetworkGetState=");
                if (p)
                {
                    s32 ret;
                    OpenCpuNetWorkState_e networkstate;
                    u8 ps_status;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    ret = Ql_GprsNetworkGetState(Ql_atoi(p), &networkstate, &ps_status);
                    OUT_DEBUG(textBuf,"Ql_GprsNetworkGetState(contxtid=%d,networkstate=%d,ps_status=%d)=%d\r\n",Ql_atoi(p),networkstate,ps_status,ret);
                    break;
                }

                /*GetHostIpbyName=0-1,www.quectel.com*/
                p = Ql_strstr(pData,"GetHostIpbyName=");
                if (p)
                {
                    s32 ret;
                    OpenCpuNetWorkState_e networkstate;
                    u8 addr[4*5];
                    u8 addr_len = 0;
                    u8 out_entry_num;
                    u8 ps_status;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    p1 = Ql_strstr(pData,",");
                    *p1 = '\0';
                    p1 += 1;
                    ret = Ql_GetHostIpbyName(Ql_atoi(p), (u8*)p1, addr, &addr_len, 5, &out_entry_num, CallBack_getipbyname);
                    OUT_DEBUG(textBuf,"Ql_GetHostIpbyName(contxtid=%d,\"%s\")=%d\r\n",Ql_atoi(p),p1,ret);
                    if(ret == 0)
                    {
                        OUT_DEBUG(textBuf,"addr_len=%d,ip=%d.%d.%d.%d,out_entry_num=%d\r\n",addr_len, addr[0],addr[1],addr[2],addr[3],out_entry_num);
                    }
                    else if(ret == -2)
                    {
                        OUT_DEBUG(textBuf,"please wait CallBack_getipbyname\r\n");
                    }
                    else
                    {
                        OUT_DEBUG(textBuf,"Ql_GetHostIpbyName run error\r\n");
                    }

                    break;
                }

                /*socketcreate=0-1*/
                p = Ql_strstr(pData,"socketcreate=");   // tcp socket
                if (p)
                {
                    s32 ret;
                    OpenCpuNetWorkState_e networkstate;
                    u8 ps_status;
                    
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    ret = Ql_SocketCreate(Ql_atoi(p), 0);
                    OUT_DEBUG(textBuf,"Ql_SocketCreate(contxtid=%d)=%d\r\n",Ql_atoi(p),ret);
                    if(ret < 0)
                    {
                        OUT_DEBUG(textBuf,"failed to create socket\r\n");
                        break;
                    }

                   socketonly[Ql_atoi(p)] = ret;

                    ret = Ql_SocketConnect(ret, address, port);
                    OUT_DEBUG(textBuf,"Ql_SocketConnect(ip=%d,%d,%d,%d,port=%d)=%d\r\n",address[0],address[1],address[2],address[3],port,ret);
                    if(ret == 0)
                    {
                        OUT_DEBUG(textBuf,"Ql_SocketConnect connect successed\r\n");
                    }
                    else if(ret == -2)
                    {
                        OUT_DEBUG(textBuf,"please wait CallBack_socket_connect\r\n");
                    }
                    else
                    {
                        OUT_DEBUG(textBuf,"Ql_SocketConnect run error\r\n");
                    }
                    
                    break;
                }

                /*socketclose=0-1*/
                p = Ql_strstr(pData,"socketclose=");
                if (p)
                {
                    s32 ret;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    if(socketonly[Ql_atoi(p)] == 0xFF)
                    {
                        OUT_DEBUG(textBuf,"socket already close\r\n");
                        break;
                    }
                    ret = Ql_SocketClose(socketonly[Ql_atoi(p)]);
                    OUT_DEBUG(textBuf,"Ql_SocketClose(socket=%d)=%d\r\n",socketonly[Ql_atoi(p)],ret);
                    socketonly[Ql_atoi(p)] = 0xFF;
                    send_dataLen[Ql_atoi(p)] = 0;
                    break;
                }

                /*socketsend=0-1*/
                p = Ql_strstr(pData,"socketsend="); //tcp send
                if (p)
                {
                    s32 ret;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    if(socketonly[Ql_atoi(p)]  == 0xFF)
                    {
                        OUT_DEBUG(textBuf,"socket not create\r\n");
                        break;
                    }

                    if(send_dataLen[Ql_atoi(p)]  > 0)
                    {
                        OUT_DEBUG(textBuf,"socket now busy, sending\r\n");
                        break;
                    }
                    
                    send_dataLen[Ql_atoi(p)]  = 0;
                    dataLen[Ql_atoi(p)]  = DATA_LEN;
                    do
                    {
                        ret = Ql_SocketSend(socketonly[Ql_atoi(p)] , data_p + send_dataLen[Ql_atoi(p)]  ,dataLen[Ql_atoi(p)]  - send_dataLen[Ql_atoi(p)] );
                        OUT_DEBUG(textBuf,"Ql_SocketSend(socket=%d,dataLen=%d)=%d\r\n",socketonly[Ql_atoi(p)] ,dataLen[Ql_atoi(p)] ,ret);
                        if(ret == (dataLen[Ql_atoi(p)]  - send_dataLen[Ql_atoi(p)] ))
                        {
                            //send compelete
                            send_dataLen[Ql_atoi(p)]  = 0;
                            break;
                        }
                        else if((ret < 0) && (ret == -2)) 
                        {
                            //you must wait CallBack_socket_write, then send data;                                                    
                            break;
                        }
                        else if(ret < 0)
                        {
                            //error , Ql_SocketClose
                            Ql_SocketClose(socketonly[Ql_atoi(p)]);
                            socketonly[Ql_atoi(p)] = 0xFF;
                            send_dataLen[Ql_atoi(p)]  = 0;
                            break;
                        }
                        else if(ret <= dataLen[Ql_atoi(p)] )
                        {
                            send_dataLen[Ql_atoi(p)]  += ret;
                            //continue send
                        }
                    }while(1);
                    break;
                }

                /*socketack=*/
                p = Ql_strstr(pData,"socketack=");  // tcp ack
                if (p)
                {
                    s8 ret;
                    u64 ackedNum;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    if(socketonly[Ql_atoi(p)] == 0xFF)
                    {
                        OUT_DEBUG(textBuf,"socket not create\r\n");
                        break;
                    }
                    ret = Ql_SocketTcpAckNumber(socketonly[Ql_atoi(p)], &ackedNum);
                    OUT_DEBUG(textBuf,"Ql_SocketTcpAckNumber(socket=%d,ackedNum=%d)=%d\r\n",socketonly[Ql_atoi(p)],ackedNum,ret);
                    break;
                }
                
                /*udpcreate=0-1*/
                p = Ql_strstr(pData,"udpcreate="); //udp socket
                if (p)
                {
                    s32 ret;
                    OpenCpuNetWorkState_e networkstate;
                    u8 ps_status;
                    
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    ret = Ql_SocketCreate(Ql_atoi(p), 1);
                    OUT_DEBUG(textBuf,"Ql_SocketCreate(contxtid=%d)=%d\r\n",Ql_atoi(p),ret);
                    if(ret < 0)
                    {
                        OUT_DEBUG(textBuf,"failed to create socket\r\n");
                        break;
                    }
                    udponly[Ql_atoi(p)] = ret;
                    break;
                }

                /*udpclose=0-1*/
                p = Ql_strstr(pData,"udpclose=");
                if (p)
                {
                    s32 ret;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    if(udponly[Ql_atoi(p)] == 0xFF)
                    {
                        OUT_DEBUG(textBuf,"socket already close\r\n");
                        break;
                    }
                    ret = Ql_SocketClose(udponly[Ql_atoi(p)]);
                    OUT_DEBUG(textBuf,"Ql_SocketClose(socket=%d)=%d\r\n",udponly[Ql_atoi(p)],ret);
                    udponly[Ql_atoi(p)] = 0xFF;
                    send_dataLen[Ql_atoi(p)] = 0;
                    break;
                }

                /*SendHeartBeat*/
                p = Ql_strstr(pData,"SendHeartBeat");
                if (p)
                {
                    s32 ret;
                    ret = Ql_SwitchHeartBeat(1, 70, 15);
                    OUT_DEBUG(textBuf,"!!!!SET heart Beat =%d!!!!\r\n",ret);
                    break;
                }

                /*udpsend=0-1*/
                p = Ql_strstr(pData,"udpsend=");
                if (p)
                {
                    s32 ret;
                    p = Ql_strstr(pData,"=");
                    p += 1;
                    if(udponly[Ql_atoi(p)]  == 0xFF)
                    {
                        OUT_DEBUG(textBuf,"socket not create\r\n");
                        break;
                    }

                    if(send_dataLen[Ql_atoi(p)]  > 0)
                    {
                        OUT_DEBUG(textBuf,"socket now busy, sending\r\n");
                        break;
                    }
                    
                    send_dataLen[Ql_atoi(p)]  = 0;
                    dataLen[Ql_atoi(p)]  = DATA_LEN;
                    ret = Ql_SocketSendTo(udponly[Ql_atoi(p)], data_p, DATA_LEN, address, port);

                    OUT_DEBUG(textBuf,"Ql_SocketSendTo(socket=%d,dataLen=%d)=%d\r\n",udponly[Ql_atoi(p)] ,DATA_LEN ,ret);
                    if(ret == DATA_LEN)
                    {
                        //send success
                    }
                    else if(ret < 0)
                    {
                        //error , Ql_SocketClose
                        Ql_SocketClose(udponly[Ql_atoi(p)]);
                        udponly[Ql_atoi(p)] = 0xFF;
                        send_dataLen[Ql_atoi(p)]  = 0;
                        OUT_DEBUG(textBuf,"Ql_SocketSendTo send error\r\n");
                    }
                    else
                    {
                        //error , Ql_SocketClose
                        Ql_SocketClose(udponly[Ql_atoi(p)]);
                        udponly[Ql_atoi(p)] = 0xFF;
                        send_dataLen[Ql_atoi(p)]  = 0;
                        OUT_DEBUG(textBuf,"Ql_SocketSendTo send error\r\n");
                    }
                    break;
                }
                break;            
            }
            
            default:
                break;
        }
    }

    Ql_GprsNetworkUnInitialize(0);
    Ql_GprsNetworkUnInitialize(1);
}
void Customer_Lib_Interface1(void* dest, u8 value, u32 size)
{
	Ql_memset(dest, value, size);
}
Beispiel #18
0
static void CallBack_UART_Hdlr(Enum_SerialPort port, Enum_UARTEventType msg, bool level, void* customizedPara)
{
    u32 rdLen=0;
    s32 ret;
    char *p=NULL;
    char *p1=NULL;
    char *p2=NULL;
    u8 write_buffer[4]={'a','b','c','D'};
    u8 read_buffer[6]={0x00,0x00,0x00,0x00,0x00,0x00};
    u8 registerAdrr[2]={0x01,0x45};
    switch (msg)
    {
        case EVENT_UART_READY_TO_READ:
        {
            Ql_memset(m_Read_Buffer, 0x0, sizeof(m_Read_Buffer));
            rdLen = Ql_UART_Read(port, m_Read_Buffer, sizeof(m_Read_Buffer));

            //command-->Init the IIC , type 0 Лђеп 1.
            p = Ql_strstr(m_Read_Buffer,"Ql_IIC_Init=");
            if(p)
            {
                char* p1 = NULL;
                char* p2 = NULL;
                u8 NumberBuf[10];
                s8 IIC_type=0;
                p1 = Ql_strstr(m_Read_Buffer, "=");
                p2 = Ql_strstr(m_Read_Buffer, "\r\n");
                Ql_memset(NumberBuf, 0x0, sizeof(NumberBuf));
                Ql_memcpy(NumberBuf, p1 + 1, p2 - p1 -1);
                IIC_type = Ql_atoi(NumberBuf);
                if(0 == IIC_type)// simultion iic test, and we choose PINNAME_GPIO4, PINNAME_GPIO5 for IIC SCL and SDA pins
                {                    
                    ret = Ql_IIC_Init(0,PINNAME_CTS,PINNAME_RTS,0);
                    if(ret < 0)
                    {
                        APP_DEBUG("\r\n<--Failed!! Ql_IIC_Init channel 0 fail ret=%d-->\r\n",ret);
                        break;
                    }
                    APP_DEBUG("\r\n<--pins(%d & %d) Ql_IIC_Init channel 0 ret=%d-->\r\n",PINNAME_CTS,PINNAME_RTS,ret);
                    break;
                }
                else if(1 == IIC_type)// IIC controller
                {
                    ret = Ql_IIC_Init(1,PINNAME_RI,PINNAME_DCD,1);
                    if(ret < 0)
                    {
                        APP_DEBUG("\r\n<--Failed!! IIC controller Ql_IIC_Init channel 1 fail ret=%d-->\r\n",ret);
                        break;
                    }
                    APP_DEBUG("\r\n<--pins(SCL=%d,SDA=%d) IIC controller Ql_IIC_Init channel 1 ret=%d-->\r\n",PINNAME_RI,PINNAME_DCD,ret);
                    break;

                }
                else
                {
                    APP_DEBUG("\r\n<--IIC type error!!!!-->\r\n");
                    break;
                }

            }
	     //command-->IIC config,  IIC controller interface
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Config=0\r\n");//   simultion IIC  (channel 0)
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Config(0,TRUE, 0x07, 0);// simultion IIC interface ,do not care the IicSpeed.
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !!Ql_IIC_Config channel 0 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--Ql_IIC_Config channel 0 ret=%d-->\r\n",ret);
                break;
            }
            
            //command-->IIC config,  IIC controller interface
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Config=1\r\n");//   IIC controller  (channel 1)
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Config(1,TRUE, 0x07, 300);// just for the IIC controller
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Config channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--IIC controller Ql_IIC_Config channel 1 ret=%d-->\r\n",ret);
                break;
            }
            
            //command-->IIC write  
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Write=0\r\n");//  channel 0 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Write(0, 0x07, write_buffer, 4);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! Ql_IIC_Write channel 0 fail ret=%d-->\r\n",ret);
                    break;               
                }
                APP_DEBUG("\r\n<--channel 0 Ql_IIC_Write ret=%d-->\r\n",ret);
                break;
            }

            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Write=1\r\n");//  channel 1 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Write(1, 0x07, write_buffer,4);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Write channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--IIC controller Ql_IIC_Write ret=%d-->\r\n",ret);
                break;
            }

            //command-->IIC read  
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Read=0\r\n");//  channel 0 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Read(0, 0x07, read_buffer, 6);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! Ql_IIC_Read channel 0 fail ret=%d-->\r\n",ret);
                    break;               
                }
                APP_DEBUG("\r\n<--channel 0 Ql_IIC_Read ret=%d-->\r\n",ret);
                break;
            }

            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Read=1\r\n");//  channel 1 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Read(1, 0x07, write_buffer, 6);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Read channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--IIC controller Ql_IIC_Read ret=%d-->\r\n",ret);
                break;
            }

            //command-->IIC write then read  
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Write_Read=0\r\n");//  channel 0 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Write_Read(0, 0x07, registerAdrr, 2,read_buffer, 6);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! Ql_IIC_Write_Read channel 0 fail ret=%d-->\r\n",ret);
                    break;               
                }
                APP_DEBUG("\r\n<--channel 0 Ql_IIC_Write_Read ret=%d-->\r\n",ret);
                break;
            }

            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Write_Read=1\r\n");//  channel 1 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Write_Read(1, 0x07, registerAdrr, 2,read_buffer, 6);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Write_Read channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                APP_DEBUG("\r\n<--IIC controller Ql_IIC_Write_Read ret=%d-->\r\n",ret);
                break;
            }

                
            
            //command-->IIC write then read  
            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Uninit=0\r\n");//  channel 0 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Uninit(0);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! Ql_IIC_Uninit channel 0 fail ret=%d-->\r\n",ret);
                    break;               
                }
                APP_DEBUG("\r\n<--channel 0 Ql_IIC_Uninit ret=%d-->\r\n",ret);
                break;
            }

            Ql_memset(m_buffer, 0x0, sizeof(m_buffer));
            Ql_sprintf(m_buffer, "Ql_IIC_Uninit=1\r\n");//  channel 1 
            ret = Ql_strncmp(m_Read_Buffer, m_buffer, Ql_strlen(m_buffer));                
            if(0 == ret)
            {
                ret = Ql_IIC_Uninit(1);
                if(ret < 0)
                {
                    APP_DEBUG("\r\n<--Failed !! IIC controller Ql_IIC_Uninit channel 1 fail ret=%d-->\r\n",ret);
                    break;
                }
                 APP_DEBUG("\r\n<--IIC controller (chnnlNo 1) Ql_IIC_Uninit  ret=%d-->\r\n",ret);
                break;
            }
            
        APP_DEBUG("\r\n<--Not found this command, please check you command-->\r\n");
        }
    default:
        break;
    }
}