سلام دوستان
من یه تسک ایجاد کردم و داخل اون یه تایمر ایجاد کردم
و میخوام توی حلقه اصلی چنتا شرط بزارم که وقتی اونا برقرار بودن یه سری کار انجام بشه، اما میکرو دائم ریست میشه و نمیشه این کارو انجام داد.
Ql_Sleep(1);
این تابع رو که میزارم میکرو دیگه ریست نمیشه، اما تایمر ها دیگه کار نمیکنن
راهی هست بشه از ریست شدن جلوگیری کرد؟
سلام
برای جواب دادن به سوالتون باید کدتون رو بفرسید تا بشه نظر داد
در غیر اینصورت جوابی براش نیست!
فایل برنامه رو با فرمت 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 میخوام هروقت شرط برقرار بود کار انجام بشه، ولی میکرو ریست میشه دائم
اسلیپ هم که قرار میدم کلا داخل تایمر نمیره
اول از همه تایمر رو توی تسک اصلی تعریف کنید
بعد از اون هم یه delay کوتاه حتی 50 میلی ثانیه برای حلقه تسک ها بزارید
مشکلتون به احتمال زیاد برطرف میشه