wireless.cpp

这是一个完整的无线通讯工程

DWORD WINAPI CallISokThread(LPVOID lpvoid)
{
	char ans[128] = "\0";
	while(1)
	{
		if (ReadComm(ans,128) > 0)
		{
			TRACE("%s\r\n", ans);
			if (strstr(ans,"OK") != NULL)
			{
				//m_ComStateThread->SuspendThread();
				::PostMessage(m_CallHand->GetSafeHwnd(), WM_CALLSTATE, 1, (LPARAM)CALLING);
				DWORD tid = 0;
				
				//CreateThread(NULL, 0, GetVoiceState, NULL, 0, &tid);
				return 0;
			}
		}
		//ClearCommData();
		Sleep(500);
	}
	return 0;    
}

extern "C" __declspec(dllexport) bool CallNumber(char *number , CWnd *callhand)
{
    char ans[128] = "\0", *p = NULL , *send = NULL;
	CString tempvalue;
	tempvalue.Format("ATD%s;\r\n",number);
	send = tempvalue.GetBuffer(0);
	WriteComm(send,strlen(send));
	m_CallHand = callhand;

	CreateThread(NULL, 0, CallISokThread, NULL, 0, NULL);
	return true;
}

extern "C" __declspec(dllexport) bool HangUp()
{
    char ans[128], *p = NULL, *send = "ATH\r\n";
	WriteComm(send,strlen(send));
	while(true)
	{
		if (ReadComm(ans,128) > 0)
		{
			TRACE("%s\r\n", ans);
			if (strstr(ans, "OK") != NULL)
			{
				//ClearCommData();
				//m_ComStateThread->ResumeThread();
				return true;
			}
			else 
				return false;
		}
	}
	return false;
}

extern "C" __declspec(dllexport) bool SetCSCA(char *csca)
{
    char ans[128] = "\0", *p = NULL, *send = NULL;
	CString tempsend;
	tempsend.Format("AT+CSCA=\"%s\"\r\n",csca);
	send = tempsend.GetBuffer(0);
	WriteComm(send,strlen(send));
	while(1)
	{
		if (ReadComm(ans, 128) > 0)
		{
			TRACE("%s\r\n", ans);
			if ((p = strstr(ans, "OK")) != NULL)
			{
				return true;
			}
			else
				return false;
		}
	}
    return false;
}

extern "C" __declspec(dllexport) bool AcceptInCall(CWnd *callhand)
{
    char ans[128] = "\0", *send = "ATA\r\n";
	
	WriteComm(send,strlen(send));
	while(1)
	{
		if (ReadComm(ans, 128) > 0)
		{
			TRACE("%s\r\n", ans);
			if (strstr(ans, "OK") != NULL)
			{
				//m_CallHand = callhand;
				//m_ComStateThread->SuspendThread();
				//CreateThread(NULL, 0, GetVoiceState, NULL, 0, NULL);
				return true;
			}
			else
			{
			//	m_ComStateThread->ResumeThread();
				return false;
			}
		}
	}
//	m_ComStateThread->ResumeThread();
    return false;
}

bool SetCPBS()
{
	char ans[128]="\0";
	WriteComm("AT+CPBS=\"SM\"\r\n",strlen("AT+CPBS=\"SM\"\r\n"));
	if ((ReadComm(ans,128) > 0) != NULL)
	{
		TRACE("%s\r\n", ans);
		if (strstr(ans,"OK") == NULL)
			return false;
	}
	return true;
}

extern "C" __declspec(dllexport) bool GetNumberCont(int *count)
{
	char ans[128] = "\0", *p = NULL;
	WriteComm("AT+CPBS?\r\n",strlen("AT+CPBS?\r\n"));
	if (ReadComm(ans,128) != NULL)
	{
		TRACE("%s\r\n", ans);
		if ((p = strstr(ans,"+CPBS:")) != NULL)
		{
            p += 12;
			CString temp;
			temp = p;
			int pos = temp.Find(",");
			*count = atoi(temp.Left(pos));
		}
		else
			return false;
	}
	else
		return false;
	
	WriteComm("AT+CSCS=\"UCS2\"\r\n",strlen("AT+CSCS=\"USC2\"\r\n"));
	if ((ReadComm(ans,128) > 0) != NULL)
	{
		TRACE("%s\r\n", ans);
		if (strstr(ans,"OK") == NULL)
			return false;
	}
    
	return true;
}


// 可打印字符串转换为字节数据
// 如："C8329BFD0E01" --> {0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01}
// 输入: pSrc - 源字符串指针
//       nSrcLength - 源字符串长度
// 输出: pDst - 目标数据指针
// 返回: 目标数据长度
int 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 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 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 gsmDecode7bit(const unsigned char* pSrc, char* pDst, int nSrcLength)
{
	int nSrc;		// 源字符串的计数值
	int nDst;		// 目标解码串的计数值
	int nByte;		// 当前正在处理的组内字节的序号，范围是0-6
	unsigned char nLeft;	// 上一字节残余的数据
	
	// 计数值初始化
	nSrc = 0;
	nDst = 0;
	
	// 组内字节序号和残余数据初始化
	nByte = 0;
	nLeft = 0;
	
	// 将源数据每7个字节分为一组，解压缩成8个字节
	// 循环该处理过程，直至源数据被处理完
	// 如果分组不到7字节，也能正确处理
	while(nSrc<nSrcLength)
	{
		// 将源字节右边部分与残余数据相加，去掉最高位，得到一个目标解码字节
		*pDst = ((*pSrc << nByte) | nLeft) & 0x7f;
		
		// 将该字节剩下的左边部分，作为残余数据保存起来
		nLeft = *pSrc >> (7-nByte);
		
		// 修改目标串的指针和计数值
		pDst++;
		nDst++;
		
		// 修改字节计数值
		nByte++;
		
		// 到了一组的最后一个字节
		if(nByte == 7)
		{
			// 额外得到一个目标解码字节
			*pDst = nLeft;
			
			// 修改目标串的指针和计数值
			pDst++;
			nDst++;
			
			// 组内字节序号和残余数据初始化
			nByte = 0;
			nLeft = 0;
		}
		
		// 修改源串的指针和计数值
		pSrc++;
		nSrc++;
	}
	
	// 输出字符串加个结束符
	*pDst = '\0';
	
	// 返回目标串长度
	return nDst;
}

// 8bit编码
// 输入: pSrc - 源字符串指针
//       nSrcLength - 源字符串长度
// 输出: pDst - 目标编码串指针
// 返回: 目标编码串长度
int gsmEncode8bit(const char* pSrc, unsigned char* pDst, int nSrcLength)
{
	// 简单复制
	memcpy(pDst, pSrc, nSrcLength);
	
	return nSrcLength;
}

// 8bit解码
// 输入: pSrc - 源编码串指针
//       nSrcLength -  源编码串长度
// 输出: pDst -  目标字符串指针
// 返回: 目标字符串长度
int gsmDecode8bit(const unsigned char* pSrc, char* pDst, int nSrcLength)
{
	// 简单复制
	memcpy(pDst, pSrc, nSrcLength);
	
	// 输出字符串加个结束符
	*pDst = '\0';
	
	return nSrcLength;
}

// UCS2编码
// 输入: pSrc - 源字符串指针
//       nSrcLength - 源字符串长度
// 输出: pDst - 目标编码串指针
// 返回: 目标编码串长度
int gsmEncodeUcs2(const char* pSrc, unsigned char* pDst, int nSrcLength)
{
	int nDstLength;		// UNICODE宽字符数目
	WCHAR wchar[160];	// UNICODE串缓冲区
	
	// 字符串-->UNICODE串
	nDstLength = MultiByteToWideChar(CP_ACP, 0, pSrc, nSrcLength, wchar, 160);
	
	// 高低字节对调，输出
	for(int i=0; i<nDstLength; i++)
	{
		*pDst++ = wchar[i] >> 8;		// 先输出高位字节
		*pDst++ = wchar[i] & 0xff;		// 后输出低位字节
	}
	
	// 返回目标编码串长度
	return nDstLength * 2;
}

// UCS2解码
// 输入: pSrc - 源编码串指针
//       nSrcLength -  源编码串长度
// 输出: pDst -  目标字符串指针
// 返回: 目标字符串长度
int gsmDecodeUcs2(const unsigned char* pSrc, char* pDst, int nSrcLength)
{
	int nDstLength;		// UNICODE宽字符数目
	WCHAR wchar[160];	// UNICODE串缓冲区
	
	// 高低字节对调，拼成UNICODE
	for(int i=0; i<nSrcLength/2; i++)
	{
		wchar[i] = *pSrc++ << 8;	// 先高位字节
		wchar[i] |= *pSrc++;		// 后低位字节
	}
	
	// UNICODE串-->字符串
	nDstLength = WideCharToMultiByte(CP_ACP, 0, wchar, nSrcLength/2, pDst, 160, NULL, NULL);
	
	// 输出字符串加个结束符
	pDst[nDstLength] = '\0';
	
	// 返回目标字符串长度
	return nDstLength;
}

// 正常顺序的字符串转换为两两颠倒的字符串，若长度为奇数，补'F'凑成偶数
// 如："8613851872468" --> "683158812764F8"
// 输入: pSrc - 源字符串指针
//       nSrcLength - 源字符串长度
// 输出: pDst - 目标字符串指针
// 返回: 目标字符串长度
int gsmInvertNumbers(const char* pSrc, char* pDst, int nSrcLength)
{
	int nDstLength;		// 目标字符串长度
	char ch;			// 用于保存一个字符
	
	// 复制串长度
	nDstLength = nSrcLength;
	
	// 两两颠倒
	for(int i=0; i<nSrcLength;i+=2)
	{
		ch = *pSrc++;		// 保存先出现的字符
		*pDst++ = *pSrc++;	// 复制后出现的字符
		*pDst++ = ch;		// 复制先出现的字符
	}
	
	// 源串长度是奇数吗？
	if(nSrcLength & 1)
	{
		*(pDst-2) = 'F';	// 补'F'
		nDstLength++;		// 目标串长度加1
	}
	
	// 输出字符串加个结束符
	*pDst = '\0';
	
	// 返回目标字符串长度
	return nDstLength;
}

// 两两颠倒的字符串转换为正常顺序的字符串
// 如："683158812764F8" --> "8613851872468"
// 输入: pSrc - 源字符串指针
//       nSrcLength - 源字符串长度
// 输出: pDst - 目标字符串指针
// 返回: 目标字符串长度
int gsmSerializeNumbers(const char* pSrc, char* pDst, int nSrcLength)
{
	int nDstLength;		// 目标字符串长度
	char ch;			// 用于保存一个字符
	
	// 复制串长度
	nDstLength = nSrcLength;
	
	// 两两颠倒
	for(int i=0; i<nSrcLength;i+=2)
	{
		ch = *pSrc++;		// 保存先出现的字符
		*pDst++ = *pSrc++;	// 复制后出现的字符
		*pDst++ = ch;		// 复制先出现的字符
	}
	
	// 最后的字符是'F'吗？
	if(*(pDst-1) == 'F')
	{
		pDst--;
		nDstLength--;		// 目标字符串长度减1
	}
	
	// 输出字符串加个结束符
	*pDst = '\0';
	
	// 返回目标字符串长度
	return nDstLength;
}


extern "C" __declspec(dllexport) /*bool*/ int  GetPhoneBook(/*LPNUMBERINFO *phonebook ,int *count*/)
{

	int Phonecount = 200,  NumberCount = 0;
	if (!SetCPBS())
		return 0;
	
    if (!GetNumberCont(&Phonecount))
		return 0;
	
	int Group = 0;
    if (Phonecount < 10)
		Group = 2;
	else
		Group = ((Phonecount%10) == 0)?Phonecount/10:(Phonecount/10)+1;
//	LPNUMBERINFO tempNumber = new NUMBERINFO[Phonecount];
//	ZeroMemory(tempNumber,sizeof(NUMBERINFO));
	
    for (int i = 0 ;i < Group ; i++)
	{
		
		if (NumberCount >= Phonecount)
			break;
		char ans[1024], send[32] ;
		memset(ans,0,1024);
		memset(send,0,32);
		sprintf(send,"AT+CPBR=%d,%d\r\n",i*10+1,(i+1)*10);
		TRACE("\r\n%d--%d\r\n", i*10+1, (i+1)*10);
		WriteComm(send,strlen(send));
		if (ReadComm(ans,1024) > 0)
		{
			TRACE("%s\r\n", ans);
			char  *p = strtok(ans, "\r\n");
			while(p)
			{
				if ( strstr(p,"OK") != NULL)
				{
					break;
				}
				LPNUMBERINFO tempNumber = new NUMBERINFO;
	            ZeroMemory(tempNumber,sizeof(NUMBERINFO));
				p += 7;
				char Noke[48];
				memset(Noke,0,48);
				CString temp;
				
				temp = p;
				int pos = temp.Find(",");