CSerialPort Class Reference

#include <serialport.h>

Inheritance diagram for CSerialPort:

Collaboration diagram for CSerialPort:

Public Types
enum	FlowControl {   NoFlowControl , CtsRtsFlowControl , CtsDtrFlowControl , DsrRtsFlowControl ,   DsrDtrFlowControl , XonXoffFlowControl }
enum	Parity {   EvenParity , MarkParity , NoParity , OddParity ,   SpaceParity }
enum	StopBits { OneStopBit , OnePointFiveStopBits , TwoStopBits }

Public Member Functions
void	Attach (HANDLE hComm)
void	CancelIo ()
void	ClearBreak ()
void	ClearDTR ()
void	ClearError (DWORD &dwErrors)
void	ClearReadBuffer ()
void	ClearRTS ()
void	ClearWriteBuffer ()
void	Close ()
	CSerialPort ()
HANDLE	Detach ()
void	Escape (DWORD dwFunc)
void	Flush ()
void	GetConfig (COMMCONFIG &config)
void	GetMask (DWORD &dwMask)
void	GetModemStatus (DWORD &dwModemStatus)
void	GetOverlappedResult (OVERLAPPED &overlapped, DWORD &dwBytesTransferred, BOOL bWait)
void	GetProperties (COMMPROP &properties)
void	GetState (DCB &dcb)
void	GetStatus (COMSTAT &stat)
void	GetTimeouts (COMMTIMEOUTS &timeouts)
BOOL	IsOpen () const
virtual void	OnCompletion (DWORD dwErrorCode, DWORD dwCount, LPOVERLAPPED lpOverlapped)
void	Open (int nPort, DWORD dwBaud=9600, Parity parity=NoParity, BYTE DataBits=8, StopBits stopbits=OneStopBit, FlowControl fc=NoFlowControl, BOOL bOverlapped=FALSE)
	operator HANDLE () const
void	Purge (DWORD dwFlags)
DWORD	Read (void *lpBuf, DWORD dwCount)
BOOL	Read (void *lpBuf, DWORD dwCount, OVERLAPPED &overlapped)
void	ReadEx (void *lpBuf, DWORD dwCount)
void	Set0ReadTimeout ()
void	Set0Timeout ()
void	Set0WriteTimeout ()
void	SetBreak ()
void	SetConfig (COMMCONFIG &Config)
void	SetDTR ()
void	SetMask (DWORD dwMask)
void	SetRTS ()
void	SetState (DCB &dcb)
void	SetTimeouts (COMMTIMEOUTS &timeouts)
void	Setup (DWORD dwInQueue, DWORD dwOutQueue)
void	SetXOFF ()
void	SetXON ()
void	TerminateOutstandingReads ()
void	TerminateOutstandingWrites ()
void	TransmitChar (char cChar)
void	WaitEvent (DWORD &dwMask)
void	WaitEvent (DWORD &dwMask, OVERLAPPED &overlapped)
DWORD	Write (const void *lpBuf, DWORD dwCount)
BOOL	Write (const void *lpBuf, DWORD dwCount, OVERLAPPED &overlapped)
void	WriteEx (const void *lpBuf, DWORD dwCount)
	~CSerialPort ()

Static Public Member Functions
static void	GetDefaultConfig (int nPort, COMMCONFIG &config)
static void	SetDefaultConfig (int nPort, COMMCONFIG &config)

Static Protected Member Functions
static void WINAPI	_OnCompletion (DWORD dwErrorCode, DWORD dwCount, LPOVERLAPPED lpOverlapped)

Protected Attributes
BOOL	m_bOverlapped
HANDLE	m_hComm

Member Enumeration Documentation

FlowControl

enum CSerialPort::FlowControl

Enumerator
NoFlowControl
CtsRtsFlowControl
CtsDtrFlowControl
DsrRtsFlowControl
DsrDtrFlowControl
XonXoffFlowControl

  {
    NoFlowControl,
    CtsRtsFlowControl,
    CtsDtrFlowControl,
    DsrRtsFlowControl,
    DsrDtrFlowControl,
    XonXoffFlowControl
  };

Parity

enum CSerialPort::Parity

Enumerator
EvenParity
MarkParity
NoParity
OddParity
SpaceParity

  {    
    EvenParity,
    MarkParity,
    NoParity,
    OddParity,
    SpaceParity
  };

StopBits

enum CSerialPort::StopBits

Enumerator
OneStopBit
OnePointFiveStopBits
TwoStopBits

  {
    OneStopBit,
    OnePointFiveStopBits,
    TwoStopBits
  };

Constructor & Destructor Documentation

CSerialPort()

CSerialPort::CSerialPort

(

)

{
  m_hComm = INVALID_HANDLE_VALUE;
  m_bOverlapped = FALSE;
}

~CSerialPort()

CSerialPort::~CSerialPort

(

)

{
  Close();
}

Member Function Documentation

_OnCompletion()

void CSerialPort::_OnCompletion ( DWORD  dwErrorCode, DWORD  dwCount, LPOVERLAPPED  lpOverlapped  )

staticprotected

{
  //Validate our parameters
  ASSERT(lpOverlapped);
 
  //Convert back to the C++ world
  CSerialPort* pSerialPort = (CSerialPort*) lpOverlapped->hEvent;
  ASSERT(pSerialPort->IsKindOf(RUNTIME_CLASS(CSerialPort)));
 
  //Call the C++ function
  pSerialPort->OnCompletion(dwErrorCode, dwCount, lpOverlapped);
}

Attach()

void CSerialPort::Attach

(

HANDLE

hComm

)

{
  Close();
  m_hComm = hComm;  
}

CancelIo()

void CSerialPort::CancelIo

(

)

{
  ASSERT(IsOpen());
 
  if (_SerialPortData.m_lpfnCancelIo == NULL)
  {
    TRACE(_T("CancelIo function is not supported on this OS. You need to be running at least NT 4 or Win 98 to use this function\n"));
    AfxThrowSerialException(ERROR_CALL_NOT_IMPLEMENTED);  
  }
 
  if (!::_SerialPortData.m_lpfnCancelIo(m_hComm))
  {
    TRACE(_T("Failed in call to CancelIO\n"));
    AfxThrowSerialException();
  }
}

ClearBreak()

void CSerialPort::ClearBreak

(

)

{
  ASSERT(IsOpen());
 
  if (!ClearCommBreak(m_hComm))
  {
    TRACE(_T("Failed in call to SetCommBreak\n"));
    AfxThrowSerialException();
  }
}

ClearDTR()

void CSerialPort::ClearDTR

(

)

{
  Escape(CLRDTR);
}

ClearError()

void CSerialPort::ClearError

(

DWORD &

dwErrors

)

{
  ASSERT(IsOpen());
 
  if (!ClearCommError(m_hComm, &dwErrors, NULL))
  {
    TRACE(_T("Failed in call to ClearCommError\n"));
    AfxThrowSerialException();
  }
}

ClearReadBuffer()

void CSerialPort::ClearReadBuffer

(

)

{
  Purge(PURGE_RXCLEAR);
}

ClearRTS()

void CSerialPort::ClearRTS

(

)

{
  Escape(CLRRTS);
}

ClearWriteBuffer()

void CSerialPort::ClearWriteBuffer

(

)

{
  Purge(PURGE_TXCLEAR);
}

Close()

void CSerialPort::Close

(

)

{
  if (IsOpen())
  {
    BOOL bSuccess = CloseHandle(m_hComm);
    m_hComm = INVALID_HANDLE_VALUE;
    if (!bSuccess)
      TRACE(_T("Failed to close up the comms port, GetLastError:%d\n"), GetLastError());
    m_bOverlapped = FALSE;
  }
}

Detach()

HANDLE CSerialPort::Detach

(

)

{
  HANDLE hrVal = m_hComm;
  m_hComm = INVALID_HANDLE_VALUE;
  return hrVal;
}

Escape()

void CSerialPort::Escape

(

DWORD

dwFunc

)

{
  ASSERT(IsOpen());
 
  if (!EscapeCommFunction(m_hComm, dwFunc))
  {
    TRACE(_T("Failed in call to EscapeCommFunction\n"));
    AfxThrowSerialException();
  }
}

Flush()

void CSerialPort::Flush

(

)

{
  ASSERT(IsOpen());
 
  if (!FlushFileBuffers(m_hComm))
  {
    TRACE(_T("Failed in call to FlushFileBuffers\n"));
    AfxThrowSerialException();
  }
}

GetConfig()

void CSerialPort::GetConfig

(

COMMCONFIG &

config

)

{
  ASSERT(IsOpen());
 
  DWORD dwSize = sizeof(COMMCONFIG);
  if (!GetCommConfig(m_hComm, &config, &dwSize))
  {
    TRACE(_T("Failed in call to GetCommConfig\n"));
    AfxThrowSerialException();
  }
}

GetDefaultConfig()

void CSerialPort::GetDefaultConfig ( int  nPort, COMMCONFIG &  config  )

static

{
  //Validate our parameters
  ASSERT(nPort>0 && nPort<=255);
 
  //Create the device name as a string
  CString sPort;
  sPort.Format(_T("COM%d"), nPort);
 
  DWORD dwSize = sizeof(COMMCONFIG);
  if (!GetDefaultCommConfig(sPort, &config, &dwSize))
  {
    TRACE(_T("Failed in call to GetDefaultCommConfig\n"));
    AfxThrowSerialException();
  }
}

GetMask()

void CSerialPort::GetMask

(

DWORD &

dwMask

)

{
  ASSERT(IsOpen());
 
  if (!GetCommMask(m_hComm, &dwMask))
  {
    TRACE(_T("Failed in call to GetCommMask\n"));
    AfxThrowSerialException();
  }
}

GetModemStatus()

void CSerialPort::GetModemStatus

(

DWORD &

dwModemStatus

)

{
  ASSERT(IsOpen());
 
  if (!GetCommModemStatus(m_hComm, &dwModemStatus))
  {
    TRACE(_T("Failed in call to GetCommModemStatus\n"));
    AfxThrowSerialException();
  }
}

GetOverlappedResult()

void CSerialPort::GetOverlappedResult	(	OVERLAPPED &	overlapped,
		DWORD &	dwBytesTransferred,
		BOOL	bWait
	)

{
  ASSERT(IsOpen());
  ASSERT(m_bOverlapped);
  ASSERT(overlapped.hEvent);
 
  DWORD dwBytesWritten = 0;
  if (!::GetOverlappedResult(m_hComm, &overlapped, &dwBytesTransferred, bWait))
  {
    if (GetLastError() != ERROR_IO_PENDING)
    {
      TRACE(_T("Failed in call to GetOverlappedResult\n"));
      AfxThrowSerialException();
    }
  }
}

GetProperties()

void CSerialPort::GetProperties

(

COMMPROP &

properties

)

{
  ASSERT(IsOpen());
 
  if (!GetCommProperties(m_hComm, &properties))
  {
    TRACE(_T("Failed in call to GetCommProperties\n"));
    AfxThrowSerialException();
  }
}

GetState()

void CSerialPort::GetState

(

DCB &

dcb

)

{
  ASSERT(IsOpen());
 
  if (!GetCommState(m_hComm, &dcb))
  {
    TRACE(_T("Failed in call to GetCommState\n"));
    AfxThrowSerialException();
  }
}

GetStatus()

void CSerialPort::GetStatus

(

COMSTAT &

stat

)

{
  ASSERT(IsOpen());
 
  DWORD dwErrors;
  if (!ClearCommError(m_hComm, &dwErrors, &stat))
  {
    TRACE(_T("Failed in call to ClearCommError\n"));
    AfxThrowSerialException();
  }
}

GetTimeouts()

void CSerialPort::GetTimeouts

(

COMMTIMEOUTS &

timeouts

)

{
  ASSERT(IsOpen());
 
  if (!GetCommTimeouts(m_hComm, &timeouts))
  {
    TRACE(_T("Failed in call to GetCommTimeouts\n"));
    AfxThrowSerialException();
  }
}

IsOpen()

BOOL CSerialPort::IsOpen ( ) const

inline

{ return m_hComm != INVALID_HANDLE_VALUE; };

OnCompletion()

void CSerialPort::OnCompletion ( DWORD  dwErrorCode, DWORD  dwCount, LPOVERLAPPED  lpOverlapped  )

virtual

{
  //Just free up the memory which was previously allocated for the OVERLAPPED structure
  delete lpOverlapped;
 
  //Your derived classes can do something useful in OnCompletion, but don't forget to
  //call CSerialPort::OnCompletion to ensure the memory is freed up
}

Open()

void CSerialPort::Open	(	int	nPort,
		DWORD	dwBaud = 9600,
		Parity	parity = NoParity,
		BYTE	DataBits = 8,
		StopBits	stopbits = OneStopBit,
		FlowControl	fc = NoFlowControl,
		BOOL	bOverlapped = FALSE
	)

{
  //Validate our parameters
  ASSERT(nPort>0 && nPort<=255);
 
  //Call CreateFile to open up the comms port
  CString sPort;
  sPort.Format(_T("\\\\.\\COM%d"), nPort);
  m_hComm = CreateFile(sPort, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, bOverlapped ? FILE_FLAG_OVERLAPPED : 0, NULL);
  if (m_hComm == INVALID_HANDLE_VALUE)
  {
    TRACE(_T("Failed to open up the comms port\n"));
    AfxThrowSerialException();
  }
  
  m_bOverlapped = bOverlapped;
 
  //Get the current state prior to changing it
  DCB dcb;
  GetState(dcb);
 
  //Setup the baud rate
  dcb.BaudRate = dwBaud; 
 
  //Setup the Parity
  switch (parity)
  {
    case EvenParity:  dcb.Parity = EVENPARITY;  break;
    case MarkParity:  dcb.Parity = MARKPARITY;  break;
    case NoParity:    dcb.Parity = NOPARITY;    break;
    case OddParity:   dcb.Parity = ODDPARITY;   break;
    case SpaceParity: dcb.Parity = SPACEPARITY; break;
    default:          ASSERT(FALSE);            break;
  }
 
  //Setup the data bits
  dcb.ByteSize = DataBits;
 
  //Setup the stop bits
  switch (stopbits)
  {
    case OneStopBit:           dcb.StopBits = ONESTOPBIT;   break;
    case OnePointFiveStopBits: dcb.StopBits = ONE5STOPBITS; break;
    case TwoStopBits:          dcb.StopBits = TWOSTOPBITS;  break;
    default:                   ASSERT(FALSE);               break;
  }
 
  //Setup the flow control 
  dcb.fDsrSensitivity = FALSE;
  switch (fc)
  {
    case NoFlowControl:
    {
      dcb.fOutxCtsFlow = FALSE;
      dcb.fOutxDsrFlow = FALSE;
      dcb.fOutX = FALSE;
      dcb.fInX = FALSE;
      break;
    }
    case CtsRtsFlowControl:
    {
      dcb.fOutxCtsFlow = TRUE;
      dcb.fOutxDsrFlow = FALSE;
      dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
      dcb.fOutX = FALSE;
      dcb.fInX = FALSE;
      break;
    }
    case CtsDtrFlowControl:
    {
      dcb.fOutxCtsFlow = TRUE;
      dcb.fOutxDsrFlow = FALSE;
      dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
      dcb.fOutX = FALSE;
      dcb.fInX = FALSE;
      break;
    }
    case DsrRtsFlowControl:
    {
      dcb.fOutxCtsFlow = FALSE;
      dcb.fOutxDsrFlow = TRUE;
      dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
      dcb.fOutX = FALSE;
      dcb.fInX = FALSE;
      break;
    }
    case DsrDtrFlowControl:
    {
      dcb.fOutxCtsFlow = FALSE;
      dcb.fOutxDsrFlow = TRUE;
      dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
      dcb.fOutX = FALSE;
      dcb.fInX = FALSE;
      break;
    }
    case XonXoffFlowControl:
    {
      dcb.fOutxCtsFlow = FALSE;
      dcb.fOutxDsrFlow = FALSE;
      dcb.fOutX = TRUE;
      dcb.fInX = TRUE;
      dcb.XonChar = 0x11;
      dcb.XoffChar = 0x13;
      dcb.XoffLim = 100;
      dcb.XonLim = 100;
      break;
    }
    default:
    {
      ASSERT(FALSE);
      break;
    }
  }
  
  //Now that we have all the settings in place, make the changes
  SetState(dcb);
}

operator HANDLE()

CSerialPort::operator HANDLE ( ) const

inline

{ return m_hComm; };

Purge()

void CSerialPort::Purge

(

DWORD

dwFlags

)

{
  ASSERT(IsOpen());
 
  if (!PurgeComm(m_hComm, dwFlags))
  {
    TRACE(_T("Failed in call to PurgeComm\n"));
    AfxThrowSerialException();
  }
}

Read() [1/2]

DWORD CSerialPort::Read	(	void *	lpBuf,
		DWORD	dwCount
	)

{
  ASSERT(IsOpen());
  ASSERT(!m_bOverlapped);
 
  DWORD dwBytesRead = 0;
  if (!ReadFile(m_hComm, lpBuf, dwCount, &dwBytesRead, NULL))
  {
    TRACE(_T("Failed in call to ReadFile\n"));
    AfxThrowSerialException();
  }
 
  return dwBytesRead;
}

Read() [2/2]

BOOL CSerialPort::Read	(	void *	lpBuf,
		DWORD	dwCount,
		OVERLAPPED &	overlapped
	)

{
  ASSERT(IsOpen());
  ASSERT(m_bOverlapped);
  ASSERT(overlapped.hEvent);
 
  DWORD dwBytesRead = 0;
  BOOL bSuccess = ReadFile(m_hComm, lpBuf, dwCount, &dwBytesRead, &overlapped);
  if (!bSuccess)
  {
    if (GetLastError() != ERROR_IO_PENDING)
    {
      TRACE(_T("Failed in call to ReadFile\n"));
      AfxThrowSerialException();
    }
  }
  return bSuccess;
}

ReadEx()

void CSerialPort::ReadEx	(	void *	lpBuf,
		DWORD	dwCount
	)

{
  ASSERT(IsOpen());
 
  OVERLAPPED* pOverlapped = new OVERLAPPED;
  ZeroMemory(pOverlapped, sizeof(OVERLAPPED));
  pOverlapped->hEvent = (HANDLE) this;
  if (!ReadFileEx(m_hComm, lpBuf, dwCount, pOverlapped, _OnCompletion))
  {
    delete pOverlapped;
    TRACE(_T("Failed in call to ReadFileEx\n"));
    AfxThrowSerialException();
  }
}

Set0ReadTimeout()

void CSerialPort::Set0ReadTimeout

(

)

{
  COMMTIMEOUTS Timeouts;
  GetTimeouts(Timeouts);
  Timeouts.ReadIntervalTimeout = MAXDWORD;
  Timeouts.ReadTotalTimeoutMultiplier = 0;
  Timeouts.ReadTotalTimeoutConstant = 0;
  SetTimeouts(Timeouts);
}

Set0Timeout()

void CSerialPort::Set0Timeout

(

)

{
  COMMTIMEOUTS Timeouts;
  ZeroMemory(&Timeouts, sizeof(COMMTIMEOUTS));
  Timeouts.ReadIntervalTimeout = MAXDWORD;
  Timeouts.ReadTotalTimeoutMultiplier = 0;
  Timeouts.ReadTotalTimeoutConstant = 0;
  Timeouts.WriteTotalTimeoutMultiplier = 0;
  Timeouts.WriteTotalTimeoutConstant = 0;
  SetTimeouts(Timeouts);
}

Set0WriteTimeout()

void CSerialPort::Set0WriteTimeout

(

)

{
  COMMTIMEOUTS Timeouts;
  GetTimeouts(Timeouts);
  Timeouts.WriteTotalTimeoutMultiplier = 0;
  Timeouts.WriteTotalTimeoutConstant = 0;
  SetTimeouts(Timeouts);
}

SetBreak()

void CSerialPort::SetBreak

(

)

{
  ASSERT(IsOpen());
 
  if (!SetCommBreak(m_hComm))
  {
    TRACE(_T("Failed in call to SetCommBreak\n"));
    AfxThrowSerialException();
  }
}

SetConfig()

void CSerialPort::SetConfig

(

COMMCONFIG &

Config

)

{
  ASSERT(IsOpen());
 
  DWORD dwSize = sizeof(COMMCONFIG);
  if (!SetCommConfig(m_hComm, &config, dwSize))
  {
    TRACE(_T("Failed in call to SetCommConfig\n"));
    AfxThrowSerialException();
  }
}

SetDefaultConfig()

void CSerialPort::SetDefaultConfig ( int  nPort, COMMCONFIG &  config  )

static

{
  //Validate our parameters
  ASSERT(nPort>0 && nPort<=255);
 
  //Create the device name as a string
  CString sPort;
  sPort.Format(_T("COM%d"), nPort);
 
  DWORD dwSize = sizeof(COMMCONFIG);
  if (!SetDefaultCommConfig(sPort, &config, dwSize))
  {
    TRACE(_T("Failed in call to GetDefaultCommConfig\n"));
    AfxThrowSerialException();
  }
}

SetDTR()

void CSerialPort::SetDTR

(

)

{
  Escape(SETDTR);
}

SetMask()

void CSerialPort::SetMask

(

DWORD

dwMask

)

{
  ASSERT(IsOpen());
 
  if (!SetCommMask(m_hComm, dwMask))
  {
    TRACE(_T("Failed in call to SetCommMask\n"));
    AfxThrowSerialException();
  }
}

SetRTS()

void CSerialPort::SetRTS

(

)

{
  Escape(SETRTS);
}

SetState()

void CSerialPort::SetState

(

DCB &

dcb

)

{
  ASSERT(IsOpen());
 
  if (!SetCommState(m_hComm, &dcb))
  {
    TRACE(_T("Failed in call to SetCommState\n"));
    AfxThrowSerialException();
  }
}

SetTimeouts()

void CSerialPort::SetTimeouts

(

COMMTIMEOUTS &

timeouts

)

{
  ASSERT(IsOpen());
 
  if (!SetCommTimeouts(m_hComm, &timeouts))
  {
    TRACE(_T("Failed in call to SetCommTimeouts\n"));
    AfxThrowSerialException();
  }
}

Setup()

void CSerialPort::Setup	(	DWORD	dwInQueue,
		DWORD	dwOutQueue
	)

{
  ASSERT(IsOpen());
 
  if (!SetupComm(m_hComm, dwInQueue, dwOutQueue))
  {
    TRACE(_T("Failed in call to SetupComm\n"));
    AfxThrowSerialException();
  }
}

SetXOFF()

void CSerialPort::SetXOFF

(

)

{
  Escape(SETXOFF);
}

SetXON()

void CSerialPort::SetXON

(

)

{
  Escape(SETXON);
}

TerminateOutstandingReads()

void CSerialPort::TerminateOutstandingReads

(

)

{
  Purge(PURGE_RXABORT);
}

TerminateOutstandingWrites()

void CSerialPort::TerminateOutstandingWrites

(

)

{
  Purge(PURGE_TXABORT);
}

TransmitChar()

void CSerialPort::TransmitChar

(

char

cChar

)

{
  ASSERT(IsOpen());
 
  if (!TransmitCommChar(m_hComm, cChar))
  {
    TRACE(_T("Failed in call to TransmitCommChar\n"));
    AfxThrowSerialException();
  }
}

WaitEvent() [1/2]

void CSerialPort::WaitEvent

(

DWORD &

dwMask

)

{
  ASSERT(IsOpen());
  ASSERT(!m_bOverlapped);
 
  if (!WaitCommEvent(m_hComm, &dwMask, NULL))
  {
    TRACE(_T("Failed in call to WaitCommEvent\n"));
    AfxThrowSerialException();
  }
}

WaitEvent() [2/2]

void CSerialPort::WaitEvent	(	DWORD &	dwMask,
		OVERLAPPED &	overlapped
	)

{
  ASSERT(IsOpen());
  ASSERT(m_bOverlapped);
  ASSERT(overlapped.hEvent);
 
  if (!WaitCommEvent(m_hComm, &dwMask, &overlapped))
  {
    if (GetLastError() != ERROR_IO_PENDING)
    {
      TRACE(_T("Failed in call to WaitCommEvent\n"));
      AfxThrowSerialException();
    }
  }
}

Write() [1/2]

DWORD CSerialPort::Write	(	const void *	lpBuf,
		DWORD	dwCount
	)

{
  ASSERT(IsOpen());
  ASSERT(!m_bOverlapped);
 
  DWORD dwBytesWritten = 0;
  if (!WriteFile(m_hComm, lpBuf, dwCount, &dwBytesWritten, NULL))
  {
    TRACE(_T("Failed in call to WriteFile\n"));
    AfxThrowSerialException();
  }
 
  return dwBytesWritten;
}

Write() [2/2]

BOOL CSerialPort::Write	(	const void *	lpBuf,
		DWORD	dwCount,
		OVERLAPPED &	overlapped
	)

{
  ASSERT(IsOpen());
  ASSERT(m_bOverlapped);
  ASSERT(overlapped.hEvent);
 
  DWORD dwBytesWritten = 0;
  BOOL bSuccess = WriteFile(m_hComm, lpBuf, dwCount, &dwBytesWritten, &overlapped);
  if (!bSuccess)
  {
    if (GetLastError() != ERROR_IO_PENDING)
    {
      TRACE(_T("Failed in call to WriteFile\n"));
      AfxThrowSerialException();
    }
  }
  return bSuccess;
}

WriteEx()

void CSerialPort::WriteEx	(	const void *	lpBuf,
		DWORD	dwCount
	)

{
  ASSERT(IsOpen());
 
  OVERLAPPED* pOverlapped = new OVERLAPPED;
  ZeroMemory(pOverlapped, sizeof(OVERLAPPED));
  pOverlapped->hEvent = (HANDLE) this;
  if (!WriteFileEx(m_hComm, lpBuf, dwCount, pOverlapped, _OnCompletion))
  {
    delete pOverlapped;
    TRACE(_T("Failed in call to WriteFileEx\n"));
    AfxThrowSerialException();
  }
}

Member Data Documentation

m_bOverlapped

BOOL CSerialPort::m_bOverlapped

protected

m_hComm

HANDLE CSerialPort::m_hComm

protected

---

The documentation for this class was generated from the following files:

• src/libACQ/serialport.h
• src/libACQ/serialport.cpp