serial.cpp

一个方便又实用的C++程序

#include "Serial.h"
#include <iostream.h>
#include <memory.h>

Serial::Serial()
{
	hComm=INVALID_HANDLE_VALUE;
	::ZeroMemory(&ovRead,sizeof(ovRead));
	::ZeroMemory(&ovWrite,sizeof(ovWrite));
	::ZeroMemory(&ovCommEvent,sizeof(ovCommEvent));
	memset(recvBuf,0,RECV_BUFFER_SIZE);
	fWaitingOnWrite=FALSE;
	fWaitingOnRead=FALSE;
}
Serial::~Serial()
{
	
}

void Serial::Open(const char* pPort,DWORD dwBaud)
{
	hComm=CreateFile(
					 pPort,
					 GENERIC_READ | GENERIC_WRITE,
					 0,
					 NULL,
					 OPEN_EXISTING,
					 FILE_FLAG_OVERLAPPED,
					 NULL
					 );
	if(hComm==INVALID_HANDLE_VALUE)
	{
		cout<<"Error in CreateFile!"<<endl;
		return;
	}
	DCB dcb;
	dcb.DCBlength=sizeof(DCB);
	if(!GetCommState(hComm,&dcb))
	{
		cout<<"Error in GetCommState!"<<endl;
		return;
	}
	dcb.BaudRate=dwBaud;
	dcb.Parity=NOPARITY;
	dcb.ByteSize=8;
	dcb.StopBits=ONESTOPBIT;
	dcb.EvtChar=0x0D;////not sure!
	if(!SetCommState(hComm,&dcb))
	{
		cout<<"Error in SetCommState!"<<endl;
		return;
	}
	//设置超时时间，这个部分非常的重要
	COMMTIMEOUTS timeouts;
	timeouts.ReadIntervalTimeout=100;
	timeouts.ReadTotalTimeoutConstant=0;
	timeouts.ReadTotalTimeoutMultiplier=0;
	timeouts.WriteTotalTimeoutConstant=0;
	timeouts.WriteTotalTimeoutMultiplier=0;
	if(!SetCommTimeouts(hComm,&timeouts))
	{
		cout<<"Error in SetCommTimeouts!"<<endl;
		return;
	}
	if(!SetupComm(hComm,RECV_BUFFER_SIZE,WRITE_BUFFER_SIZE))
		cout<<"Error in SetupComm!"<<endl;
	ovRead.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);
	ovWrite.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);
	ovCommEvent.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);	
	return;
}

BOOL Serial::IsOpen() const
{
	if(hComm!=INVALID_HANDLE_VALUE)
		return TRUE;
	return FALSE;
}

BOOL Serial::WriteComm(const char*lpbuf,DWORD size)
{
	if(!IsOpen())
		return FALSE;
	if(!WriteFile(hComm, lpbuf, size, &dwWrite, &ovWrite))
	{
		if(GetLastError() != ERROR_IO_PENDING)//写操作失败！
		{
			fWaitingOnWrite=FALSE;
			cout<<"WriteFile Failed!"<<endl;
			return FALSE;
		}
		else
		{
			fWaitingOnWrite=TRUE;
			return FALSE;
		}
	}
	fWaitingOnWrite=FALSE;
	if(dwWrite!=size)
		return FALSE;
	return TRUE;
}

BOOL Serial::ReadComm(DWORD NumOfBytes)
{
	if(!IsOpen())
		return FALSE;
	if(!ReadFile(this->hComm,this->recvBuf,NumOfBytes,&this->dwRead,&this->ovRead))
	{
		if(GetLastError() != ERROR_IO_PENDING)
		{
			fWaitingOnRead=FALSE;
			cout<<"ReadFile Error!"<<endl;
			return FALSE;
		}
		else
		{
			fWaitingOnRead=TRUE;
			return FALSE;
		}
	}
	//for(int i=0;i<dwRead;i++)
	//{
	//	cout<<(int)recvBuf[i];
	//}
	fWaitingOnRead=FALSE;
	return TRUE;
}

HANDLE Serial::GetCommHandle() const
{
	return hComm;
}

BOOL Serial::WaitForWriteComplete(DWORD dwMilliseconds)
{
	if(!this->fWaitingOnWrite)
		return FALSE;
	else
	{
		DWORD dwRes=::WaitForSingleObject(this->ovWrite.hEvent,dwMilliseconds);
		switch(dwRes)
		{
		case WAIT_OBJECT_0:
			if(!GetOverlappedResult(this->hComm,&this->ovWrite,&this->dwWrite,FALSE))
			{
				cout<<"Write Error Occur!"<<endl;
				return FALSE;
			}
			else
			{
				this->fWaitingOnWrite=FALSE;
				return TRUE;
			}
			break;
		case WAIT_TIMEOUT:
			this->fWaitingOnWrite=FALSE;
			cout<<"Wait for Write TimeOut!"<<endl;
			return FALSE;
			break;
		default:
			this->fWaitingOnWrite=FALSE;
			cout<<"Error in WaitForWriteComplete!"<<endl;
			return FALSE;
		}	
	}
}

BOOL Serial::WaitForReadComplete(DWORD dwMilliseconds)
{
	if(this->fWaitingOnRead=FALSE)
		return FALSE;
	else
	{
		DWORD dwRes=::WaitForSingleObject(this->ovRead.hEvent,dwMilliseconds);
		switch(dwRes)
		{
		case WAIT_OBJECT_0:
			if(!GetOverlappedResult(this->hComm,&this->ovRead,&this->dwRead,FALSE))
			{
				this->fWaitingOnRead=FALSE;
				cout<<"Error in Read!"<<endl;
				return FALSE;
			}
			else
			{
				this->fWaitingOnRead=FALSE;
				//for(DWORD j=0;j<dwRead;j++)
				//{
				//	cout<<(int)recvBuf[j]<<endl;
				//}
				return TRUE;
			}
			break;
		case WAIT_TIMEOUT:
			this->fWaitingOnRead=FALSE;
			cout<<"Read Time out!"<<endl;
			return FALSE;
			break;
		default:
			this->fWaitingOnRead=FALSE;
			cout<<"Some Error Occured!"<<endl;
			return FALSE;
		}
	}
}

DWORD Serial::GetRecvSize() const
{
	return this->dwRead;
}

const char* Serial::GetBuffer() const
{
	return recvBuf;
}

BOOL Serial::WaitForCommEvent(DWORD dwMilliseconds)
{
	DWORD dwRes;
	if(!::WaitCommEvent(this->hComm,&this->dwWaitEvtMask,&this->ovCommEvent))
	{
		if(GetLastError()!=ERROR_IO_PENDING)
		{
			cout<<"Error in WaitCommEvent!"<<endl;
			return FALSE;
		}
		else
		{
			dwRes=::WaitForSingleObject(this->ovCommEvent.hEvent,dwMilliseconds);
			switch(dwRes)
			{
			case WAIT_OBJECT_0:
				return TRUE;
			case  WAIT_TIMEOUT:
				return FALSE;
			default:
				return FALSE;
			}
		}
	}
	return TRUE;
}

BOOL Serial::SetCommEventMask(DWORD dwEvtMask)
{
	if(!SetCommMask(this->hComm,dwEvtMask))
	{
		cout<<"Error in SetCommMask!"<<endl;
		return FALSE;
	}
	return TRUE;
}

void Serial::Close()//这个函数还需要重点地写一写！
{
	
}

void Serial::ResetCommEvent()
{
	::ResetEvent(ovCommEvent.hEvent);
}

DWORD Serial::GetCharSizeInBuf()
{
	DWORD Errors;
	COMSTAT commstate;
	::ClearCommError(this->hComm,&Errors,&commstate);
	return commstate.cbInQue;	
}

void Serial::FlushBuffer()
{
	memset(recvBuf,0,RECV_BUFFER_SIZE);
}

BOOL Serial::DCBSetting(DCB* lpdcb)
{
	if(!::SetCommState(hComm,lpdcb))
		return FALSE;
	return TRUE;
}