فایل برنامه رو با فرمت txt اپلود کردم:
#ifdef __EXAMPLE_TCPCLIENT__
#include "custom_feature_def.h"
#include "ql_stdlib.h"
#include "ql_common.h"
#include "ql_type.h"
#include "ql_trace.h"
#include "ql_error.h"
#include "ql_uart.h"
#include "ql_uart.h"
#include "ql_gprs.h"
#include "ql_socket.h"
#include "ql_timer.h"
#include "ril_sim.h"
#include "ril_network.h"
#include "ril.h"
#include "ril_util.h"
#include "ril_telephony.h"
#define DEBUG_ENABLE 1
#if DEBUG_ENABLE > 0
#define DEBUG_PORT UART_PORT1
#define DBG_BUF_LEN 512
static char DBG_BUFFER[DBG_BUF_LEN];
#define APP_DEBUG(FORMAT,...) {\
Ql_memset(DBG_BUFFER, 0, DBG_BUF_LEN);\
Ql_sprintf(DBG_BUFFER,FORMAT,##__VA_ARGS__); \
if (UART_PORT2 == (DEBUG_PORT)) \
{\
Ql_Debug_Trace(DBG_BUFFER);\
} else {\
Ql_UART_Write((Enum_SerialPort)(DEBUG_PORT), (u8*)(DBG_BUFFER), Ql_strlen((const char *)(DBG_BUFFER)));\
}\
}
#else
#define APP_DEBUG(FORMAT,...)
#endif
/*****************************************************************
* define process state
******************************************************************/
typedef enum{
STATE_NW_GET_SIMSTATE,
STATE_NW_QUERY_STATE,
STATE_GPRS_REGISTER,
STATE_GPRS_CONFIG,
STATE_GPRS_ACTIVATE,
STATE_GPRS_ACTIVATING,
STATE_GPRS_GET_DNSADDRESS,
STATE_GPRS_GET_LOCALIP,
STATE_CHACK_SRVADDR,
STATE_SOC_REGISTER,
STATE_SOC_CREATE,
STATE_SOC_CONNECT,
STATE_SOC_CONNECTING,
STATE_SOC_SEND,
STATE_SOC_SENDING,
STATE_SOC_ACK,
STATE_SOC_CLOSE,
STATE_GPRS_DEACTIVATE,
STATE_TOTAL_NUM
}Enum_TCPSTATE;
static u8 m_tcp_state = STATE_NW_GET_SIMSTATE;
/*****************************************************************
* Param
******************************************************************/
u32 counter = 0;
u64 prevtime = 0;
s32 stable = 0;
s32 SENDING_TO_SERVER = 0;
s32 rep = 0;
s32 RIL_STATUS = 0;
s32 iRet = 0;
u8 RMC_BUFFER[1000];
u8 postMsg[300] = {0};
u8 arrHttpRcvBuf[10 * 1024];
u8 gps_valid = 0;
u8 soc_connect = 0;
/*****************************************************************
* UART Param
******************************************************************/
#define SERIAL_RX_BUFFER_LEN 2048
static u8 m_RxBuf_Uart[SERIAL_RX_BUFFER_LEN];
/*****************************************************************
* timer param
******************************************************************/
#define TCP_TIMER_ID TIMER_ID_USER_START
#define TIMEOUT_90S_TIMER_ID TIMER_ID_USER_START + 1 //timeout
#define TCP_TIMER_PERIOD 800
#define TIMEOUT_90S_PERIOD 90000
static s32 timeout_90S_monitor = FALSE;
/*****************************************************************
* APN Param
******************************************************************/
static u8 m_apn[MAX_GPRS_APN_LEN] = "mtnirancell";
static u8 m_userid[MAX_GPRS_USER_NAME_LEN] = "";
static u8 m_passwd[MAX_GPRS_PASSWORD_LEN] = "";
static ST_GprsConfig m_gprsCfg;
/*****************************************************************
* Server Param
******************************************************************/
#define SRVADDR_BUFFER_LEN 100
#define SEND_BUFFER_LEN 2048
#define RECV_BUFFER_LEN 2048
static u8 m_send_buf[SEND_BUFFER_LEN];
static u8 m_recv_buf[RECV_BUFFER_LEN];
static u64 m_nSentLen = 0; // Bytes of number sent data through current socket
static u8 m_SrvADDR[SRVADDR_BUFFER_LEN] = "116.247.104.27";
static u32 m_SrvPort = 6003;
static u8 m_ipaddress[5]; //only save the number of server ip, remove the comma
static s32 m_socketid = -1;
static s32 m_remain_len = 0; // record the remaining number of bytes in send buffer.
static char *m_pCurrentPos = NULL;
/*****************************************************************
* GPRS and socket callback function
******************************************************************/
void callback_socket_connect(s32 socketId, s32 errCode, void* customParam );
void callback_socket_close(s32 socketId, s32 errCode, void* customParam );
void callback_socket_accept(s32 listenSocketId, s32 errCode, void* customParam );
void callback_socket_read(s32 socketId, s32 errCode, void* customParam );
void callback_socket_write(s32 socketId, s32 errCode, void* customParam );
void Callback_GPRS_Actived(u8 contexId, s32 errCode, void* customParam);
void CallBack_GPRS_Deactived(u8 contextId, s32 errCode, void* customParam );
void Callback_GetIpByName(u8 contexId, u8 requestId, s32 errCode, u32 ipAddrCnt, u32* ipAddr);
ST_PDPContxt_Callback callback_gprs_func =
{
Callback_GPRS_Actived,
CallBack_GPRS_Deactived
};
ST_SOC_Callback callback_soc_func=
{
callback_socket_connect,
callback_socket_close,
callback_socket_accept,
callback_socket_read,
callback_socket_write
};
/*****************************************************************
* uart callback function
******************************************************************/
static void CallBack_UART_Hdlr(Enum_SerialPort port, Enum_UARTEventType msg, bool level, void* customizedPara);
/*****************************************************************
* timer callback function
******************************************************************/
static void Callback_Timer(u32 timerId, void* param);
/*****************************************************************
* other subroutines
******************************************************************/
extern s32 Analyse_Command(u8* src_str,s32 symbol_num,u8 symbol, u8* dest_buf);
static s32 ReadSerialPort(Enum_SerialPort port, /*[out]*/u8* pBuffer, /*[in]*/u32 bufLen);
static void proc_handle(char *pData,s32 len);
void task_GPRS(s32 TaskId);
void task_GNSS(s32 TaskId);
void GPSPower(int status);
static s32 ret;
void proc_main_task(s32 taskId)
{
s32 ret;
ST_MSG msg;
// Register & open UART port
Ql_UART_Register(UART_PORT1, CallBack_UART_Hdlr, NULL);
Ql_UART_Register(UART_PORT2, CallBack_UART_Hdlr, NULL);
Ql_UART_Open(UART_PORT1, 115200, FC_NONE);
Ql_UART_Open(UART_PORT2, 115200, FC_NONE);
APP_DEBUG("<--OpenCPU: TCP Client.-->\r\n");
while(TRUE)
{
Ql_OS_GetMessage(&msg);
switch(msg.message)
{
#ifdef __OCPU_RIL_SUPPORT__
case MSG_ID_RIL_READY:
APP_DEBUG("<-- RIL is ready -->\r\n");
Ql_RIL_Initialize();
break;
#endif
default:
break;
}
}
}
void task_GPRS(s32 TaskId)
{
//register & start timer
Ql_Timer_Register(TCP_TIMER_ID, Callback_Timer, NULL);
Ql_Timer_Start(TCP_TIMER_ID, TCP_TIMER_PERIOD, TRUE);
Ql_Timer_Register(TIMEOUT_90S_TIMER_ID, Callback_Timer, NULL);
timeout_90S_monitor = FALSE;
while(1)
{
if(soc_connect)
{
m_pCurrentPos = m_send_buf;
Ql_strcpy(m_pCurrentPos, postMsg);
m_remain_len = Ql_strlen(m_pCurrentPos);
}
}
}
/*
* RIL_NW_GetOperator(); //AT+COPS?
* RIL_NW_GetGPRSState(); //AT+CGREG?
* RIL_NW_GetGSMState(); //AT+CREG?
* RIL_NW_GetSignalQuality(); //AT+CSQ
* RIL_GetIMEI(imei);
* Ql_GetMsSincePwrOn();
*/
void task_GNSS(s32 TaskId)
{
char data[5];
Ql_GPIO_Init(PINNAME_DTR, PINDIRECTION_OUT, PINLEVEL_HIGH, PINPULLSEL_PULLUP);
while (1)
{
Ql_Sleep(1000);
if (RIL_STATUS = 1)
{
iRet = RIL_GPS_Read("RMC", RMC_BUFFER);
if (RIL_AT_SUCCESS != iRet)
{
APP_DEBUG("Read %s information failed.\r\n", "RMC");
}
else
{
if (RMC_BUFFER[30] == 'A')
{
Ql_sprintf(data, "%d", counter);
Ql_strcpy((char*)postMsg, data);
Ql_strcat((char*)postMsg, (const char*)RMC_BUFFER);
Ql_strcat((char*)postMsg, "\0");
Ql_GPIO_SetLevel(PINNAME_DTR, PINLEVEL_HIGH);
Ql_Sleep(50);
Ql_GPIO_SetLevel(PINNAME_DTR, PINLEVEL_LOW);
Ql_Sleep(50);
Ql_GPIO_SetLevel(PINNAME_DTR, PINLEVEL_HIGH);
Ql_Sleep(50);
Ql_GPIO_SetLevel(PINNAME_DTR, PINLEVEL_LOW);
gps_valid = 1;
}
else if (RMC_BUFFER[30] == 'V')
{
gps_valid = 0;
Ql_GPIO_SetLevel(PINNAME_DTR, PINLEVEL_HIGH);
Ql_Sleep(50);
Ql_GPIO_SetLevel(PINNAME_DTR, PINLEVEL_LOW);
}
}
}
}
}
void GPSPower(int status)
{
if (status == 1)
{
iRet = RIL_GPS_Open(1);
if (RIL_AT_SUCCESS != iRet)
{
APP_DEBUG("GPS is on \r\n");
}
else
{
APP_DEBUG("Power on GPS Successful.\r\n");
}
}
else if (status == 0)
{
iRet = RIL_GPS_Open(0);
if (RIL_AT_SUCCESS != iRet)
{
APP_DEBUG("GPS is off \r\n");
}
else
{
APP_DEBUG("Power off GPS Successful.\r\n");
}
}
}
static void CallBack_UART_Hdlr(Enum_SerialPort port, Enum_UARTEventType msg, bool level, void* customizedPara)
{
switch (msg)
{
case EVENT_UART_READY_TO_READ:
{
s32 totalBytes = ReadSerialPort(port, m_RxBuf_Uart, sizeof(m_RxBuf_Uart));
if (totalBytes > 0)
{
proc_handle(m_RxBuf_Uart,sizeof(m_RxBuf_Uart));
}
break;
}
case EVENT_UART_READY_TO_WRITE:
break;
default:
break;
}
}
static s32 ReadSerialPort(Enum_SerialPort port, /*[out]*/u8* pBuffer, /*[in]*/u32 bufLen)
{
s32 rdLen = 0;
s32 rdTotalLen = 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;
}
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, MAX_GPRS_APN_LEN);
if (Analyse_Command(pData, 1, '>', m_apn))
{
APP_DEBUG("<--APN Parameter Error.-->\r\n");
return;
}
Ql_memset(m_userid, 0, MAX_GPRS_USER_NAME_LEN);
if (Analyse_Command(pData, 2, '>', m_userid))
{
APP_DEBUG("<--APN Username Parameter Error.-->\r\n");
return;
}
Ql_memset(m_passwd, 0, MAX_GPRS_PASSWORD_LEN);
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);
}
static void checkErr_AckNumber(s32 err_code)
{
if(SOC_INVALID_SOCKET == err_code)
{
APP_DEBUG("<-- Invalid socket ID -->\r\n");
}
else if(SOC_INVAL == err_code)
{
APP_DEBUG("<-- Invalid parameters for ACK number -->\r\n");
}
else if(SOC_ERROR == err_code)
{
APP_DEBUG("<-- Unspecified error for ACK number -->\r\n");
}
else
{
// get the socket option successfully
}
}
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;
RIL_SIM_GetSimState(&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;
soc_connect = 1;
}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;
}
}
}
void Callback_GPRS_Actived(u8 contexId, s32 errCode, void* customParam)
{
if(errCode == SOC_SUCCESS)
{
APP_DEBUG("<--CallBack: active GPRS successfully.-->\r\n");
m_tcp_state = STATE_GPRS_GET_DNSADDRESS;
}else
{
APP_DEBUG("<--CallBack: active GPRS successfully,errCode=%d-->\r\n",errCode);
m_tcp_state = STATE_GPRS_ACTIVATE;
}
}
void Callback_GetIpByName(u8 contexId, u8 requestId, s32 errCode, u32 ipAddrCnt, u32* ipAddr)
{
u8 i=0;
u8* ipSegment = (u8*)ipAddr;
APP_DEBUG("<-- %s:contexid=%d, requestId=%d,error=%d,num_entry=%d -->\r\n", __func__, contexId, requestId,errCode,ipAddrCnt);
if (errCode == SOC_SUCCESS)
{
APP_DEBUG("<--CallBack: get ip by name successfully.-->\r\n");
for(i=0;i<ipAddrCnt;i++)
{
ipSegment = (u8*)(ipAddr + i);
APP_DEBUG("<--Entry=%d, ip=%d.%d.%d.%d-->\r\n",i,ipSegment[0],ipSegment[1],ipSegment[2],ipSegment[3]);
}
// Fetch the first ip address as the valid IP
Ql_memcpy(m_ipaddress, ipAddr, 4);
m_tcp_state = STATE_SOC_REGISTER;
}
}
void callback_socket_connect(s32 socketId, s32 errCode, void* customParam )
{
if (errCode == SOC_SUCCESS)
{
if (timeout_90S_monitor) //stop timeout monitor
{
Ql_Timer_Stop(TIMEOUT_90S_TIMER_ID);
timeout_90S_monitor = FALSE;
}
APP_DEBUG("<--Callback: socket connect successfully.-->\r\n");
m_tcp_state = STATE_SOC_SEND;
}else
{
APP_DEBUG("<--Callback: socket connect failure,(socketId=%d),errCode=%d-->\r\n",socketId,errCode);
Ql_SOC_Close(socketId);
m_tcp_state = STATE_SOC_CREATE;
}
}
void callback_socket_close(s32 socketId, s32 errCode, void* customParam )
{
m_nSentLen = 0;
if (errCode == SOC_SUCCESS)
{
APP_DEBUG("<--CallBack: close socket successfully.-->\r\n");
}else if(errCode == SOC_BEARER_FAIL)
{
m_tcp_state = STATE_GPRS_DEACTIVATE;
APP_DEBUG("<--CallBack: close socket failure,(socketId=%d,error_cause=%d)-->\r\n",socketId,errCode);
}else
{
m_tcp_state = STATE_GPRS_GET_DNSADDRESS;
APP_DEBUG("<--CallBack: close socket failure,(socketId=%d,error_cause=%d)-->\r\n",socketId,errCode);
}
}
void callback_socket_accept(s32 listenSocketId, s32 errCode, void* customParam )
{
}
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 callback_socket_write(s32 socketId, s32 errCode, void* customParam )
{
s32 ret;
if(errCode)
{
APP_DEBUG("<--CallBack: socket write failure,(sock=%d,error=%d)-->\r\n",socketId,errCode);
APP_DEBUG("<-- Close socket.-->\r\n");
Ql_SOC_Close(socketId);
m_socketid = -1;
if(ret == SOC_BEARER_FAIL)
{
m_tcp_state = STATE_GPRS_DEACTIVATE;
}
else
{
m_tcp_state = STATE_GPRS_GET_DNSADDRESS;
}
return;
}
m_tcp_state = STATE_SOC_SENDING;
do
{
ret = Ql_SOC_Send(m_socketid, m_pCurrentPos, m_remain_len);
APP_DEBUG("<--CallBack: 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))
{
//you must wait 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(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);
}
void CallBack_GPRS_Deactived(u8 contextId, s32 errCode, void* customParam )
{
m_nSentLen = 0;
if (errCode == SOC_SUCCESS)
{
APP_DEBUG("<--CallBack: deactived GPRS successfully.-->\r\n");
m_tcp_state = STATE_NW_GET_SIMSTATE;
}else
{
APP_DEBUG("<--CallBack: deactived GPRS failure,(contexid=%d,error_cause=%d)-->\r\n",contextId,errCode);
}
}
#endif // __EXAMPLE_TCPCLIENT__
توی تسک task_GPRS میخوام هروقت شرط برقرار بود کار انجام بشه، ولی میکرو ریست میشه دائم
اسلیپ هم که قرار میدم کلا داخل تایمر نمیره