rs485读写源程序 vc++代码 .cpp

=== === === ===== RS485读写源程序 VC++代码

													pRoadSvrDlg->e_pImage[1 + i * 2] = 0;
											}
											pSerial->m_pEye->nImageOdd = len - 1; //nLength;
											SetEvent(pSerial->m_pEye->m_hImageReceivedOdd);
										}
										break;
									default:
										bError = true;
									}
								}
							}
							pSerial->m_pEye->QueryReceiveImage();
							break;
						case 0x21:
						case 0x22:
							nLength = pSerial->Read(pSerial->pReceive + 5, len);
							pSerial->nReceive += nLength;
						case 0x23:
							pRoadSvrDlg->OnReceiveMeMatch(pSerial->pReceive, pSerial->nReceive);
							pRoadSvrDlg->m_dwMatchStatus |= MAT_BYIMAGE; //仅图像匹配有该报文，车牌号码匹配不在该报文的管辖范围之内（新的修改，2001年11月15日）
							break;
						case 0xF1:
							nLength = pSerial->Read(pSerial->pReceive + 5, 5);
							pSerial->nReceive += nLength;
							if (nLength == 5)
							{
								DWORD dwImageSize = *((DWORD*)(pSerial->pReceive+6));

								switch(pSerial->pReceive[5])
								{
								case 0x00:
								case 0x01:
									{
										nLength = pSerial->ReadByBlock(pSerial->m_pEye->pImage, dwImageSize, dwBlockSize);
										if (nLength < dwImageSize)
											memset(pSerial->m_pEye->pImage + nLength, 0xFF, dwImageSize - nLength);

										pSerial->m_pEye->nImageEven = dwImageSize;
										pSerial->m_pEye->nImageOdd = 0;
										pSerial->m_pEye->nImage = dwImageSize;
										ResetEvent(pSerial->m_pEye->m_hImageReceivedEven);
										ResetEvent(pSerial->m_pEye->m_hImageReceivedOdd);
										pRoadSvrDlg->OnReceiveDebugImage(pSerial->m_pEye->pImage, pSerial->m_pEye->nImage, len);
									}
									break;
								case 0x02://模拟收费计算机接收第一个车牌图片报文
									{
										nLength = pSerial->ReadByBlock(pSerial->pReceive + 10, dwImageSize, dwBlockSize);
										for (DWORD i = 0 ; i < dwImageSize ; i ++)
										{
											if (i < nLength)
												pSerial->m_pEye->pImage[i * 2] = pSerial->pReceive[10 + i];
											else
												pSerial->m_pEye->pImage[i * 2] = 0xFF;
										}
										pSerial->m_pEye->nImageEven = dwImageSize;
										SetEvent(pSerial->m_pEye->m_hImageReceivedEven);
									}
									break;
								case 0x12:
									{
										nLength = pSerial->ReadByBlock(pSerial->pReceive + 10, dwImageSize, dwBlockSize);
										for (DWORD i = 0 ; i < dwImageSize ; i ++)
										{
											if (i < nLength)
												pSerial->m_pEye->pImage[1 + i * 2] = pSerial->pReceive[10 + i];
											else
												pSerial->m_pEye->pImage[1 + i * 2] = 0xFF;
										}
										pSerial->m_pEye->nImageOdd = dwImageSize;
										SetEvent(pSerial->m_pEye->m_hImageReceivedOdd);
									}
									break;
								default:
									bError = true;
								}
							}
							else
								bError = true;

							pSerial->m_blIdle = true; //正常来说，过了这个报文就没有报文了，而下一个触发是很难预料什么时候的

							pSerial->m_pEye->QueryReceiveDebugImage(len);
							break;
						case 0x31:
#ifdef LPR_DOHERELARGE
							if (pRoadSvrDlg->m_nTriggerMethod == 1)
							{
								if (pRoadSvrDlg->m_pCaptureDlg != NULL)
								{
#ifdef CAP_DAHENG
									((CDHCaptureDlg*)(pRoadSvrDlg->m_pCaptureDlg))->Capture("", true);
#endif
								}
							}
							//else
							//if (pRoadSvrDlg->m_pCaptureDlg != NULL)
							// pRoadSvrDlg->m_pCaptureDlg->PostMessage(WM_NOTIFYCAPTURENOW, 0, 0);
#endif
							break;
						default:
							nLength = pSerial->Read(pSerial->pReceive + 5, len);
							pSerial->nReceive += nLength;
							if (nLength != len)
								bError = true;
						}
					}
				}

				if (pRoadSvrDlg->m_pDebugDlg != NULL)
					pRoadSvrDlg->m_pDebugDlg->Message(pSerial->pReceive, pSerial->nReceive, "[->] ");

				if (bError)
				{
					ClearCommError(pSerial->m_hCom, &dwErrorFlags, &ComStat);
					while(ComStat.cbInQue)
					{
						PurgeComm(pSerial->m_hCom, PURGE_RXABORT | PURGE_RXCLEAR);
						CHssApp::Idle(1);
						ClearCommError(pSerial->m_hCom, &dwErrorFlags, &ComStat);
					}
				}
			}
		}
#if 0
		if ((dwEvtMask & EV_CTS) == EV_CTS)
		{
#ifdef LPR_DOHERELARGE
			if (pRoadSvrDlg->m_nTriggerMethod == 0)
			{
				DWORD dwModemStat;
				GetCommModemStatus(pSerial->m_hCom, &dwModemStat);
				if (dwModemStat & MS_CTS_ON)
				{
					if (!blTriggered)
					{
						blTriggered = true;
						if (pRoadSvrDlg->m_pCaptureDlg != NULL)
						{
#ifdef CAP_DAHENG
							((CDHCaptureDlg*)(pRoadSvrDlg->m_pCaptureDlg))->Capture("", true);
#endif
						}
					}
				}
				else
				{
					blTriggered = false;
				}
			}
#endif
		}
#endif
	}
	pSerial->m_dwThreadID = 0;
	pSerial->m_hCommWatchThread = NULL;

	return TRUE;
}

BOOL CSerialPort::GetCommTimeouts(LPCOMMTIMEOUTS lpCommTimeouts)
{
	if (m_hCom == INVALID_HANDLE_VALUE)
		return false;
	return ::GetCommTimeouts(m_hCom, lpCommTimeouts);
}

BOOL CSerialPort::SetCommTimeouts(LPCOMMTIMEOUTS lpCommTimeouts)
{
	if (m_hCom == INVALID_HANDLE_VALUE)
		return false;
	return ::SetCommTimeouts(m_hCom, lpCommTimeouts);
}

BOOL CSerialPort::Disconnect()
{
	if (m_hCom == INVALID_HANDLE_VALUE)
		return true;

	if (!m_fConnected)
		return true;

	m_fConnected = false;

	//SetCommMask(m_hCom, 0);

	int count = 0;
	while(m_dwThreadID != 0 && count < 100)
	{
		Sleep(10);
		count ++;
	}

	EscapeCommFunction(m_hCom, CLRDTR) ;

	PurgeComm(m_hCom, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
	CloseHandle(m_hCom) ;

	m_hCom = INVALID_HANDLE_VALUE;

	return true;
}

BOOL CSerialPort::Write(LPBYTE pData, DWORD dwLength)
{
	if (m_hCom == INVALID_HANDLE_VALUE)
		return false;

	DWORD dwBytesSent = 0;
	DWORD dwBytesWritten ;
	DWORD dwErrorFlags;
	DWORD dwError;
	COMSTAT ComStat;

	BOOL fWriteStat = ::WriteFile(m_hCom, pData, dwLength, &dwBytesWritten, &m_osWrite);
	if (!fWriteStat)
	{
		if(GetLastError() == ERROR_IO_PENDING)
		{
			while(!GetOverlappedResult(m_hCom, &m_osWrite, &dwBytesWritten, false))
			{
				dwError = GetLastError();
				if(dwError == ERROR_IO_INCOMPLETE)
				{
					dwBytesSent += dwBytesWritten;
					continue;
				}
				else
				{
					ClearCommError(m_hCom, &dwErrorFlags, &ComStat ) ;
					break;
				}
			}
			dwBytesSent += dwBytesWritten;
			if( dwBytesSent != dwLength )
				return false;
		}
		else
		{
			ClearCommError( m_hCom, &dwErrorFlags, &ComStat ) ;
			if (pRoadSvrDlg->m_pDebugDlg != NULL)
				pRoadSvrDlg->m_pDebugDlg->Message(pData, dwLength, "[×] ");
			return false;
		}

	}
	if (pRoadSvrDlg->m_pDebugDlg != NULL)
		pRoadSvrDlg->m_pDebugDlg->Message(pData, dwLength, "[√] ");
	return true;
}

DWORD CSerialPort::Read(LPBYTE pData, DWORD dwLength)
{
	BOOL fReadStat;
	COMSTAT ComStat;
	DWORD dwErrorFlags;
	DWORD dwError;
	DWORD dwBytesReaded, dwBytesReceive = 0;

	fReadStat = ReadFile(m_hCom, pData, dwLength, &dwBytesReaded, &m_osRead);
	if (!fReadStat)
	{
		if (GetLastError() == ERROR_IO_PENDING)
		{
			while(!GetOverlappedResult(m_hCom, &m_osRead, &dwBytesReaded, true))
			{
				dwError = GetLastError();
				if(dwError == ERROR_IO_INCOMPLETE)
				{
					dwBytesReceive += dwBytesReaded;
					continue;
				}
				else
				{
					ClearCommError(m_hCom, &dwErrorFlags, &ComStat);
					return dwBytesReceive;
				}
			}
			dwBytesReceive += dwBytesReaded;
			return dwBytesReceive;
		}
		else
		{
			ClearCommError(m_hCom, &dwErrorFlags, &ComStat);
			return dwBytesReceive;
		}
	}
	return dwBytesReaded;
}

//0 :false 1 : first true 2 : second true 3 two true
int CSerialPort::Write(CSerialPort* pSerial1, LPBYTE pData1, DWORD dwLength1,
					   CSerialPort* pSerial2, LPBYTE pData2, DWORD dwLength2)
{
	BOOL bCom1 = (pSerial1->m_hCom != INVALID_HANDLE_VALUE && pSerial1->m_fConnected);
	BOOL bCom2 = (pSerial2->m_hCom != INVALID_HANDLE_VALUE && pSerial2->m_fConnected);
	if (!bCom1 && !bCom2)
		return 0;

	DWORD dwBytesSent1 = 0, dwBytesSent2 = 0;
	DWORD dwBytesWritten1, dwBytesWritten2 ;
	DWORD dwErrorFlags;
	DWORD dwError;
	COMSTAT ComStat;

	BOOL bFinish1 = false, bFinish2 = false;

	if (bCom1 && !WriteFile(pSerial1->m_hCom, pData1, dwLength1, &dwBytesWritten1, &pSerial1->m_osWrite))
	{
		if (GetLastError() != ERROR_IO_PENDING)
		{
			ClearCommError(pSerial1->m_hCom, &dwErrorFlags, &ComStat ) ;
			bCom1 = false;
		}
	}
	else
	{
		//dwBytesSent1 == dwBytesWritten1;
		bFinish1 = true;
	}

	if (bCom2 && !WriteFile(pSerial2->m_hCom, pData2, dwLength2, &dwBytesWritten2, &pSerial2->m_osWrite))
	{
		if (GetLastError() != ERROR_IO_PENDING)
		{
			ClearCommError(pSerial2->m_hCom, &dwErrorFlags, &ComStat ) ;
			bCom2 = false;
		}
	}
	else
	{
		//dwBytesSent2 == dwBytesWritten2;
		bFinish2 = true;
	}

	while((bCom1 && !bFinish1) || (bCom2 && !bFinish2))
	{
		if (bCom1 && !GetOverlappedResult(pSerial1->m_hCom, &pSerial1->m_osWrite, &dwBytesWritten1, false))
		{
			dwError = GetLastError();
			if(dwError == ERROR_IO_INCOMPLETE)
				;//dwBytesSent1 += dwBytesWritten1;
			else
				bCom1 = false;
		}
		else
			bFinish1 = true;
		if (bCom2 && !GetOverlappedResult(pSerial2->m_hCom, &pSerial2->m_osWrite, &dwBytesWritten2, false))
		{
			dwError = GetLastError();
			if(dwError == ERROR_IO_INCOMPLETE)
				;//dwBytesSent1 += dwBytesWritten1;
			else
				bCom2 = false;
		}
		else
			bFinish2 = true;
	}
	//return (bCom1 ? (dwBytesSent1 == dwLength1 ? 1 : 0) : 0) + (bCom2 ? (dwBytesSent2 == dwLength2 ? 2 : 0) : 0);
	return (bCom1 && bFinish1 ? 1 : 0) + (bCom2 && bFinish2 ? 2 : 0);
}

DWORD CSerialPort::ReadByBlock(LPBYTE pBuffer, DWORD dwWantSize, DWORD dwBlockSize)
{
	DWORD dwReceived = 0;
	DWORD dwReceiving = __min(dwWantSize - dwReceived, dwBlockSize);
	while(dwReceived < dwWantSize)
	{
		DWORD nLength = Read(pBuffer + dwReceived, dwReceiving);
		dwReceived += nLength;
		if (nLength != dwReceiving)
			return dwReceived;
		dwReceiving = __min(dwWantSize - dwReceived, dwBlockSize);
	}
	return dwReceived;
}