Knowledge Base Nr: 00048 serial_com_class.cpp - http://www.swe-kaiser.de

Downloads:

Win32: wrapper class for API functions for serial communication RS232
derived from TTY SDK sample (supports overlapped IO)

  
/**************************************************************/
/*************** H FILE *************************************/
/**************************************************************/
/**************************************************************/

#if !defined(__RS232__)
#define __RS232__

// wrapper class for API functions for serial communication RS232
// derived from TTY SDK sample

//receive rs232 buffer size
#define MAX_INBUFFER (10*1024)

class CCommunication: public CObject
{
private:
  //flag for connection state
  BOOL    m_bIsConnected;

  //RS232 port number (range 0..255)
  int     m_nPort;

  //rcs232 port settings:
  DWORD   m_dwBaudRate;   //CBR_110, CBR_300, CBR_600, CBR_1200, CBR_2400,
                          //CBR_4800, CBR_9600, CBR_14400, CBR_19200, CBR_38400,
                          //CBR_56000, CBR_128000, CBR_256000
  int     m_nParity;      //NOPARITY, EVENPARITY, ODDPARITY, MARKPARITY, SPACEPARITY
  int     m_nByteSize;
  int     m_nStopBits;    //ONESTOPBIT, ONE5STOPBITS, TWOSTOPBITS

  //handshake:
  BOOL    m_bDTRDSR;
  BOOL    m_bRTSCTS;
  BOOL    m_bXONXOFF;

    //events for thread implementation
  OVERLAPPED  m_osWrite, m_osRead ;

  DWORD m_dwReadTotalTimeoutConstant;

protected:
  //receiving buffer
  BYTE  m_byRecvBuffer[MAX_INBUFFER];
  int   m_nRecvBufferPos;

  //free port and clear memory
  int CleanUpPortInfo();

  //setup communication parameters
  int SetupConnection();

public:
  virtual ~CCommunication();
  CCommunication();

  void SetConnected(BOOL bIsConnected) { m_bIsConnected = bIsConnected; }

  //handles and ids for rs232 api-functions
  //(public because used within thread procedure)
  //SHOULD NOT ACCESSED DIRECTLY OUTSIDE THIS CLASS!
  HANDLE  m_nIdComDev;
  DWORD   m_dwThreadID;
  HANDLE  m_hWatchThread;

public:
  //setup communication interface; allocate port
  int SetupPortInfo(int nPortNo);

  //allocate com port
  int OpenConnection(int nPortNo, BOOL bUseThread);

  //free com port
  int CloseConnection();

  //write characters via rs232. returns GetLastError()
  int WriteCommBlock(LPBYTE lpByte , DWORD dwBytesToWrite);

  //read characters via rs232. returns GetLastError(), -1 if buffer too small, -2 if timeout
  //waits for nExpectedRecvLength characters (if nExpectedRecvLength > 0).
  int ReadCommBlock(LPBYTE lpszBlock, int nMaxLength, int nExpectedRecvLength, int* nBytesRead);

  //callback interface for thread implementation
  //overwrite this function in a derived class for asynchron receive
  //(requires call OpenConnection(bUseThread = TRUE))
  virtual int CommReceived(LPSTR szData, int nLength);

  //wait dwWaitMiliSecs ms for still incoming characters and purge the rs232 buffers
  void ClearBuffers(DWORD dwWaitMiliSecs = 0);

  //connection state
  BOOL IsConnected() { return m_bIsConnected; }
};

//receiving thread
DWORD FAR PASCAL CommWatchProc( LPSTR );

// constant definitions
#define MAXBLOCK        80

#define ASCII_XON       0x11
#define ASCII_XOFF      0x13

// Flow control flags
#define FC_DTRDSR       0x01
#define FC_RTSCTS       0x02
#define FC_XONXOFF      0x04

#endif //__RS232__

/**************************************************************/
/*************** CPP FILE *************************************/
/**************************************************************/
/**************************************************************/

#include "stdafx.h"

#include "rs232.h"

CCommunication::CCommunication()
{
  m_nIdComDev = NULL;

  m_bIsConnected       = FALSE ;

  m_dwReadTotalTimeoutConstant = 1000;

  ZeroMemory(m_byRecvBuffer, MAX_INBUFFER);
  m_nRecvBufferPos = 0;

  m_osRead.hEvent = NULL;
  m_osWrite.hEvent = NULL;

  m_dwThreadID = 0;
  m_hWatchThread = NULL;
}


CCommunication::~CCommunication ()
{
  int nErr = CleanUpPortInfo();
  ASSERT(nErr == 0);
}


/////////////////////////////////////////////////////////////////////////////
//function: SetupPortInfo
//setup communication interface; allocate port
//
int CCommunication::SetupPortInfo(int nPortNo)
{
  CleanUpPortInfo();

  //free handle if already used
  if (m_nIdComDev != NULL)
    CloseHandle(m_nIdComDev);
  m_nIdComDev          = NULL;

  //restore settings from last session (ini-file)
  m_nPort         = nPortNo;
  m_dwBaudRate    = CBR_9600;
  m_nParity       = NOPARITY;
  m_nByteSize     = 8;
  m_nStopBits     = ONESTOPBIT;
  m_bDTRDSR       = FALSE;
  m_bRTSCTS       = FALSE;
  m_bXONXOFF      = FALSE;

  m_dwReadTotalTimeoutConstant = 1000;

  m_osWrite.Offset     = 0 ;
  m_osWrite.OffsetHigh = 0 ;
  m_osRead.Offset      = 0 ;
  m_osRead.OffsetHigh  = 0 ;

  // create I/O event used for overlapped reads / writes
  m_osRead.hEvent = CreateEvent(NULL,    // no security
                                TRUE,    // explicit reset req
                                FALSE,   // initial event reset
                                NULL);   // no name
  if (m_osRead.hEvent == NULL)
  {
    ASSERT(FALSE);
    return GetLastError();
  }

  m_osWrite.hEvent = CreateEvent( NULL,    // no security
                                TRUE,    // explicit reset req
                                FALSE,   // initial event reset
                                NULL ) ; // no name
  if (m_osWrite.hEvent == NULL)
  {
    ASSERT(FALSE);
    CloseHandle(m_osRead.hEvent);
    return GetLastError();
  }

  return 0;
}


/////////////////////////////////////////////////////////////////////////////
//function: CleanUpPortInfo
//free port and clear memory
//
int CCommunication::CleanUpPortInfo()
{
  // force connection closed (if not already closed)
  if (m_bIsConnected)
    CloseConnection();

  // clean up event objects
  if (m_osRead.hEvent != NULL)
    CloseHandle(m_osRead.hEvent);

  if (m_osRead.hEvent != NULL)
    CloseHandle(m_osWrite.hEvent);

  return 0;
}


/////////////////////////////////////////////////////////////////////////////
//function: CloseConnection
//free com port
//
int CCommunication::CloseConnection()
{
  // disable event notification and wait for thread
  // to halt
  SetCommMask(m_nIdComDev, 0);

  //wait for thread termination
  SetConnected(FALSE);
  while(m_dwThreadID != 0)
    Sleep(5);

  // drop DTR
  EscapeCommFunction(m_nIdComDev, CLRDTR);

  // purge any outstanding reads/writes and close device handle
  PurgeComm(m_nIdComDev, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );

  CloseHandle(m_nIdComDev);
  m_nIdComDev = NULL;

  //reset buffer
  ZeroMemory(m_byRecvBuffer, MAX_INBUFFER);
  m_nRecvBufferPos = 0;

  return 0;
}


/////////////////////////////////////////////////////////////////////////////
//function: OpenConnection
//allocate com port
//
int CCommunication::OpenConnection(int nPortNo, BOOL bUseThread)
{
  SetupPortInfo(nPortNo);

  HANDLE        hCommWatchThread;
  DWORD         dwThreadID;
  COMMTIMEOUTS  CommTimeOuts;

  // load the COM prefix string and append port number
  CString strPort;
  strPort.Format("COM%d", m_nPort);

  // open COMM device
  HANDLE hCOMDEV = CreateFile(strPort, GENERIC_READ | GENERIC_WRITE,
                              0,                    // exclusive access
                              NULL,                 // no security attrs
                              OPEN_EXISTING,
                              FILE_ATTRIBUTE_NORMAL |
                              FILE_FLAG_OVERLAPPED, // overlapped I/O
                              NULL );
  if (hCOMDEV == INVALID_HANDLE_VALUE )
  {
    ASSERT(FALSE);
    return GetLastError();
  }
  else
  {
    m_nIdComDev = hCOMDEV;
    // get any early notifications
    SetCommMask(m_nIdComDev, EV_RXCHAR ) ;

    // setup device buffers
    SetupComm(m_nIdComDev, 4096, 4096 ) ;

    // purge any information in the buffer
    PurgeComm(m_nIdComDev, PURGE_TXABORT | PURGE_RXABORT |
                           PURGE_TXCLEAR | PURGE_RXCLEAR ) ;

    // set up for overlapped I/O
    CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF ;
    CommTimeOuts.ReadTotalTimeoutMultiplier = 0 ;
    CommTimeOuts.ReadTotalTimeoutConstant = m_dwReadTotalTimeoutConstant;
    // CBR_9600 is approximately 1byte/ms. For our purposes, allow
    // double the expected time per character for a fudge factor.
    CommTimeOuts.WriteTotalTimeoutMultiplier = 2;
    CommTimeOuts.WriteTotalTimeoutConstant = 0 ;
    SetCommTimeouts(m_nIdComDev, &CommTimeOuts ) ;
  }

  int nError = SetupConnection();

  if (!nError)
  {
    m_bIsConnected = TRUE ;

    if (bUseThread)
    {
      // Create a secondary thread to watch for an event.
      hCommWatchThread = CreateThread((LPSECURITY_ATTRIBUTES) NULL,
                                      0,
                                      (LPTHREAD_START_ROUTINE) CommWatchProc,
                                      (LPVOID) this,
                                      0, &dwThreadID);
      if (hCommWatchThread == NULL)
      {
        m_bIsConnected = FALSE ;
        CloseHandle(m_nIdComDev) ;
        nError = GetLastError();
      }
      else
      {
        m_dwThreadID = dwThreadID;
        m_hWatchThread = hCommWatchThread;
      }
    }

    // assert DTR
    EscapeCommFunction(m_nIdComDev, SETDTR ) ;
  }
  else
  {
    m_bIsConnected = FALSE ;
    CloseHandle(m_nIdComDev) ;
  }

  m_bIsConnected = (nError == 0);

  return nError;
}


/////////////////////////////////////////////////////////////////////////////
//function: SetupConnection
//setup communication parameters
//
int CCommunication::SetupConnection()
{
  DCB        dcb ;
  dcb.DCBlength = sizeof( DCB ) ;

  GetCommState(m_nIdComDev, &dcb ) ;

  dcb.BaudRate = m_dwBaudRate;
  dcb.ByteSize = m_nByteSize;
  dcb.Parity   = m_nParity;
  dcb.StopBits = m_nStopBits;

  // setup hardware flow control
  BYTE bSet = (BYTE) m_bDTRDSR;
  dcb.fOutxDsrFlow = bSet ;
  if (bSet)
    dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
  else
    dcb.fDtrControl = DTR_CONTROL_ENABLE;

  bSet = (BYTE) m_bRTSCTS;
  dcb.fOutxCtsFlow = bSet;
  if (bSet)
    dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
  else
    dcb.fRtsControl = RTS_CONTROL_ENABLE ;

  // setup software flow control
  bSet = (BYTE) m_bXONXOFF;

  dcb.fInX = dcb.fOutX = bSet ;
  dcb.XonChar = ASCII_XON ;
  dcb.XoffChar = ASCII_XOFF ;
  dcb.XonLim = 100 ;
  dcb.XoffLim = 100 ;

  // other various settings
  dcb.fBinary = TRUE ;
  dcb.fParity = TRUE ;

  BOOL bRetVal = SetCommState(m_nIdComDev, &dcb ) ;
  if (!bRetVal)
  {
    ASSERT(FALSE);
    DWORD dwError = GetLastError();
    TRACE("<SetCommState: %u>\n", dwError);
    return GetLastError();
  }

  //reset buffer
  ZeroMemory(m_byRecvBuffer, MAX_INBUFFER);
  m_nRecvBufferPos = 0;

  return 0;
}


/////////////////////////////////////////////////////////////////////////////
//function: WriteCommBlock
//write characters via rs232. returns GetLastError()
//
int CCommunication::WriteCommBlock(LPBYTE lpByte , DWORD dwBytesToWrite)
{
  DWORD dwBytesWritten;

  BOOL fWriteStat = WriteFile(m_nIdComDev, lpByte, dwBytesToWrite
                , &dwBytesWritten, &m_osWrite);

    // Note that normally the code will not execute the following
    // because the driver caches write operations. Small I/O requests
    // (up to several thousand bytes) will normally be accepted
    // immediately and WriteFile will return true even though an
    // overlapped operation was specified

  DWORD       dwErrorFlags;
  COMSTAT     ComStat;

  if (!fWriteStat)
  {
    DWORD dwErr = GetLastError();

    if (dwErr == ERROR_IO_PENDING)
    {
      // We should wait for the completion of the write operation
      // so we know if it worked or not

      // This is only one way to do this. It might be beneficial to
      // place the write operation in a separate thread
      // so that blocking on completion will not negatively
      // affect the responsiveness of the UI

      // If the write takes too long to complete, this
      // function will timeout according to the
      // CommTimeOuts.WriteTotalTimeoutMultiplier variable.
      // This code logs the timeout but does not retry
      // the write.

      DWORD dwBytesSent=0;

      while(!GetOverlappedResult(m_nIdComDev, &m_osWrite, &dwBytesWritten, TRUE))
      {
        DWORD dwError = GetLastError();
        if(dwError == ERROR_IO_INCOMPLETE)
        {
          // normal result if not finished
          dwBytesSent += dwBytesWritten;
          continue;
        }
        else
        {
          // an error occurred, try to recover
          TRACE("<GetOverlappedResult: %u>\n", dwError);

                  ClearCommError(m_nIdComDev, &dwErrorFlags, &ComStat ) ;
                  if (dwErrorFlags > 0)
          TRACE("<ClearCommError: %u>\n", dwErrorFlags);

          break;
        }
      }

      dwBytesSent += dwBytesWritten;

      if( dwBytesSent != dwBytesToWrite )
      {
        TRACE("Probable Write Timeout: Total of %ld bytes sent.\n", dwBytesSent);
        return GetLastError();
      }
      else
        TRACE("%ld bytes written\n", dwBytesSent);
      }

    else  //(dwErr != ERROR_IO_PENDING)
    {
      // some other error occurred
      ClearCommError(m_nIdComDev, &dwErrorFlags, &ComStat ) ;
      if (dwErrorFlags > 0)
        TRACE("<ClearCommError: %u>\n", dwErrorFlags);

      return GetLastError();
    }
  }

  return 0;
}


/////////////////////////////////////////////////////////////////////////////
//function: ReadCommBlock
//read characters via rs232. returns GetLastError(), -1 if buffer too small, -2 if timeout
//waits for nExpectedRecvLength characters (if nExpectedRecvLength > 0).
//
int CCommunication::ReadCommBlock(LPBYTE lpBlock, int nMaxLength, int nExpectedRecvLength, int* nBytesRead)
{
  *nBytesRead = 0;

  LPBYTE lpDatagram = &m_byRecvBuffer[0];

  DWORD dwRecvTimeOut = m_dwReadTotalTimeoutConstant;
  DWORD dwStartRecv = GetTickCount();

  while (TRUE)
  {
    // only try to read number of bytes in queue
    COMSTAT    ComStat;
    DWORD      dwErrorFlags;

    ClearCommError(m_nIdComDev, &dwErrorFlags, &ComStat);

    DWORD dwLength = min((DWORD) nMaxLength, ComStat.cbInQue);

    if (dwLength > 0)
    {
      //data received -> reset timeout
      dwStartRecv = GetTickCount();

      BOOL fReadStat = ReadFile(m_nIdComDev, lpDatagram, dwLength, &dwLength, &m_osRead);

      if (!fReadStat)
      {
        if (GetLastError() == ERROR_IO_PENDING)
        {
          TRACE("\n\rIO Pending");
          // We have to wait for read to complete.
          // This function will timeout according to the
          // CommTimeOuts.ReadTotalTimeoutConstant variable
          // Every time it times out, check for port errors
          while(!GetOverlappedResult(m_nIdComDev, &m_osRead, &dwLength, TRUE ))
          {
            DWORD dwError = GetLastError();
            if(dwError == ERROR_IO_INCOMPLETE)
              continue;   // normal result if not finished
            else
            {
              // an error occurred, try to recover
              TRACE("<GetOverlappedResult: %u>\n", dwError);
              ClearCommError(m_nIdComDev, &dwErrorFlags, &ComStat ) ;
              if (dwErrorFlags > 0)
                TRACE("<ClearCommError: %u>\n", dwErrorFlags);
              break;
            }
          }
        }
        else
        {
          // some other error occurred
          dwLength = 0 ;
          ClearCommError(m_nIdComDev, &dwErrorFlags, &ComStat ) ;
          if (dwErrorFlags > 0)
            TRACE("<ClearCommError: %u>\n", dwErrorFlags);
          return GetLastError();
        }
      }

      *nBytesRead += dwLength;
      if (*nBytesRead > nMaxLength)
        return -1; //buffer too small

      lpDatagram += dwLength;

      if (nExpectedRecvLength <= 0) //do not wait for further recv. data -> return immediately
        break;
    }

    //timeout?
    static BOOL s_bTimeoutEnabled = TRUE; //usefull for debugging (can be set to FALSE within debugger)

    if (((GetTickCount() - dwStartRecv) > dwRecvTimeOut) && s_bTimeoutEnabled)
      return -2; //timeout
  }

  CopyMemory(lpBlock, m_byRecvBuffer, *nBytesRead);

  return GetLastError();
}

void CCommunication::ClearBuffers(DWORD dwWaitMiliSecs)
{
  Sleep(dwWaitMiliSecs);  //wait for still incoming characters

  PurgeComm(m_nIdComDev, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );
}

int CCommunication::CommReceived(LPSTR szData, int nLength)
{
  while (nLength--)
    TRACE("%c", *szData++);

  return 0;
}

/////////////////////////////////////////////////////////////////////////////
//function: CommWatchProc
//asecondary thread that will watch for COMM events.
//add this thread to watch the communications device and
//post notifications to the associated window.
//
DWORD FAR PASCAL CommWatchProc(LPSTR lpData)
{
    DWORD       dwEvtMask ;
    CCommunication* pCom = (CCommunication*) lpData;
    OVERLAPPED  os ;
    int         nLength ;
    BYTE        abIn[ MAXBLOCK + 1] ;

    memset( &os, 0, sizeof( OVERLAPPED ) ) ;

    // create I/O event used for overlapped read

    os.hEvent = CreateEvent( NULL,    // no security
                            TRUE,    // explicit reset req
                            FALSE,   // initial event reset
                            NULL ) ; // no name
    if (os.hEvent == NULL)
    {
        MessageBox(NULL, "Failed to create event for thread!", "TTY Error!",
                   MB_ICONEXCLAMATION | MB_OK ) ;
        return ( FALSE ) ;
    }

    if (!SetCommMask(pCom->m_nIdComDev, EV_RXCHAR ))
        return ( FALSE ) ;

    while (pCom->IsConnected())
    {
        dwEvtMask = 0 ;

        WaitCommEvent(pCom->m_nIdComDev, &dwEvtMask, NULL );

        if ((dwEvtMask & EV_RXCHAR) == EV_RXCHAR)
        {
            do
            {
                int nErr = pCom->ReadCommBlock(abIn, MAXBLOCK, 0, &nLength);
                if (nErr)
                    break;
                if (nLength)
                {
                    nErr = pCom->CommReceived((LPSTR) abIn, nLength);
                    if (nErr)
                        break;
                }
            } while (nLength > 0);
        }
    }

    // get rid of event handle
    CloseHandle(os.hEvent);

    // clear information in structure (kind of a "we're done flag")
    pCom->m_dwThreadID = 0 ;
    pCom->m_hWatchThread = NULL ;

    return 0;
} // end of CommWatchProc()