serial.cpp

计算机串口编程类源代码类

// Serial.cpp

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

CSerial::CSerial()
{

	memset( &m_OverlappedRead, 0, sizeof( OVERLAPPED ) );
 	memset( &m_OverlappedWrite, 0, sizeof( OVERLAPPED ) );
	m_hIDComDev = NULL;
	m_bOpened = FALSE;

}

CSerial::~CSerial()
{

	Close();

}

BOOL CSerial::Open(int nPort,int nBaud,UINT InBufSize,UINT OutBufSize)
{

	if( m_bOpened ) return( TRUE );

	char szPort[15];
	char szComParams[50];
	DCB dcb;

	wsprintf( szPort, "COM%d", nPort );
	m_hIDComDev = CreateFile( szPort, 
		            GENERIC_READ | GENERIC_WRITE, 
					0,
					NULL,
					OPEN_EXISTING, 
					FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 
					NULL );
	if( m_hIDComDev == NULL ) return( FALSE );

	memset( &m_OverlappedRead, 0, sizeof( OVERLAPPED ) );
 	memset( &m_OverlappedWrite, 0, sizeof( OVERLAPPED ) );
	m_OverlappedRead.hEvent=NULL;
	m_OverlappedWrite.hEvent=NULL;

	COMMTIMEOUTS CommTimeOuts;
	CommTimeOuts.ReadIntervalTimeout = MAXDWORD;
	CommTimeOuts.ReadTotalTimeoutMultiplier = 500;
	CommTimeOuts.ReadTotalTimeoutConstant = MAXDWORD;
	CommTimeOuts.WriteTotalTimeoutMultiplier = 500;
	CommTimeOuts.WriteTotalTimeoutConstant = MAXDWORD;
	if(SetCommTimeouts( m_hIDComDev, &CommTimeOuts )==FALSE)
		return FALSE;

	wsprintf( szComParams, "COM%d:%d,n,8,1", nPort, nBaud );

	m_OverlappedRead.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
	m_OverlappedWrite.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
	if(m_OverlappedRead.hEvent==NULL || m_OverlappedWrite.hEvent==NULL)
		return FALSE;

	dcb.DCBlength = sizeof( DCB );
	GetCommState( m_hIDComDev, &dcb );
	dcb.BaudRate = nBaud;
	dcb.ByteSize = 8;
	dcb.Parity=NOPARITY;
	dcb.StopBits=ONESTOPBIT;
	unsigned char ucSet;
	ucSet = (unsigned char) ( ( FC_RTSCTS & FC_DTRDSR ) != 0 );
	ucSet = (unsigned char) ( ( FC_RTSCTS & FC_RTSCTS ) != 0 );
	ucSet = (unsigned char) ( ( FC_RTSCTS & FC_XONXOFF ) != 0 );
	if( !SetCommState( m_hIDComDev, &dcb ) ||
		!SetupComm( m_hIDComDev, InBufSize, OutBufSize ) ||
		m_OverlappedRead.hEvent == NULL ||
		m_OverlappedWrite.hEvent == NULL )
	{
		DWORD dwError = GetLastError();
		if( m_OverlappedRead.hEvent != NULL ) CloseHandle( m_OverlappedRead.hEvent );
		if( m_OverlappedWrite.hEvent != NULL ) CloseHandle( m_OverlappedWrite.hEvent );
		CloseHandle( m_hIDComDev );
		return( FALSE );
	}

	m_bOpened = TRUE;

	return( m_bOpened );

}

BOOL CSerial::Close( void )
{

	if( !m_bOpened || m_hIDComDev == NULL ) return( TRUE );

	if( m_OverlappedRead.hEvent != NULL ) CloseHandle( m_OverlappedRead.hEvent );
	if( m_OverlappedWrite.hEvent != NULL ) CloseHandle( m_OverlappedWrite.hEvent );
	m_OverlappedRead.hEvent=NULL;
	m_OverlappedWrite.hEvent=NULL;

	CloseHandle( m_hIDComDev );
	m_bOpened = FALSE;
	m_hIDComDev = NULL;

	return( TRUE );

}

BOOL CSerial::ClearInputBuffer()
{
	return PurgeComm(m_hIDComDev,PURGE_RXCLEAR);
}

BOOL CSerial::ClearOutPutBuffer()
{
	return PurgeComm(m_hIDComDev,PURGE_TXCLEAR);
}

BOOL CSerial::WriteCommByte( unsigned char ucByte )
{
	BOOL bWriteStat;
	DWORD dwBytesWritten;

	bWriteStat = WriteFile( m_hIDComDev, (LPSTR) &ucByte, 
		           1, &dwBytesWritten, &m_OverlappedWrite );
	if( !bWriteStat && ( GetLastError() == ERROR_IO_PENDING ) )
	{
		if( WaitForSingleObject( m_OverlappedWrite.hEvent, 1000 ) ) 
			dwBytesWritten = 0;
		else
		{
			GetOverlappedResult( m_hIDComDev, &m_OverlappedWrite, &dwBytesWritten, FALSE );
			m_OverlappedWrite.Offset += dwBytesWritten;
		}
	}

	return( TRUE );

}

int CSerial::SendData( const char *buffer, int size )
{

	if( !m_bOpened || m_hIDComDev == NULL ) return( 0 );

	DWORD dwBytesWritten = 0;
	int i;
	for( i=0; i<size; i++ )
	{
		WriteCommByte( buffer[i] );
		dwBytesWritten++;
	}

	return( (int) dwBytesWritten );

}

int CSerial::ReadDataWaiting( void )
{

	if( !m_bOpened || m_hIDComDev == NULL ) return( 0 );

	DWORD dwErrorFlags;
	COMSTAT ComStat;

	ClearCommError( m_hIDComDev, &dwErrorFlags, &ComStat );

	return( (int) ComStat.cbInQue );

}

int CSerial::ReadData( void *buffer, int limit )
{

	if( !m_bOpened || m_hIDComDev == NULL ) return( 0 );

	BOOL bReadStatus;
	DWORD dwBytesRead, dwErrorFlags;
	COMSTAT ComStat;

	ClearCommError( m_hIDComDev, &dwErrorFlags, &ComStat );
	if( !ComStat.cbInQue ) return( 0 );

	dwBytesRead = (DWORD) ComStat.cbInQue;
	if( limit < (int) dwBytesRead ) 
		dwBytesRead = (DWORD) limit;

	bReadStatus = ReadFile( m_hIDComDev, buffer, 
		        dwBytesRead, &dwBytesRead, &m_OverlappedRead );
	if( !bReadStatus )
	{
		if( GetLastError() == ERROR_IO_PENDING )
		{
			WaitForSingleObject( m_OverlappedRead.hEvent, 2000 );
			return( (int) dwBytesRead );
		}
		return( 0 );
	}

	return( (int) dwBytesRead );
}


BOOL CSerial::WriteCommBlock(void* buffer,DWORD dwBytesToWrite)
{
	BOOL fWriteStat; 
	DWORD dwBytesWritten; 
	DWORD dwErrorFlags; 
	DWORD dwError; 
	COMSTAT ComStat; 
	
	fWriteStat=WriteFile(m_hIDComDev,buffer,dwBytesToWrite, 
		&dwBytesWritten,&m_OverlappedWrite); 
	
	if (!fWriteStat) 
	{ 
		if(GetLastError()==ERROR_IO_PENDING) 
		{ 
			while(!GetOverlappedResult(m_hIDComDev, 
						&m_OverlappedWrite,&dwBytesWritten,TRUE)) 
			{ 
				dwError=GetLastError(); 
				if(dwError == ERROR_IO_INCOMPLETE)
					continue; 
				else 
				{ 
					ClearCommError(m_hIDComDev,&dwErrorFlags,&ComStat); 
					break; 
				} 
			} 
		}
		else 
		{ 
			ClearCommError(m_hIDComDev,&dwErrorFlags,&ComStat); 
			return ( FALSE ); 
		} 
	}

	return ( TRUE ) ; 

	/*BOOL bWriteStat;
	DWORD dwBytesWritten;

	bWriteStat = WriteFile( m_hIDComDev, buffer, 
		           nLength, &dwBytesWritten, &m_OverlappedWrite );
	if( !bWriteStat && ( GetLastError() == ERROR_IO_PENDING ) )
	{
		if( WaitForSingleObject( m_OverlappedWrite.hEvent, 1000 ) ) 
			dwBytesWritten = 0;
		else
		{
			GetOverlappedResult( m_hIDComDev, &m_OverlappedWrite, &dwBytesWritten, TRUE );
			m_OverlappedWrite.Offset += dwBytesWritten;
		}
	}

	return( TRUE );*/
}