smstraffic.cpp

基于VC++6的GSM模块收发短消息的程序

// SmsTraffic.cpp: implementation of the CSmsTraffic class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SmsTraffic.h"

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

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

CSmsTraffic::CSmsTraffic()
{
	m_nSendIn = 0;
	m_nSendOut = 0;
	m_nRecvIn = 0;
	m_nRecvOut = 0;
	m_nSendInTimeOut=0;
	m_nSendOutTimeOut=0;
	m_hKillThreadEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hThreadKilledEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

	InitializeCriticalSection(&m_csSend);
	InitializeCriticalSection(&m_csRecv);

	// 启动子线程
	AfxBeginThread(SmThread, this, THREAD_PRIORITY_NORMAL);
}

CSmsTraffic::~CSmsTraffic()
{
	SetEvent(m_hKillThreadEvent);			// 发出关闭子线程的信号
	WaitForSingleObject(m_hThreadKilledEvent, INFINITE);	// 等待子线程关闭

	DeleteCriticalSection(&m_csSend);
	DeleteCriticalSection(&m_csRecv);

	CloseHandle(m_hKillThreadEvent);
	CloseHandle(m_hThreadKilledEvent);
}

// 将一条短消息放入发送队列
bool CSmsTraffic::PutSendMessage(SM_PARAM* pparam)
{
	static int busy=0;
	if(busy)
		return 0;
	busy=1;
	bool Success = TRUE;
	int m_nSendIn_tmp=m_nSendIn,nDstLength;
	EnterCriticalSection(&m_csSend);
	if(pparam->TP_DCS==GSM_UCS2)
	{
		WCHAR wchar[1024];
		pparam->m_this_num=1;
		pparam->m_total_num=1;
		nDstLength = ::MultiByteToWideChar(CP_ACP, 0, pparam->TP_UD, -1, wchar, 1024);
		if(nDstLength>70)
			pparam->m_total_num=(nDstLength/66)+1;
		do 
		{
			if(nDstLength>70)
			{
				memset(pparam->TP_UD,0,sizeof(pparam->TP_UD));
				WideCharToMultiByte(CP_ACP, 0, wchar, 66, pparam->TP_UD, 160, NULL, NULL);
				memcpy(wchar,&wchar[66],(nDstLength-66)*2);
				nDstLength-=66;
			}
			else
			{
				memset(pparam->TP_UD,0,sizeof(pparam->TP_UD));
				WideCharToMultiByte(CP_ACP, 0, wchar, 70, pparam->TP_UD, 160, NULL, NULL);
				nDstLength=0;
			}
			memcpy(&m_SmSend[m_nSendIn_tmp], pparam, sizeof(SM_PARAM));
			m_nSendIn_tmp++;
			if (m_nSendIn_tmp >= MAX_SM_SEND)  m_nSendIn_tmp = 0;
			if(m_nSendIn_tmp==m_nSendOut)
			{
				Success=0;
				break;
			}
			pparam->m_this_num++;
		} while (nDstLength);
		
		if(Success)
			m_nSendIn=m_nSendIn_tmp;
	}
	else
	{
		memcpy(&m_SmSend[m_nSendIn], pparam, sizeof(SM_PARAM));
		
		m_nSendIn++;
		if (m_nSendIn >= MAX_SM_SEND)  m_nSendIn = 0;
		if(m_nSendIn==m_nSendOut)
			Success=0;
	}
	LeaveCriticalSection(&m_csSend);
	busy=0;
	return Success;
}

// 从发送队列中取一条短消息
BOOL CSmsTraffic::GetSendMessage(SM_PARAM* pparam)
{
	BOOL fSuccess = FALSE;
	
	EnterCriticalSection(&m_csSend);
	int num=0,tmp;
	tmp=m_nSendOut;
	while(tmp!=m_nSendIn)
	{
		tmp++;
		if (tmp >= MAX_SM_SEND)  tmp = 0;
		num++;
	}
	tmp=m_nSendOutTimeOut;
	while(tmp!=m_nSendInTimeOut)
	{
		tmp++;
		if (tmp >= MAX_SM_SEND)  tmp = 0;
		num++;
	}
	m_WaitNum=num;
	if (m_nSendOut != m_nSendIn)
	{
		memcpy(pparam, &m_SmSend[m_nSendOut], sizeof(SM_PARAM));
		pparam->send_times=0;
		pparam->send_type=0;

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

		fSuccess = TRUE;
	}
	else
	{
		if (m_nSendOutTimeOut != m_nSendInTimeOut)
		{
			memcpy(pparam, &m_SmSendTimeOut[m_nSendOutTimeOut], sizeof(SM_PARAM));
			pparam->send_times=0;
			pparam->send_type=1;
			
			m_nSendOutTimeOut++;
			if (m_nSendOutTimeOut >= MAX_SM_SEND)  m_nSendOutTimeOut = 0;
			
			fSuccess = TRUE;
		}
		
	}

	LeaveCriticalSection(&m_csSend);

	return fSuccess;
}

// 将短消息放入接收队列
void CSmsTraffic::PutRecvMessage(SM_PARAM* pparam, int nCount)
{
	EnterCriticalSection(&m_csRecv);

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

		pparam++;
	}

	LeaveCriticalSection(&m_csRecv);
}

// 从接收队列中取一条短消息
BOOL CSmsTraffic::GetRecvMessage(SM_PARAM* pparam)
{
	BOOL fSuccess = FALSE;

	EnterCriticalSection(&m_csRecv);

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

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

		fSuccess = TRUE;
	}

	LeaveCriticalSection(&m_csRecv);

	return fSuccess;
}
void CSmsTraffic::SendTimeOut(SM_PARAM* pparam)
{
	if(pparam->send_type)
	{
//		m_nSendOutTimeOut++;
//		if (m_nSendOutTimeOut >= MAX_SM_SEND)  m_nSendOutTimeOut = 0;
	}
	else
	{
		memcpy(&m_SmSendTimeOut[m_nSendInTimeOut], pparam, sizeof(SM_PARAM));
		m_nSendInTimeOut++;
		if (m_nSendInTimeOut >= MAX_SM_SEND)  m_nSendInTimeOut = 0;
	}
}
UINT CSmsTraffic::SmThread(LPVOID lParam)
{
	CSmsTraffic* p=(CSmsTraffic *)lParam;	// this
	int nMsg;				// 收到短消息条数
	int nDelete;			// 目前正在删除的短消息编号
	SM_BUFF buff;			// 接收短消息列表的缓冲区
	SM_PARAM param[256];	// 发送/接收短消息缓冲区
	CTime tmOrg, tmNow;		// 上次和现在的时间，计算超时用
	enum {
		stBeginRest,				// 开始休息/延时
		stContinueRest,				// 继续休息/延时
		stSendMessageRequest,		// 发送短消息
		stSendMessageResponse,		// 读取短消息列表到缓冲区
		stSendMessageWaitIdle,		// 发送不成功，等待GSM就绪
		stReadMessageRequest,		// 发送读取短消息列表的命令
		stReadMessageResponse,		// 读取短消息列表到缓冲区
		stDeleteMessageRequest,		// 删除短消息
		stDeleteMessageResponse,	// 删除短消息
		stDeleteMessageWaitIdle,	// 删除不成功，等待GSM就绪
		stExitThread				// 退出
	} nState;				// 处理过程的状态

	// 初始状态
	nState = stBeginRest;

	// 发送和接收处理的状态循环
	while (nState != stExitThread)
	{
		switch(nState)
		{
			case stBeginRest:
//				TRACE("State=stBeginRest\n");
				tmOrg = CTime::GetCurrentTime();
				nState = stContinueRest;
				break;

			case stContinueRest:
//				TRACE("State=stContinueRest\n");
				Sleep(300);
				tmNow = CTime::GetCurrentTime();
				if (p->GetSendMessage(&param[0]))
				{
					nState = stSendMessageRequest;	// 有待发短消息，就不休息了
				}
				else 
					if (tmNow - tmOrg >= 5)		// 待发短消息队列空，休息5秒
					{
						nState = stReadMessageRequest;	// 转到读取短消息状态
					}
					break;
					
			case stSendMessageRequest:
				//				TRACE("State=stSendMessageRequest\n");
				p->gsmSendMessage(&param[0]);
				memset(&buff, 0, sizeof(buff));
				tmOrg = CTime::GetCurrentTime();
				nState = stSendMessageResponse;
				break;

			case stSendMessageResponse:
//				TRACE("State=stSendMessageResponse\n");
				Sleep(100);
				tmNow = CTime::GetCurrentTime();
				switch (p->gsmGetResponse(&buff))
				{
					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:
				param[0].send_times++;
				if(param[0].send_type)
					Sleep((5000));
				else
					Sleep(500);
				if(param[0].send_times>10)
				{
					p->SendTimeOut(&param[0]);
					nState = stBeginRest;
				}
				else
					nState = stSendMessageRequest;		// 超时次数未到继续发送
				break;
				
			case stReadMessageRequest:
//				TRACE("State=stReadMessageRequest\n");
				p->gsmReadMessageList();
				memset(&buff, 0, sizeof(buff));
				tmOrg = CTime::GetCurrentTime();
				nState = stReadMessageResponse;
				break;

			case stReadMessageResponse:
//				TRACE("State=stReadMessageResponse\n");
				Sleep(100);
				tmNow = CTime::GetCurrentTime();
				switch (p->gsmGetResponse(&buff))
				{
					case GSM_OK: 
//						TRACE("  GSM_OK %d\n", tmNow - tmOrg);
						nMsg = p->gsmParseMessageList(param, &buff);
						if (nMsg > 0)
						{
							p->PutRecvMessage(param, nMsg);
							nDelete = 0;
							nState = stDeleteMessageRequest;
						}
						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)
				{
					p->gsmDeleteMessage(param[nDelete].index);
					memset(&buff, 0, sizeof(buff));
					tmOrg = CTime::GetCurrentTime();
					nState = stDeleteMessageResponse;
				}
				else
				{
					nState = stBeginRest;
				}
				break;

			case stDeleteMessageResponse:
//				TRACE("State=stDeleteMessageResponse\n");
				Sleep(100);
				tmNow = CTime::GetCurrentTime();
				switch (p->gsmGetResponse(&buff))
				{
					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;
}
// 可打印字符串转换为字节数据
// 如："C8329BFD0E01" --> {0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01}
// 输入: pSrc - 源字符串指针
//       nSrcLength - 源字符串长度
// 输出: pDst - 目标数据指针
// 返回: 目标数据长度
int CSmsTraffic::gsmString2Bytes(const char* pSrc, unsigned char* pDst, int nSrcLength)
{
	for (int i = 0; i < nSrcLength; i += 2)
	{
		// 输出高4位
		if ((*pSrc >= '0') && (*pSrc <= '9'))
		{
			*pDst = (*pSrc - '0') << 4;
		}
		else
		{
			*pDst = (*pSrc - 'A' + 10) << 4;
		}

		pSrc++;

		// 输出低4位
		if ((*pSrc>='0') && (*pSrc<='9'))
		{
			*pDst |= *pSrc - '0';
		}
		else
		{
			*pDst |= *pSrc - 'A' + 10;
		}

		pSrc++;
		pDst++;
	}

	// 返回目标数据长度
	return (nSrcLength / 2);
}

// 字节数据转换为可打印字符串
// 如：{0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01} --> "C8329BFD0E01" 
// 输入: pSrc - 源数据指针
//       nSrcLength - 源数据长度
// 输出: pDst - 目标字符串指针
// 返回: 目标字符串长度
 int CSmsTraffic::gsmBytes2String(const unsigned char* pSrc, char* pDst, int nSrcLength)
{
	const char tab[]="0123456789ABCDEF";	// 0x0-0xf的字符查找表

	for (int i = 0; i < nSrcLength; i++)
	{
		*pDst++ = tab[*pSrc >> 4];		// 输出高4位
		*pDst++ = tab[*pSrc & 0x0f];	// 输出低4位
		pSrc++;
	}

	// 输出字符串加个结束符
	*pDst = '\0';

	// 返回目标字符串长度
	return (nSrcLength * 2);
}

// 7bit编码
// 输入: pSrc - 源字符串指针
//       nSrcLength - 源字符串长度
// 输出: pDst - 目标编码串指针
// 返回: 目标编码串长度
int CSmsTraffic::gsmEncode7bit(const char* pSrc, unsigned char* pDst, int nSrcLength)
{
	int nSrc;		// 源字符串的计数值
	int nDst;		// 目标编码串的计数值
	int nChar;		// 当前正在处理的组内字符字节的序号，范围是0-7
	unsigned char nLeft;	// 上一字节残余的数据

	// 计数值初始化
	nSrc = 0;
	nDst = 0;

	// 将源串每8个字节分为一组，压缩成7个字节
	// 循环该处理过程，直至源串被处理完
	// 如果分组不到8字节，也能正确处理
	while (nSrc < nSrcLength)
	{
		// 取源字符串的计数值的最低3位
		nChar = nSrc & 7;

		// 处理源串的每个字节
		if(nChar == 0)
		{
			// 组内第一个字节，只是保存起来，待处理下一个字节时使用
			nLeft = *pSrc;
		}
		else
		{
			// 组内其它字节，将其右边部分与残余数据相加，得到一个目标编码字节
			*pDst = (*pSrc << (8-nChar)) | nLeft;

			// 将该字节剩下的左边部分，作为残余数据保存起来
			nLeft = *pSrc >> nChar;

			// 修改目标串的指针和计数值
			pDst++;
			nDst++;
		}

		// 修改源串的指针和计数值
		pSrc++;
		nSrc++;
	}

	// 返回目标串长度
	return nDst;
}

// 7bit解码
// 输入: pSrc - 源编码串指针
//       nSrcLength - 源编码串长度
// 输出: pDst - 目标字符串指针
// 返回: 目标字符串长度
int CSmsTraffic::gsmDecode7bit(const unsigned char* pSrc, char* pDst, int nSrcLength)
{
	int nSrc;		// 源字符串的计数值
	int nDst;		// 目标解码串的计数值
	int nByte;		// 当前正在处理的组内字节的序号，范围是0-6
	unsigned char nLeft;	// 上一字节残余的数据

	// 计数值初始化
	nSrc = 0;