sockettraffic.cpp

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

// SocketTraffic.cpp: implementation of the CSocketTraffic class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GrpsTest.h"
#include "SocketTraffic.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSocketTraffic::CSocketTraffic()
{
	m_nSendIn = 0;
	m_nMessageSendIn = 0;
	m_nSendOut = 0;
	m_nMessageSendOut = 0;
	m_nRecvIn = 0;
	m_nMessageRecvIn = 0;
	m_nRecvOut = 0;
	m_nMessageRecvOut=0;
	m_nConnectIn = 0;
	m_nConnectOut = 0;
	m_nCloseIn = 0;
	m_nCloseOut = 0;
	m_bThreadWait = TRUE;
	RecMsgFlag = FALSE;
	m_bBeginFlag = FALSE;

	m_hKillThreadEvent = CreateEvent(NULL, TRUE, FALSE, NULL);		// 创建一个手动重置的事件
	m_hThreadKilledEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

	InitializeCriticalSection(&m_csSend);
	InitializeCriticalSection(&m_csRecv);
	InitializeCriticalSection(&m_csConnect);
	InitializeCriticalSection(&m_csClose);
	AfxBeginThread(SocketThread, this, THREAD_PRIORITY_NORMAL);
}

CSocketTraffic::~CSocketTraffic()
{
	SetEvent(m_hKillThreadEvent);
	WaitForSingleObject(m_hThreadKilledEvent,INFINITE);
	
	DeleteCriticalSection(&m_csSend);
	DeleteCriticalSection(&m_csRecv);
	DeleteCriticalSection(&m_csConnect);
	DeleteCriticalSection(&m_csClose);

	CloseHandle(m_hKillThreadEvent);
	CloseHandle(m_hThreadKilledEvent);
}

void CSocketTraffic::PutConnectSocket(SOCKET_PARAM* pSocketParam)
{
	EnterCriticalSection(&m_csConnect);
	memcpy(&m_ConnectSocket[m_nConnectIn], pSocketParam, sizeof(SOCKET_PARAM));
	m_nConnectIn++;
	if (m_nConnectIn >= MAX_SM_SEND)  m_nConnectIn = 0;

	LeaveCriticalSection(&m_csConnect);
}

BOOL CSocketTraffic::GetConnectSocket(SOCKET_PARAM* pSocketParam)
{
	BOOL fSuccess = FALSE;
	EnterCriticalSection(&m_csConnect);
	if (m_nConnectOut != m_nConnectIn)
	{
		memcpy(pSocketParam, &m_ConnectSocket[m_nSendOut], sizeof(SOCKET_PARAM));
		m_nConnectOut++;
		if (m_nConnectOut >= MAX_SM_SEND)  m_nConnectOut = 0;
		fSuccess = TRUE;
	}
	LeaveCriticalSection(&m_csConnect);
	return fSuccess;
}

void CSocketTraffic::PutCloseSocket(SOCKET_PARAM* pSocketParam)
{
	EnterCriticalSection(&m_csClose);
	memcpy(&m_CloseSocket[m_nCloseIn],pSocketParam,sizeof(SOCKET_PARAM));
	m_nCloseIn++;
	if (m_nCloseIn>=MAX_SM_SEND) m_nCloseIn = 0;
	LeaveCriticalSection(&m_csClose);
}

BOOL CSocketTraffic::GetCloseSocket(SOCKET_PARAM* pSocketParam)
{
	BOOL fSuccess = FALSE;
	EnterCriticalSection(&m_csClose);
	if (m_nCloseOut!=m_nCloseIn)
	{
		memcpy(pSocketParam,&m_CloseSocket[m_nCloseOut],sizeof(SOCKET_PARAM));
		m_nCloseOut++;
		if (m_nCloseOut>=MAX_SM_SEND) m_nCloseOut = 0;
		fSuccess = TRUE;
	}
	LeaveCriticalSection(&m_csClose);
	return fSuccess;
}

void CSocketTraffic::PutSendData(SOCKETDATA_PARAM* pSocketParam)
{
	EnterCriticalSection(&m_csSend);
	memcpy(&m_SocketSend[m_nSendIn], pSocketParam, sizeof(SOCKETDATA_PARAM));
	m_nSendIn++;
	if (m_nSendIn >= MAX_SM_SEND)  m_nSendIn = 0;
	LeaveCriticalSection(&m_csSend);
}

BOOL CSocketTraffic::GetSendData(SOCKETDATA_PARAM* pSocketParam)
{
	BOOL fSuccess = FALSE;
	EnterCriticalSection(&m_csSend);
	if (m_nSendOut!=m_nSendIn)
	{
		memcpy(pSocketParam,&m_SocketSend[m_nSendOut],sizeof(SOCKETDATA_PARAM));
		m_nSendOut++;
		if (m_nSendOut>=MAX_SM_SEND) m_nSendOut = 0;
		fSuccess = TRUE;
	}
	LeaveCriticalSection(&m_csSend);
	return fSuccess;
}

void CSocketTraffic::PutRecvData(SOCKETDATA_PARAM* pSocketParam, int nCount)
{
	EnterCriticalSection(&m_csRecv);
	for (int i = 0; i < nCount; i++)
	{
		memcpy(&m_SocketRecv[m_nRecvIn], pSocketParam, sizeof(SM_PARAM));
	
		m_nRecvIn++;
		if (m_nRecvIn >= MAX_SM_RECV)  m_nRecvIn = 0;

		pSocketParam++;
	}

	LeaveCriticalSection(&m_csRecv);

}

BOOL CSocketTraffic::GetRecvData(SOCKETDATA_PARAM* pSocketParam)
{
	BOOL fSuccess = FALSE;
	EnterCriticalSection(&m_csRecv);
	if (m_nRecvOut != m_nRecvIn)
	{
		memcpy(pSocketParam, &m_SocketRecv[m_nRecvOut], sizeof(SM_PARAM));

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

		fSuccess = TRUE;
	}
	LeaveCriticalSection(&m_csRecv);
	return fSuccess;
}

BOOL CSocketTraffic::GetThreadStatus()
{
	return m_bThreadWait;
}
UINT CSocketTraffic::SocketThread(LPVOID lParam)
{
	CSocketTraffic* p=(CSocketTraffic *)lParam;	// this
	int nMsg;				// 收到短消息条数
	int nDelete;			// 目前正在删除的短消息编号
	int ntimes;							// 发送不成功时重发次数
	int nData;							// 记录数据包的个数
	SOCKET_BUFF buff;					// 接收数据列表的缓冲区
	SM_BUFF		smbuff;			// 接收短消息列表的缓冲区
	SOCKETDATA_PARAM dataparam[256];	// 发送/接收数据包缓冲区
	SOCKET_PARAM param[1];				// 连接/关闭socket缓冲区
	SM_PARAM Messageparam[256];	// 发送/接收短消息缓冲区
	CTime tmOrg, tmNow;					// 上次和现在的时间，计算超时用

	enum {
		stBeginRest,					// 开始休息/延时
		stContinueRest,					// 继续休息/延时
		stConnectSocketRequest,			// 建立Socket连接
		stConnectSocketResponse,	    // 读取已经建立socket连接的句柄
		stConnectSocketWaitIdle,	    // 建立连接不成功，等待回应
		stCloseSocketRequest,			// 关闭Socket连接
		stCloseSocketResponse,			// 读取关闭socket连接结果
		stCloseSocketWaitIdle,			// 关闭连接不成功，等待回应
		stSendDataRequest,				// 发送数据
		stSendDataResponse,				// 读取发送数据后GPRS返回值
		stSendDataWaitIdle,				// 发送不成功，等待GPRS就绪
//		stReadDataRequest,				// 发送读取数据列表的命令
		stReadDataResponse,				// 读取数据列表到缓冲区
		stSendMessageRequest,		// 发送短消息
		stSendMessageResponse,		// 读取短消息列表到缓冲区
		stSendMessageWaitIdle,		// 发送不成功，等待GSM就绪
		stReadMessageRequest,		// 发送读取短消息列表的命令
		stReadMessageResponse,		// 读取短消息列表到缓冲区
		stDeleteMessageRequest,		// 删除短消息
		stDeleteMessageResponse,	// 删除短消息
		stDeleteMessageWaitIdle,	// 删除不成功，等待GSM就绪
		stExitThread					// 退出
	} nState;							// 处理过程的状态
	nState = stBeginRest;

	while (nState != stExitThread)
	{
		
		switch(nState)
		{
			case stBeginRest:
				tmOrg = CTime::GetCurrentTime();
				nState = stContinueRest;
			break;
			case stContinueRest:
				Sleep(100);
				if(p->m_bBeginFlag)
				{
					memset(&buff,0,sizeof(buff));
					ReadComm(&buff,100);
				}
				tmNow = CTime::GetCurrentTime();
				if(GetRecMsgFlag())
				{
					nState = stReadMessageRequest;					// 转到读取短消息状态
					SetRecMsgFlag(TRUE);
				}
				else if (GetRecDataFlag())							// 转到读取数据状态
				{
					nState = stReadDataResponse;					
					SetRecDatFlag(TRUE);
				}
				else if (p->GetConnectSocket(param))				// 先判断缓冲区中是否有socket连接需要建立
				{
					nState = stConnectSocketRequest;
					ntimes = 0;
				}
				else if (p->GetSendMessage(&Messageparam[0]))
				{
					nState = stSendMessageRequest;					// 有待发短消息，就不休息了
				}
				else if (p->GetSendData(&dataparam[0]))				// 判断缓冲区中是否有数据需要发送
				{
					nState = stSendDataRequest;
					ntimes = 0;
				}
				else if (p->GetCloseSocket(param))			// 判断缓冲区中是否有socket连接需要断开
				{
					nState = stCloseSocketRequest;
					ntimes = 0;
				}
		/*		else if((tmNow-tmOrg)>4)					// 三秒钟发送缓冲区为空，则读取接收缓冲区的内容	
				{
				
				}	*/							
			break;
			case stConnectSocketRequest:
				ConnectSocket(param);
				memset(&buff, 0, sizeof(buff));
				tmOrg = CTime::GetCurrentTime();
				nState = stConnectSocketResponse;
			break;	
			case stSendMessageRequest:
//				TRACE("State=stSendMessageRequest\n");
				GprsSendMessage(&Messageparam[0]);
				memset(&smbuff, 0, sizeof(smbuff));
				tmOrg = CTime::GetCurrentTime();
				nState = stSendMessageResponse;
				break;
			case stConnectSocketResponse:
				Sleep(4000);
				tmNow = CTime::GetCurrentTime();
				SocketGetResponse(&buff);
				if (strstr(buff.data,"ERROR")||strstr(buff.data,"MIPSTAT"))			// 发送错误，重发
				{
					nState = stConnectSocketWaitIdle;	
				}	
				else if (strstr(buff.data,"OK")&&strstr(buff.data,"MIPOPEN:"))
				{
					strcpy(dataparam[0].IP_ADDRESS,param[0].IP_ADDRESS);
					strcpy(dataparam[0].SOCKET_ID,param[0].SOCKET_ID);
					strcpy(dataparam[0].SEND_DATA,"CONNECTSUCCESS");
					p->PutRecvData(dataparam,1);		// 将接收到的socket句柄加入接收缓冲区中
					nState = stBeginRest;							
				}				
				else
				{
					if ((tmNow-tmOrg)>90)					// 90秒内仍没有应答，则重发
					{
						nState = stConnectSocketWaitIdle;	
					}	
				}
			break;
			case stConnectSocketWaitIdle:					// 重发，直到成功为止
				Sleep(500);