nettocommdlg.cpp

本压缩包是一个网口转串口的原码,非常有用哦

	BYTE8* pucCommand = new BYTE8[iNewLen + 4];

	if (NULL == pucCommand)
	{
		delete[] pucCRCData;
		pucCRCData = NULL;

		TRACE("new pucCRCData failed\n");
		return -1;
	}

	memset(pucCommand, 0, sizeof(BYTE8)*(iNewLen + 4));

	// 添加开始结束标记
	pucCommand[0] = 0x7e;

	for (int i = 0; i < iNewLen + 2; i++)
	{
		pucCommand[i+1] = pucCRCData[i];
	}

	pucCommand[iNewLen + 3] = 0x7e;

	delete[] pucCRCData;
	pucCRCData = NULL;

	typedef DWORD (*WRITE)(void*, int); 
	WRITE ComWrite = (WRITE)GetProcAddress(m_hCommDll, _T("ComWrite")); 

	if (ComWrite(pucCommand, iNewLen + 4) <= 0)
	{
		delete[] pucCommand;
		pucCommand = NULL;

		TRACE("write data to comm failed\n");
		return -1;
	}

	delete[] pucCommand;
	pucCommand = NULL;

	return iNewLen + 4;
}


int CNetToCommDlg::ReadData(BYTE8* pucReadData, int iReadLen)
{
	int iRead = 0;

	BYTE8* pucReadBuff = new BYTE8[iReadLen];

	if (NULL == pucReadBuff)
	{
		TRACE("new variable in ReadData function failed\n");
		return -1;
	}

	memset(pucReadBuff, 0, sizeof(BYTE8)*iReadLen);

	typedef DWORD (*READ)(void*); 
	READ ComRead = (READ)GetProcAddress(m_hCommDll, _T("ComRead")); 

	iRead = ComRead(pucReadBuff);

	// 如果没有读到数据
	if (iRead <= 0)
	{
		delete[] pucReadBuff;
		pucReadBuff = NULL;

		TRACE0("read data from comm failed\n");
		return -1;
	}

	int iFlag = 0;

	// 分析读到的数据
	if (0 == m_iTag)
	{
		for (int i = 0; i < iRead; i++)
		{
			if (0x7e == pucReadBuff[i])
			{
				if (0 == iFlag)
				{
					iFlag = 1;
				}
				else if (1 == iFlag)
				{
					// 开始处理整条标签信息
					iFlag = 2;
					break;
				}
			}
			else if (1 == iFlag)
			{
				m_aucTag[m_iTag++] = pucReadBuff[i];
			}
		}
	}
	else
	{
		for (int i = 0; i < iRead; i++)
		{
			if (0x7e == pucReadBuff[i])
			{
				// 开始处理整条标签信息
				iFlag = 2;
				break;
			}
			else
			{
				m_aucTag[m_iTag++] = pucReadBuff[i];
			}
		}
	}

	// 如果读到的数据是不完整的就继续读
	if (iFlag != 2)
	{
		delete[] pucReadBuff;
		pucReadBuff = NULL;

		return 0;
	}

	// 检测读到的数据中是否有特殊字符
	int iNewLen = GetReadLen(m_aucTag, m_iTag);

	// 如果读到的数据中没有特殊字符
	if (m_iTag == iNewLen)
	{
		// 将读到的标签拷贝给参数
		for (int k = 0; k < iNewLen; k++)
		{
			pucReadData[k] = m_aucTag[k];
		}
	}
	else
	{
		// 将特殊字符恢复
		CheckReadData(m_aucTag, pucReadData, m_iTag);
	}

	// 检测是否成功的读取,第3个字节为0表示成功,否则表示失败
	if (pucReadData[2] != 0)
	{
		AfxMessageBox("the result for command is failed\n");
		return -1;
	}

	// 将标签缓冲清空
    memset(m_aucTag, 0, sizeof(BYTE8)*LEN);
	m_iTag = 0;

	// 释放临时变量
	delete[] pucReadBuff;
	pucReadBuff = NULL;

	typedef char (*CRCCHECKOUT)(BYTE8*, int); 
	CRCCHECKOUT CRCCheckout = (CRCCHECKOUT)GetProcAddress(m_hCRCDll, _T("CRCCheckout")); 

	// 校验标签
	if (CRCCheckout(pucReadData, iNewLen) != 0)
	{
		TRACE("CRCCheckout failed in function ReadData\n");
		//return -1;
	}

	// 取真正的标签数据,第5个到第10个才是真正的标签数据
	pucReadData[0] = TAG_LEN;

	for (int i = 0; i < TAG_LEN; i++)
	{
		pucReadData[i+1] = pucReadData[i + 4];
	}

	//return iNewLen;
	return TAG_LEN+1;
}


int CNetToCommDlg::BYTEToChar(BYTE8 ucVar, char* pcVar)
{
	char cVar[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

	BYTE8 ucTemp;

	ucTemp = ucVar & 0xF0;
	ucTemp >>= 4;
	pcVar[0] = cVar[ucTemp];

	ucTemp = ucVar & 0x0F;
	pcVar[1] = cVar[ucTemp];

	pcVar[2] = '\0';

	return 0;
}



UINT CNetToCommDlg::ReadThread(LPVOID lParam)
{
	CNetToCommDlg *pNetToCommDlg = (CNetToCommDlg*)lParam;

	pNetToCommDlg->m_bThreadFlag = TRUE;

	int  nRead = 0, nSend = 0;

	int i, iLine;
	BYTE8 aucRead[LEN];
	char cTag[97];
	char cTemp[3];

	CString strSendData;

	// 循环读取串口的数据
	while (true)
	{
		memset(aucRead, 0, sizeof(BYTE8)*LEN);

		memset(cTag, 0, sizeof(char)*97);

		nRead = pNetToCommDlg->ReadData(aucRead, sizeof(aucRead) - 1);

		// 如果读到一次完整的标签数据
		if (nRead > 0)
		{
			// 将十六进制的标签转换为BCD码
			for (i = 0; i < nRead; i++)
			{
				pNetToCommDlg->BYTEToChar(aucRead[i], cTemp);
				strcat(cTag, cTemp);
			}

			// 将标签整理成 notification 的样子发给中间件
			nSend = send(pNetToCommDlg->m_sClient, (const char FAR *)aucRead, nRead, 0);

			if (nSend > 0)
			{
				TRACE("tag is: ");
			    TRACE(cTag);
		    	TRACE("\n");

				strSendData = cTag+2;

				pNetToCommDlg->m_listSend.AddString(strSendData);

				// 点亮最新行
				iLine = pNetToCommDlg->m_listSend.GetCount();
				pNetToCommDlg->m_listSend.SetCurSel(iLine-1);
			}
			
		}
		else
		{
			TRACE("Read tag from comm failed\n");
		}

		Sleep(1000);
	}

	return 0;
}



void CNetToCommDlg::StartListen()
{
	WSADATA wsaData;		

	if (WSAStartup(MAKEWORD(2,0), &wsaData))
	{
		WSACleanup();
		AfxMessageBox("不能够加载Windows Sockets");
		return;
	}

	if ((m_sServer = socket(PF_INET,SOCK_STREAM,0)) == INVALID_SOCKET)
	{
		AfxMessageBox("创建套接字出错");
		return;
	}

	SOCKADDR_IN tServerAddr;

	tServerAddr.sin_family = AF_INET;   
	// tServerAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
	tServerAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	tServerAddr.sin_port = htons(16000);

	if (bind(m_sServer, (LPSOCKADDR)&tServerAddr, sizeof(tServerAddr)) == SOCKET_ERROR)
	{
		AfxMessageBox("无法绑定IP地址和端口");
		return;		
	}
	
	if (listen(m_sServer, 2) == SOCKET_ERROR)
	{
		AfxMessageBox("无法监听");
		return;
	}

	// 当接到客户端连接请求就发送一个WM_SERVER_ACCEPCT消息来触发接收函数

	if (WSAAsyncSelect(m_sServer, m_hWnd, WM_CLIENT_ACCEPT, FD_ACCEPT) == SOCKET_ERROR)
	{
		AfxMessageBox("无法响应客户端的连接");
		return;		
	}
}



LRESULT CNetToCommDlg::ClientAccept(WPARAM wParam, LPARAM lParam)
{
	SOCKADDR_IN tClientAdd;

	int iLength = sizeof(SOCKADDR);

	if (WSAGETSELECTEVENT(lParam) == FD_ACCEPT)
	{
		m_sClient = accept(m_sServer, (LPSOCKADDR)&tClientAdd, (LPINT)&iLength);

		if (m_sClient == INVALID_SOCKET)
		{
			// AfxMessageBox("accepct函数无法返回一个socket!");
			return -1;
		}

		// 检测该客户端是否有数据发送过来
		WSAAsyncSelect(m_sClient, m_hWnd, WM_CLIENT_READ, FD_READ);

		return 0;
	}
	else
	{
		return -1;
	}
}


// 读取客户端发送的信息，也就是读取日志
LRESULT CNetToCommDlg::ClientRead(WPARAM wParam, LPARAM lParam)
{
	int nRead;
	BYTE8 aucReadBuff[LEN];

	memset(aucReadBuff, 0, LEN);

	// 从客户端接受数据
 	nRead = recv(m_sClient, (LPSTR)(aucReadBuff), LEN, 0);

	if (SOCKET_ERROR == nRead)
	{
		return -1;
	}

	// 将数据解析成要发送的命令格式，然后发送给阅读器
	int nWrite = 0;

	// 往串口发送指令
	nWrite = WriteData(aucReadBuff, nRead);

	if (-1 == nWrite)
	{
		return -1;
	}

	CString strRecvData;
	char acRecvData[50];
	char acTemp[3];

	memset(acRecvData, 0, sizeof(char)*50);
	memset(acTemp, 0, sizeof(char)*3);

	// 将接受的数据显示在界面
	for (int i = 0; i < nRead; i++)
	{
		BYTEToChar(aucReadBuff[i], acTemp);
		strcat(acRecvData, acTemp);
	}

	strRecvData = acRecvData;
	m_listRecv.AddString(strRecvData);
    
	// 点亮最新行
	int iLine = m_listRecv.GetCount();
	m_listRecv.SetCurSel(iLine-1);

	if (FALSE == m_bThreadFlag)
	{
		AfxBeginThread(ReadThread, this);
	}

	return 0;
}