scbc_repos/Serail-Demo/Demo/Serial.cpp

#include "stdafx.h"
#include "Serial.h"

VOID _dprintf(CHAR* pszStr, ...)
{
	const int LOGLEN = 3072;
	char szData[LOGLEN] = { 0 };
#if _MSC_VER >= 1200 && _MSC_VER < 1500
	sprintf(szData, _T("[%s %s]\n\t"), _T("Db"), CTime::GetCurrentTime().Format(_T("%H:%M:%S")));
#elif _MSC_VER >= 1500
	_stprintf_s(szData, _T("[%s %s]\n\t"), _T("Db"), CTime::GetCurrentTime().Format(_T("%H:%M:%S")).GetString());
#endif
	int len = strlen(szData);
	va_list args;
	va_start(args, pszStr);
#if _MSC_VER >= 1200 && _MSC_VER < 1500
	_vsnprintf(szData + len, LOGLEN - len, pszStr, args);
#elif _MSC_VER >= 1500
	_vsntprintf_s(szData + len, LOGLEN - len, _TRUNCATE, pszStr, args);
#endif
	va_end(args);
	if (szData[strlen(szData) - 1] != '\n')
#if _MSC_VER >= 1200 && _MSC_VER < 1500
		strcat(szData, "\n");
#elif _MSC_VER >= 1500
		strcat_s(szData, "\n");
#endif
	OutputDebugStringA(szData);
}

DCB *CBaseSerial::GetState()
{
	return IsOpen() && ::GetCommState(_hCommHandle, &_DCB) == TRUE ? &_DCB : NULL;
}

bool CBaseSerial::SetState(DCB *pdcb /*= NULL*/)
{
	return IsOpen() ? ::SetCommState(_hCommHandle, pdcb == NULL ? &_DCB : pdcb) == TRUE : false;
}

bool CBaseSerial::SetState(TCHAR *lpszSetStr /* = _T("baud=115200 parity=N data=8 stop=1") */)
{
	if (lpszSetStr && lpszSetStr[0] != '\0' && IsOpen())
	{
		if (::GetCommState(_hCommHandle, &_DCB) != TRUE)
			return false;
		// COMx[:][baud=b][parity=p][data=d][stop=s][to={on|off}][xon={on|off}][odsr={on|off}][octs={on|off}][dtr={on|off|hs}][rts={on|off|hs|tg}][idsr={on|off}]
		if (::BuildCommDCB(lpszSetStr, &_DCB) != TRUE)
			return false;
		return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
	}

	return false;
}

bool CBaseSerial::SetState(DWORD dwBaudRate, DWORD dwByteSize /* = 8 */, DWORD dwParity /* = NOPARITY */, DWORD dwStopBits /* = ONESTOPBIT */)
{
	if (!IsOpen()) return false;

	if (::GetCommState(_hCommHandle, &_DCB) != TRUE)
		return false;

	_DCB.BaudRate = dwBaudRate;
	_DCB.ByteSize = (BYTE)dwByteSize;
	_DCB.Parity = (BYTE)dwParity;
	_DCB.StopBits = (BYTE)dwStopBits;
	return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
}

LPCOMMTIMEOUTS CBaseSerial::GetTimeouts()
{
	return IsOpen() && ::GetCommTimeouts(_hCommHandle, &_CO) == TRUE ? &_CO : NULL;
}

bool CBaseSerial::SetTimeouts(DWORD ReadIntervalTimeout /* = 0 */, DWORD ReadTotalTimeoutMultiplier /* = 10 */, DWORD ReadTotalTimeoutConstant /* = 1500 */, DWORD WriteTotalTimeoutMultiplier /* = 10 */, DWORD WriteTotalTimeoutConstant /* = 1500 */)
{
	COMMTIMEOUTS CO = {
		ReadIntervalTimeout, 
		ReadTotalTimeoutMultiplier, 
		ReadTotalTimeoutConstant, 
		WriteTotalTimeoutMultiplier, 
		WriteTotalTimeoutConstant
	};
	return IsOpen() ? ::SetCommTimeouts(_hCommHandle, &CO) == TRUE : false;
}

bool CBaseSerial::SetTimeouts(LPCOMMTIMEOUTS lpCO)
{
	return IsOpen() ? ::SetCommTimeouts(_hCommHandle, lpCO) == TRUE : false;
}

bool CBaseSerial::SetBufferSize(DWORD dwInputSize, DWORD dwOutputSize)
{
	// SetupComm设置输入输出缓冲区大小;
	return IsOpen() ? ::SetupComm(_hCommHandle, dwInputSize, dwOutputSize) == TRUE : false;
}

void CBaseSerial::SetMaskEvent(DWORD dwEvent /* = DEFAULT_COM_MASK_EVENT */)
{
	_dwMaskEvent = dwEvent;
}

int CBaseSerial::GetInputSize()
{
	COMSTAT Stat;
	DWORD dwError;
	return ::ClearCommError(_hCommHandle, &dwError, &Stat) == TRUE ? Stat.cbInQue : (DWORD)-1L;
}

bool CBaseSerial::Open(DWORD dwPort)
{
	return Open(dwPort, 19200);
}

bool CBaseSerial::Open(DWORD dwPort, DWORD dwBaudRate)
{
	if (dwPort < 1 || dwPort > 1024)
		return false;

	BindCommPort(dwPort);
	if (!OpenCommPort())
		return false;
	if (!SetupPort())
		return false;

	return SetState(dwBaudRate);
}

bool CBaseSerial::Open(DWORD dwPort, TCHAR *lpszSetStr /* = _T("baud/* =115200 parity/* =N data/* =8 stop/* =1") */ )
{
	if (dwPort < 1 || dwPort > 1024)
		return false;

	BindCommPort(dwPort);
	if (!OpenCommPort())
		return false;
	if (!SetupPort())
		return false;

	return SetState(lpszSetStr);
}

DWORD CBaseSerial::Read(LPVOID Buffer, DWORD dwBufferLength, DWORD dwWaitTime /* = 100 */)
{
	if (!IsOpen())
		return 0;

	COMSTAT Stat;
	DWORD dwError;
	if (::ClearCommError(_hCommHandle, &dwError, &Stat) && dwError > 0) {
		::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR);	// 清空输入缓冲区（PURGE_RXCLEAR）
		return 0;
	}

#if 0 
	// 暂时保留：要视机器情况而定，有些响应慢缓冲区会暂时性无数据;
	if (!Stat.cbInQue)
		return 0; // 缓冲区无数据
#endif
	_dprintf("缓冲区数据量：%ld", Stat.cbInQue);

	unsigned long uReadLength = 0;
	// dwBufferLength = dwBufferLength > Stat.cbInQue ? Stat.cbInQue : dwBufferLength;//会越界;
	if (!::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength, &_ReadOverlapped))  { // 可能Buffer不够大,装不完;
		WaitForSingleObject(_ReadOverlapped.hEvent, dwWaitTime); // 等待异步操作完成;
		if (::GetLastError() == ERROR_IO_PENDING) {
			while (!::GetOverlappedResult(_hCommHandle, &_ReadOverlapped, &uReadLength, false)) {
				dwError = ::GetLastError();
				if ( dwError == ERROR_IO_PENDING ) {
					Sleep(50);
					_dprintf("读等待：%ld", dwError);
				} else if ( dwError == ERROR_SUCCESS || dwError == ERROR_IO_INCOMPLETE ) {
					_dprintf("读完成：%ld,%ld,%ld", dwError, uReadLength,_ReadOverlapped.InternalHigh);
					// 奇葩：_ReadOverlapped并不能马上出长度,在超时后才会刷新出来(不知是否与Win平台有关);
					if ( _ReadOverlapped.InternalHigh )
						uReadLength = _ReadOverlapped.InternalHigh;
					else
						uReadLength = Stat.cbInQue;
					break;
				} else {
					_dprintf("读错误：%ld", dwError);
					uReadLength = 0;
					break;
				}
			}
		}
	}

	return uReadLength;
}

char* CBaseSerial::ReadString(char *szBuffer, DWORD dwBufferLength, DWORD dwWaitTime /* = 20 */)
{
	unsigned long uReadLength = Read(szBuffer, dwBufferLength - 1, dwWaitTime);
	szBuffer[uReadLength] = '\0';
	return szBuffer;
}

DWORD CBaseSerial::Write(LPVOID Buffer, DWORD dwBufferLength)
{
	if (!IsOpen())
		return 0;

	DWORD dwError;
	if (::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0)
		::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);	// 清空输出缓冲区（PURGE_TXCLEAR）
	
	unsigned long uWriteLength = 0;
	if (!::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength, &_WriteOverlapped)) {
		if (ERROR_IO_PENDING == GetLastError()) {
			while (!GetOverlappedResult(_hCommHandle, &_WriteOverlapped, &uWriteLength, FALSE)) {
				dwError = GetLastError();
				if (ERROR_IO_PENDING == dwError) {
					_dprintf("写等待");
					continue;
				} else if (dwError == ERROR_SUCCESS || dwError == ERROR_IO_INCOMPLETE){
					uWriteLength = _WriteOverlapped.InternalHigh;
					_dprintf("写完成:%ld", dwError);
					break;
				} else {
					_dprintf("写出错:%ld",dwError);
					uWriteLength = 0;
					ClearCommError(_hCommHandle, &dwError, NULL);
					break;
				}
			}
		}
	}

	return uWriteLength;
}

DWORD CBaseSerial::Write(const TCHAR *szBuffer)
{
	assert(szBuffer);
	return Write((void *)szBuffer, _tclen(szBuffer));
}

DWORD CBaseSerial::ReadSync(LPVOID Buffer, DWORD dwBufferLength)
{
	if (!IsOpen())
		return 0;
	
	COMSTAT Stat;
	DWORD dwError;

	DWORD dwLastLen = 0;
	ULONGLONG ulTick = GetTickCount();	
	// 直到有数据为止，超时3秒;
	while (true) {// cbInQue表示输入缓冲区的字节数; 
		if (GetTickCount() - ulTick > 3000) {
			_dprintf("读出错: 超过3秒仍未读完");
			break;
		}

		if ( ::ClearCommError(_hCommHandle, &dwError, &Stat) && dwError > 0 ) {
			::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR);	// 清空输入缓冲区（PURGE_RXCLEAR）
			_dprintf("读出错: ClearCommError出错");
			break;
		}

		// 防止读一次没读完，再读一次;二次长度一样表示读完;
		if (Stat.cbInQue != 0 && dwLastLen == Stat.cbInQue)
			break;
		dwLastLen = Stat.cbInQue;
		Sleep(100);
	}

	if (Stat.cbInQue == 0) {
		// 串口超时，无数据返回;
		return 0;
	}

	if (dwBufferLength < Stat.cbInQue) {
		_dprintf("读出错: 缓冲数据过大 %ld > %ld", dwBufferLength, Stat.cbInQue);
	}

	DWORD uReadLength = 0;
	if ( !::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength, NULL) )
	{
		DWORD dwError = GetLastError();
		_dprintf("读出错：%ld", dwError);
	}

	return uReadLength;
}

DWORD CBaseSerial::WriteSync(LPVOID Buffer, DWORD dwBufferLength)
{
	if (!IsOpen())
		return 0;
	
	DWORD dwError;
	if (::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0)
		::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);	// 清空输出缓冲区（PURGE_TXCLEAR）
	
	unsigned long uWriteLength = 0;
	if ( !::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength, NULL) )
	{
		DWORD dwError = GetLastError();
		_dprintf("写出错：%ld", dwError);
	}

	return uWriteLength;
}

DWORD CBaseSerial::Write(TCHAR *szBuffer, DWORD dwBufferLength, TCHAR *szFormat, ...)
{
	if (!IsOpen())
		return 0;
	
	va_list va;
	va_start(va, szFormat);
#if _MSC_VER < 1500
	_vsnprintf(szBuffer, dwBufferLength, szFormat, va);
#elif _MSC_VER >=1500 // VC9.0以上版本;
	//_vsntprintf(szBuffer, dwBufferLength, szFormat, va);
	_vsntprintf_s(szBuffer, dwBufferLength, _TRUNCATE, szFormat, va);
#endif
	va_end(va);

	return Write(szBuffer);
}

DWORD CBaseSerial::Write(TCHAR *szBuffer, TCHAR *szFormat, ...)
{
	if (!IsOpen()) 
		return 0;
	
	va_list va;
	va_start(va, szFormat);
#if _MSC_VER < 1500       
	vsprintf(szBuffer, szFormat, va);
#elif _MSC_VER >=1500 // VC9.0以上版本;    
	_vstprintf(szBuffer, szFormat, va);
#endif
	va_end(va);

	return Write(szBuffer);
}

void CBaseSerial::Close()
{
	if (!IsOpen()) return;

	PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);	// 清空输出缓冲区（PURGE_TXCLEAR）
	::CloseHandle(_hCommHandle);
	_hCommHandle = INVALID_HANDLE_VALUE;
}

bool CBaseSerial::SetDTR(bool OnOrOff)
{
	return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETDTR : CLRDTR) : false;
}

bool CBaseSerial::SetRTS(bool OnOrOff)
{
	return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETRTS : CLRRTS) : false;
}

bool CBaseSerial::SetBreak(bool OnOrOff)
{
	return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETBREAK : CLRBREAK) : false;
}

void CBaseSerial::Init()
{
	memset(_szCommStr, 0, 20*sizeof(TCHAR));
	memset(&_DCB, 0, sizeof(_DCB));
	_DCB.DCBlength = sizeof(_DCB);
	_hCommHandle = INVALID_HANDLE_VALUE;

	memset(&_ReadOverlapped, 0, sizeof(_ReadOverlapped));
	memset(&_WriteOverlapped, 0, sizeof(_WriteOverlapped));
	_ReadOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
	assert(_ReadOverlapped.hEvent != INVALID_HANDLE_VALUE);
	_WriteOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
	assert(_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE);

	_hNotifyWnd = NULL;
	_dwNotifyNum = 0;
	_dwMaskEvent = DEFAULT_COM_MASK_EVENT;

	memset(&_WaitOverlapped, 0, sizeof(_WaitOverlapped));
	_WaitOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
	assert(_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE);
}

void CBaseSerial::UnInit()
{
	if (_ReadOverlapped.hEvent != INVALID_HANDLE_VALUE)
		CloseHandle(_ReadOverlapped.hEvent);
	if (_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE)
		CloseHandle(_WriteOverlapped.hEvent);
	if (_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE)
		CloseHandle(_WaitOverlapped.hEvent);
}

void CBaseSerial::BindCommPort(DWORD dwPort)
{
	assert(dwPort >= 1 && dwPort <= 1024);
	TCHAR p[5] = {0};
	_dwPort = dwPort;
#if _MSC_VER >= 1200 && _MSC_VER < 1500
	strcpy(_szCommStr, _T("\\\\.\\COM"));
	ltoa(_dwPort, p, 10);
	strcat(_szCommStr, p);
#elif _MSC_VER >= 1500
	_tcscpy_s(_szCommStr, _T("\\\\.\\COM"));
	_ltot_s(_dwPort, p, 10);
	_tcscat_s(_szCommStr, p);
#endif
}

bool CBaseSerial::OpenCommPort()
{
	if (IsOpen())
		Close();
	_hCommHandle = ::CreateFile(_szCommStr, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | _dwIOMode, NULL);
	return IsOpen();
}

bool CBaseSerial::SetupPort()
{
	if (!IsOpen())
		return false;
	// SetupComm设置输入输出缓冲区大小;
	if (!::SetupComm(_hCommHandle, 8192, 8192))
		return false;
	if (!::GetCommTimeouts(_hCommHandle, &_CO))
		return false;

	_CO.ReadIntervalTimeout = 0;
	_CO.ReadTotalTimeoutMultiplier = 10;
	_CO.ReadTotalTimeoutConstant = 1500;
	_CO.WriteTotalTimeoutMultiplier = 10;
	_CO.WriteTotalTimeoutConstant = 1500;
	if (!::SetCommTimeouts(_hCommHandle, &_CO))
		return false;

	// 清空输入输出缓冲区;
	if (!::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR))
		return false;

	return true;
}