Rs232com

// RS232COM.h: interface for the CRS232COM class.
//
//

#if !defined(AFX_RS232COM_H__B81A9E13_D764_42BB_AE18_3E296EF735C7__INCLUDED_)
#define AFX_RS232COM_H__B81A9E13_D764_42BB_AE18_3E296EF735C7__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <Windows.h>

#define FC_DTRDSR       0x01
#define FC_RTSCTS       0x02
#define FC_XONXOFF      0x04
#define ASCII_BEL       0x07
#define ASCII_BS        0x08
#define ASCII_LF        0x0A
#define ASCII_CR        0x0D
#define ASCII_XON       0x11
#define ASCII_XOFF      0x13

class CRS232COM 
{
public:
 CRS232COM();
 virtual ~CRS232COM();

 BOOL Open( int nPort = 1, int nBaud = 9600 );
 BOOL Close( void );

 int ReadData( void *buffer, int limit  );
 int SendData( unsigned  char *buffer, int size );
 int ReadDataWaiting( void );

 BOOL IsOpened( void ){ return( m_bOpened ); }

protected:
 BOOL WriteCommByte( unsigned char ucByte );
 HANDLE m_hIDComDev;
 OVERLAPPED m_OverlappedRead, m_OverlappedWrite;
 BOOL m_bOpened;
};

#endif // !defined(AFX_RS232COM_H__B81A9E13_D764_42BB_AE18_3E296EF735C7__INCLUDED_)
/*
***********************************************************************************************************
    ,CPP
***********************************************************************************************************
*/
// RS232COM.cpp: implementation of the CRS232COM class.
//
//

#include "StdAfx.h"
#include "RS232COM.h"

//
// Construction/Destruction
//

CRS232COM::CRS232COM()
{
 memset( &m_OverlappedRead, 0, sizeof( OVERLAPPED ) );
  memset( &m_OverlappedWrite, 0, sizeof( OVERLAPPED ) );

 m_hIDComDev = NULL;
 m_bOpened = FALSE;
}

CRS232COM::~CRS232COM()
{
 Close();
}

BOOL CRS232COM::Open( int nPort, int nBaud )
{

 if( m_bOpened ) return( TRUE );
 
 char szPort[15];

 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 ) );
 
 COMMTIMEOUTS CommTimeOuts;
 CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF;
 CommTimeOuts.ReadTotalTimeoutMultiplier = 0;
 CommTimeOuts.ReadTotalTimeoutConstant = 0;
 CommTimeOuts.WriteTotalTimeoutMultiplier = 0;
 CommTimeOuts.WriteTotalTimeoutConstant = 5000;
 SetCommTimeouts( m_hIDComDev, &CommTimeOuts );
   
 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 );
 }
 
 m_bOpened = TRUE;
 
 return( m_bOpened );
}

 

BOOL CRS232COM::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 );
}

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

int CRS232COM::ReadDataWaiting( void )
{
 if (!m_bOpened || m_hIDComDev == NULL )
 {
  return( 0 );
 }

 DWORD dwErrorFlags;
 COMSTAT ComStat;

 ClearCommError( m_hIDComDev, &dwErrorFlags, &ComStat );

 return( (int) ComStat.cbInQue );
} 

 

int CRS232COM::SendData( unsigned  char *buffer, int size )
{
 if (!m_bOpened || m_hIDComDev == NULL )
 {
  return( 0 );
 }

 DWORD dwBytesWritten = 0;

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

 return( (int) dwBytesWritten );
}

 

BOOL CRS232COM::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 );
}