iceserial.cpp

Windows CE下Modem(调制解调器)源代码

/* ICESerial.cpp
 *
 * 对串口进行操作的类。
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include "stdafx.h"
#include "CSerial.h"
#include "common.h"

ICESerial::ICESerial()
{

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

}

ICESerial::~ICESerial()
{

	Close();

}

HANDLE ICESerial::GetHandle( void )
{
	return m_hIDComDev;
}

// 清除缓冲区数据。
void ICESerial::FlushCOM( void )
{
	PurgeComm( m_hIDComDev, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
}

BOOL ICESerial::Open( int nPort, int nBaud )
{
	if( m_bOpened ) 
		return( TRUE );

	char szPort[15];
	wsprintf( szPort, "COM%d", nPort );
	return OpenPort( szPort, nBaud );
}

BOOL ICESerial::OpenPort( char *szPort, int nBaud )
{

	if( m_bOpened ) 
		return( TRUE );

	DCB  dcb;

	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 ) );

	COMMTIMEOUTS CommTimeOuts;
	/*/ set the timeout values
	CommTimeOuts.ReadIntervalTimeout         = 1000;
	CommTimeOuts.ReadTotalTimeoutMultiplier  = 1000;
	CommTimeOuts.ReadTotalTimeoutConstant    = 1000;
	CommTimeOuts.WriteTotalTimeoutMultiplier = 1000;
	CommTimeOuts.WriteTotalTimeoutConstant   = 1000;
	/* * * * * * * * * * * * * * * * * * * * * * * * * * * */
	//* Set Time Out Values
	CommTimeOuts.ReadIntervalTimeout         = 0xFFFFFFFF;
	CommTimeOuts.ReadTotalTimeoutMultiplier  = 0;
	CommTimeOuts.ReadTotalTimeoutConstant    = 0;
	CommTimeOuts.WriteTotalTimeoutMultiplier = 0;
	CommTimeOuts.WriteTotalTimeoutConstant   = 5000;
	/* * * * * * * * * * * * * * * * * * * * * * * * * * * */
	SetCommTimeouts( m_hIDComDev, &CommTimeOuts );

	SetCommMask( m_hIDComDev, EV_RXCHAR | EV_CTS );

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

	dcb.DCBlength = sizeof( DCB );
	GetCommState( m_hIDComDev, &dcb );
	dcb.BaudRate = nBaud;
	dcb.ByteSize = 8;
	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, 10000, 10000 ) ||
		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 );
	}
	// flush COM
	PurgeComm(m_hIDComDev, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

	m_bOpened = TRUE;

	return( m_bOpened );

}

BOOL ICESerial::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 );
	CloseHandle( m_hIDComDev );
	m_bOpened = FALSE;
	m_hIDComDev = NULL;

	return( TRUE );

}

BOOL ICESerial::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 ICESerial::WriteComm( unsigned char *buf, int len )
{
	BOOL bWriteStat;
	DWORD dwBytesWritten;

	bWriteStat = WriteFile( m_hIDComDev, (LPSTR) buf, len, &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 len;
}

int ICESerial::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 );
}

// 发送 AT 命令。
int ICESerial::SendCommand( 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++;
	}
	char ch[2];
	ch[0]=0x0D; ch[1]='\0';
	WriteCommByte( ch[0] );

	return( (int) dwBytesWritten );
}

// 发送自定义数据结构。
int ICESerial::SendPackage( const char *buffer, int size )
{
	if( !m_bOpened || m_hIDComDev == NULL ) 
		return( 0 );

	DWORD dwBytesWritten = 0;
	WriteCommByte( SOH );				// 发送包头。
	WriteComm( (unsigned char *)buffer, size );
	/*
	for( int i=0; i<size; i++ )
	{
		WriteCommByte( buffer[i] );
		dwBytesWritten++;
	}*/
	//WriteCommByte( EOT );				// 发送包尾。

	return( (int) dwBytesWritten );
}

int ICESerial::ReadDataWaiting( void )
{

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

	DWORD dwErrorFlags;
	COMSTAT ComStat;

	ClearCommError( m_hIDComDev, &dwErrorFlags, &ComStat );

	return( (int) ComStat.cbInQue );

}

int ICESerial::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 );
			((char *)buffer)[dwBytesRead]='\0';
			return( (int) dwBytesRead );
		}
		return( 0 );
	}

	((char *)buffer)[dwBytesRead]='\0';
	return( (int) dwBytesRead );
}