sockettraffic.cpp

上位机vc++对摩托罗拉GPRS模块G24编程实现短信收发

				ntimes++;
				if(ntimes<3) 	nState = stConnectSocketRequest;	// 不到三次继续重发	
				else
				{
					strcpy(dataparam[0].SEND_DATA,"CONNFAIL");
					p->PutRecvData(dataparam,1);			// 通知主程序建立连接失败
					nState = stBeginRest;
				}
			break;
			case stSendDataRequest:
				SocketSendData(&dataparam[0]);
				memset(&buff, 0, sizeof(buff));
				tmOrg = CTime::GetCurrentTime();
				nState = stSendDataResponse;
			break;
			case stSendDataResponse:
				Sleep(100);
				tmNow = CTime::GetCurrentTime();
				SocketGetResponse(&buff);
				if (strstr(buff.data,"MIPSEND"))		// 数据已经发送至缓冲区中
				{
					memset(&buff, 0, sizeof(buff));
					char buffer[] = "AT+MIPPUSH=1\r";				// 长度以后需要指定
					WriteComm(buffer,strlen(buffer));
				}
				else if(strstr(buff.data,"MIPPUSH"))	// 数据已经发送出去
				{
					strcpy(dataparam[0].SEND_DATA,"SENDSUCCESS");
					p->PutRecvData(dataparam,1);
					nState = stBeginRest;
				}
				else if (strstr(buff.data,"ERROR"))
				{
					nState = stSendDataWaitIdle;
				}
				else if((tmNow-tmOrg)>90)
				{
					nState = stSendDataWaitIdle;
				}
			break;
			case stSendDataWaitIdle:
				Sleep(500);
				ntimes++;
				if(ntimes<3) 	nState = stSendDataRequest;	// 不到三次继续重发	
				else
				{
					strcpy(dataparam[1].SEND_DATA,"SENDFAIL");
					p->PutRecvData(&dataparam[1],1);		// 通知主程序发送数据失败
					nState = stBeginRest;
				}
			break;
			case stCloseSocketRequest:
				CloseSocket(param);
				memset(&buff, 0, sizeof(buff));
				tmOrg = CTime::GetCurrentTime();
				nState = stCloseSocketResponse;
			break;
			case stCloseSocketResponse:
				Sleep(100);
				tmNow = CTime::GetCurrentTime();
				SocketGetResponse(&buff);
				if (strstr(buff.data,"OK"))	// socket关闭成功
				{
					strcpy(dataparam[0].SEND_DATA,"CLOSESUCCESS");
					p->PutRecvData(dataparam,1);
					nState = stBeginRest;
				}
				else if (strstr(buff.data,"ERROR"))
				{
					nState = stCloseSocketWaitIdle;
				}
				else if ((tmNow-tmOrg)>90)
				{
					nState = stCloseSocketWaitIdle;
				}
			break;
			case stCloseSocketWaitIdle:
				Sleep(500);
				ntimes++;
				if(ntimes<3) 	nState = stCloseSocketRequest;	// 不到三次继续重发	
				else
				{
					strcpy(dataparam[0].SEND_DATA,"CLOSEFAIL");
					p->PutRecvData(dataparam,1);			// 通知主程序建立连接失败
					nState = stBeginRest;
				}
			break;
			default:
			break;
			case stReadDataResponse:
				memset(&dataparam[0],0,sizeof(dataparam[0]));
				nData = SocketParseMessageList(param,&dataparam[0],&buff);
				if(nData>0)									// 缓冲区中有数据
				{
					p->PutRecvData(dataparam,nData);
				}
				nState = stBeginRest;
				break;
			case stSendMessageResponse:
				//				TRACE("State=stSendMessageResponse\n");
				Sleep(100);
				tmNow = CTime::GetCurrentTime();
				switch (gsmGetResponse(&smbuff))
				{
					case GSM_OK: 
//						TRACE("  GSM_OK %d\n", tmNow - tmOrg);
						nState = stBeginRest;
						break;
					case GSM_ERR:
//						TRACE("  GSM_ERR %d\n", tmNow - tmOrg);
						nState = stSendMessageWaitIdle;
						break;
					default:
//						TRACE("  GSM_WAIT %d\n", tmNow - tmOrg);
						if (tmNow - tmOrg >= 10)		// 10秒超时
						{
//							TRACE("  Timeout!\n");
							nState = stSendMessageWaitIdle;
						}
				}
				break;

			case stSendMessageWaitIdle:
				Sleep(500);
				nState = stSendMessageRequest;		// 直到发送成功为止
				break;

			case stReadMessageRequest:
//				TRACE("State=stReadMessageRequest\n");
				gsmReadMessageList();
				memset(&smbuff, 0, sizeof(smbuff));
				tmOrg = CTime::GetCurrentTime();
				nState = stReadMessageResponse;
				break;

			case stReadMessageResponse:
//				TRACE("State=stReadMessageResponse\n");
				Sleep(100);
				tmNow = CTime::GetCurrentTime();
				switch (gsmGetResponse(&smbuff))			//	在15秒内将卡内的短消息内容读取出来
				{
					case GSM_OK: 
//						TRACE("  GSM_OK %d\n", tmNow - tmOrg);
						nMsg = gsmParseMessageList(Messageparam, &smbuff);
						if (nMsg > 0)
						{
							p->PutRecvMessage(Messageparam, nMsg);
							nDelete = 0;
							nState = stDeleteMessageRequest;
						//	nState = stBeginRest;
						}
						else
						{
							nState = stBeginRest;
						}
						break;
					case GSM_ERR:
//						TRACE("  GSM_ERR %d\n", tmNow - tmOrg);
						nState = stBeginRest;
						break;
					default:
//						TRACE("  GSM_WAIT %d\n", tmNow - tmOrg);
						if (tmNow - tmOrg >= 15)		// 15秒超时
						{
//							TRACE("  Timeout!\n");
							nState = stBeginRest;
						}
				}
				break;

			case stDeleteMessageRequest:
//				TRACE("State=stDeleteMessageRequest\n");
				if (nDelete < nMsg)
				{
					gsmDeleteMessage(Messageparam[nDelete].index);
					memset(&smbuff, 0, sizeof(smbuff));
					tmOrg = CTime::GetCurrentTime();
					nState = stDeleteMessageResponse;
				}
				else
				{
					nState = stBeginRest;
				}
				break;

			case stDeleteMessageResponse:
//				TRACE("State=stDeleteMessageResponse\n");
				Sleep(100);
				tmNow = CTime::GetCurrentTime();
				switch (gsmGetResponse(&smbuff))
				{
					case GSM_OK: 
//						TRACE("  GSM_OK %d\n", tmNow - tmOrg);
						nDelete++;
						nState = stDeleteMessageRequest;
						break;
					case GSM_ERR:
//						TRACE("  GSM_ERR %d\n", tmNow - tmOrg);
						nState = stDeleteMessageWaitIdle;
						break;
					default:
//						TRACE("  GSM_WAIT %d\n", tmNow - tmOrg);
						if (tmNow - tmOrg >= 5)		// 5秒超时
						{
//							TRACE("  Timeout!\n");
							nState = stBeginRest;
						}
				}
				break;

			case stDeleteMessageWaitIdle:
//				TRACE("State=stDeleteMessageWaitIdle\n");
				Sleep(500);
				nState = stDeleteMessageRequest;		// 直到删除成功为止
				break;
		}
		DWORD dwEvent = WaitForSingleObject(p->m_hKillThreadEvent, 20);
		if (dwEvent == WAIT_OBJECT_0)  nState = stExitThread;
	}

	SetEvent(p->m_hThreadKilledEvent);
	
	return 9999;
}

void CSocketTraffic::PutSendMessage(SM_PARAM *pparam)
{
	EnterCriticalSection(&m_csSend);
 
 	memcpy(&m_SmSend[m_nMessageSendIn], pparam, sizeof(SM_PARAM));
 
	m_nMessageSendIn++;
 	if (m_nMessageSendIn >= MAX_SM_SEND)  m_nMessageSendIn = 0;
 
 	LeaveCriticalSection(&m_csSend);
}

void CSocketTraffic::PutRecvMessage(SM_PARAM *pparam, int nCount)
{
	EnterCriticalSection(&m_csRecv);

	for (int i = 0; i < nCount; i++)
	{
		memcpy(&m_SmRecv[m_nMessageRecvIn], pparam, sizeof(SM_PARAM));
	
		m_nMessageRecvIn++;
		if (m_nMessageRecvIn >= MAX_SM_RECV)  m_nMessageRecvIn = 0;

		pparam++;
	}

	LeaveCriticalSection(&m_csRecv);
}

BOOL CSocketTraffic::GetRecvMessage(SM_PARAM *pparam)
{
	BOOL fSuccess = FALSE;

	EnterCriticalSection(&m_csRecv);

	if (m_nMessageRecvOut != m_nMessageRecvIn)
	{
		memcpy(pparam, &m_SmRecv[m_nMessageRecvOut], sizeof(SM_PARAM));

		m_nMessageRecvOut++;
		if (m_nMessageRecvOut >= MAX_SM_RECV)  m_nMessageRecvOut = 0;

		fSuccess = TRUE;
	}

	LeaveCriticalSection(&m_csRecv);

	return fSuccess;
}

BOOL CSocketTraffic::GetSendMessage(SM_PARAM *pparam)
{
	BOOL fSuccess = FALSE;
	EnterCriticalSection(&m_csSend);

	if (m_nMessageSendOut != m_nMessageSendIn)
	{
		memcpy(pparam, &m_SmSend[m_nMessageSendOut], sizeof(SM_PARAM));

		m_nMessageSendOut++;
		if (m_nMessageSendOut >= MAX_SM_SEND)  m_nMessageSendOut = 0;

		fSuccess = TRUE;
	}

	LeaveCriticalSection(&m_csSend);

	return fSuccess;
}

void CSocketTraffic::SetRecvMsgFlag()
{
	RecMsgFlag = 1;
}