www.pudn.com > SendMsgOCX.rar > WMsgPacket.cpp

// WMsgFrame.cpp: implementation of the CWMsgPacket class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "stdafx.h" 
//tts #include "WSMModule.h" 
#include "WMsgPacket.h" 
#include "ByteHexStrConvert.h" 
 
#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
CWMsgPacket::CWMsgPacket() 
{ 
	Reset(); 
} 
 
CWMsgPacket::~CWMsgPacket() 
{ 
 
} 
 
BOOL CWMsgPacket::SetPhoneNumberBegin(BYTE toSet) 
{ 
	BOOL bResult = toSet == PHONE_NUMBER_BEGIN; 
	m_numberDigitReceived = 0; 
	return bResult; 
} 
 
BOOL CWMsgPacket::SetPhoneNumberDigit(BYTE toSet) 
{ 
	BOOL bResult = IsValidPhoneNumberDigit(toSet); 
	 
	if(bResult)  
		m_szPhoneNumber[m_numberDigitReceived++] = toSet; 
 
	return bResult; 
} 
 
BOOL CWMsgPacket::SetPhoneNumberEnd(BYTE toSet) 
{ 
	BOOL bResult = toSet == PHONE_NUMBER_END; 
	 
	if (bResult) 
	{ 
		m_szPhoneNumber[m_numberDigitReceived] = '\0'; 
		 
		// remove +86 
		CString strTmp(m_szPhoneNumber); 
		strTmp.Replace("+86", ""); 
		strcpy(m_szPhoneNumber, strTmp); 
		m_numberDigitReceived = strTmp.GetLength(); 
	} 
 
	return bResult; 
} 
 
void CWMsgPacket::AppendPacketByte(BYTE byData) 
{ 
	ASSERT(m_dataReceived < MAX_SHORT_MSG_LEN); 
	m_msgFrameData[m_dataReceived++] = byData; 
} 
 
BOOL CWMsgPacket::SetFrameBegin(BYTE toSet) 
{ 
	BOOL bResult = toSet == FRAME_BEGIN_ID; 
	if (bResult) AppendPacketByte(toSet); 
 
	return bResult; 
} 
 
BOOL CWMsgPacket::SetFrameNo(BYTE toSet) 
{ 
	BOOL bResult = IsValidFrameNo(toSet); 
	if(bResult) AppendPacketByte(toSet); 
 
	return bResult; 
} 
 
BOOL CWMsgPacket::SetPacketNo(BYTE toSet) 
{ 
	BOOL bResult = IsValidPacketNo(toSet); 
	if(bResult) AppendPacketByte(toSet); 
	 
	return bResult; 
} 
 
BOOL CWMsgPacket::SetLastPacketFlag(BYTE toSet) 
{ 
	BOOL bResult = toSet == LAST_PACKET_ID; 
	if(bResult) 
	{ 
		m_bLastPacket = TRUE; 
		AppendPacketByte(toSet); 
	} 
 
	return bResult; 
} 
 
BOOL CWMsgPacket::IsValidMsgType(BYTE byType) 
{ 
	switch(byType) 
	{ 
	case DASHI_MSG: 
	case DIAODU_MSG_NEED_ANSWER: 
	case DIAODU_MSG_NEEDNOT_ANSWER : 
	case ANSWER_FRAME_MSG : 
	case SEND_PACKET_AGAIN_MSG : 
	case SEND_FRAME_AGAIN_MSG : 
		return TRUE; 
	default : 
		return FALSE; 
	} 
} 
 
BOOL CWMsgPacket::SetMessageType(BYTE toSet) 
{ 
	BOOL bResult = IsValidMsgType(toSet); 
	if(bResult) AppendPacketByte(toSet); 
	 
	return bResult; 
} 
 
 
BOOL CWMsgPacket::IsValidTextOrCheckSumByte(BYTE byData) 
{ 
	return isxdigit(byData);  
} 
 
BOOL CWMsgPacket::IsValidPhoneNumberDigit(BYTE byDigit) 
{ 
	return isdigit(byDigit) || byDigit == '+';		// +86--- 
} 
 
BOOL CWMsgPacket::AppendMsgTextOrCheckSum(BYTE toSet) 
{ 
	BOOL bResult = IsValidTextOrCheckSumByte(toSet); 
	if(bResult) AppendPacketByte(toSet); 
 
	return bResult; 
} 
 
BOOL CWMsgPacket::SetFrameEnd(BYTE toSet) 
{ 
	BOOL bResult = toSet == FRAME_END_ID; 
	if(bResult) AppendPacketByte(toSet); 
 
	return bResult; 
} 
 
BOOL CWMsgPacket::CheckCheckSum() 
{ 
	int nBytes = m_dataReceived - 3;		// 2 check sum + 1 end char 
	BYTE currSum = CalculateSum(nBytes); 
 
	LPBYTE lpCheckSum = m_msgFrameData + nBytes; 
	 
	BYTE checkSum; 
	HexStrLenToByte((const char*)lpCheckSum, 2, &checkSum); 
 
	return (BYTE)(checkSum + currSum) == 0; 
 
} 
 
void CWMsgPacket::Reset() 
{ 
	m_dataReceived = 0; 
	m_numberDigitReceived = 0; 
	m_bLastPacket = FALSE; 
} 
 
void CWMsgPacket::GenerateMsgPacket(LPCSTR lpszPhoneNumber, BYTE msgType, BYTE frameNo, BYTE packetNo,  
									const BYTE* lpBinData, DWORD dwDataSize, BOOL bLastPacket) 
{ 
	 
	// set phone number 
	strcpy(m_szPhoneNumber, lpszPhoneNumber); 
	m_numberDigitReceived = strlen(m_szPhoneNumber); 
 
	VERIFY(SetFrameBegin(FRAME_BEGIN_ID)); 
	VERIFY(SetFrameNo(frameNo)); 
	if(bLastPacket) VERIFY(SetLastPacketFlag(LAST_PACKET_ID)); 
	VERIFY(SetPacketNo(packetNo)); 
	VERIFY(SetMessageType((BYTE)msgType)); 
 
	// convert and get text 
	ConvertAndAppend(lpBinData, dwDataSize); 
	AppendCheckSum(); 
 
	SetFrameEnd(FRAME_END_ID); 
	 
} 
 
void CWMsgPacket::ConvertAndAppend(const BYTE* lpBinData, int binDataSize) 
{ 
	BYTE* pDest = m_msgFrameData + m_dataReceived; 
	m_dataReceived += ByteToHexStr(lpBinData, binDataSize, (char*)pDest); 
} 
 
void CWMsgPacket::AppendCheckSum() 
{ 
	BYTE currSum = CalculateSum(m_dataReceived); 
	BYTE sumNeed = 0 - currSum; 
 
	ConvertAndAppend(&sumNeed, 1); 
} 
 
BYTE CWMsgPacket::PacketIndex2PacketNo(int idx) 
{ 
	ASSERT(idx < MAX_PACKETS_PER_FRAME); 
	return idx + MIN_PACKET_NO; 
} 
 
int  CWMsgPacket::PacketNo2PacketIndex(BYTE byNo) 
{ 
	ASSERT(byNo <= MAX_PACKET_NO); 
	return byNo - MIN_PACKET_NO; 
} 
 
 
BYTE CWMsgPacket::CalculateSum(int nBytes) const 
{ 
	BYTE byteRes = 0; 
 
	const BYTE* pStart = (const BYTE*)m_msgFrameData; 
	const BYTE* pEnd = pStart + nBytes - 1; 
 
	for( const BYTE* pData = pStart; pData <= pEnd; pData++) 
		byteRes += *pData; 
 
	return byteRes; 
} 
 
const BYTE* CWMsgPacket::GetDataAndSize(int& dataSize) const 
{ 
	dataSize = m_dataReceived; 
	return m_msgFrameData; 
} 
 
LPCSTR CWMsgPacket::GetPhoneNumber() const 
{ 
	return m_szPhoneNumber; 
} 
 
BYTE CWMsgPacket::GetMessageType() const 
{ 
	int idxMsgType = 3; 
	if(m_bLastPacket) idxMsgType ++; 
 
	return m_msgFrameData[idxMsgType]; 
} 
 
int  CWMsgPacket::GetMsgBinaryData(LPBYTE lpDest) const 
{ 
	// get position of first byte 
 
	int idxFirstData = 4; 
	if(m_bLastPacket) idxFirstData ++; 
	const char* pDataBegin = (const char*)m_msgFrameData + idxFirstData; 
 
	// get data size 
	int idxLastData = m_dataReceived - 1;		// position of end flag 
	idxLastData -= 3;							// 2 check sum + 1 end flag 
	int nDataSize = idxLastData - idxFirstData + 1; 
	ASSERT(nDataSize >= 0); 
 
	return HexStrLenToByte(pDataBegin, nDataSize, lpDest); 
} 
 
BYTE CWMsgPacket::GetFrameNo() const 
{ 
	int idxFrameNo = 1; 
	return m_msgFrameData[idxFrameNo]; 
} 
 
BYTE CWMsgPacket::GetPacketNo() const 
{ 
	int idxPacketNo = 2; 
	if(m_bLastPacket) idxPacketNo++; 
 
	return m_msgFrameData[idxPacketNo]; 
} 
 
BOOL CWMsgPacket::IsLastPacket() const 
{ 
	return m_bLastPacket; 
} 
 
BOOL   CWMsgPacket::IsValidPacketNo(BYTE byNo) 
{ 
	return byNo >= MIN_PACKET_NO && byNo <= MAX_PACKET_NO; 
} 
 
BOOL   CWMsgPacket::IsValidFrameNo(BYTE byNo) 
{ 
	return byNo >= MIN_FRAME_NO && byNo <= MAX_FRAME_NO; 
}