comwin32.h

一个很好用的comm类

/************************************************************************
*
*  Module name         : ComWin32.h
*
*  Module description  :
*     Declaration of class ComWin32.
*     ComWin32 is a class which operates the RS232 port.
*
*  Project             : Generic
*
*  Target platform     : Win32
*
*  Compiler & Library  : Visual C++ 6.0
*
*  Author              : Richard Shen
*
*  Creation date       : 30 August, 1999
*
*  Modifications       :
*     04May03  RCS       WaitForTxComplete() added.
*
************************************************************************/
#ifndef ComWin32_h
#define ComWin32_h

#include "ComWinDef.h"

#define COM_RXBUFSZ     4096
#define COM_TXBUFSZ     2048

enum RS232Signal     {  DTR,  RTS,  DSR,  CTS,  RI,   DCD   };
enum FlushType       {  FLUSH_RX,   FLUSH_TX,   FLUSH_ALL,  FLUSH_COMERROR };

enum HandshakeType   {  HS_NONE, HS_XONXOFF, HS_DTR, HS_DSR, HS_CTS, HS_RTS };

struct ComBufferInfo
{
   DWORD    rxCount;       // Number of bytes received
   DWORD    rxSize;        // Size of receiver buffer
   BOOL     rxPaused;      // Pause state of Rx
   DWORD    txCount;       // Number of bytes remained an to be transmit
   DWORD    txSize;        // Size of transmit buffer
   BOOL     txPaused;      // Pause state of Tx
};

class ComWin32
{
public:
   ComWin32(int portNo = COM1,
            int rxBufSize = COM_RXBUFSZ, int txBufSize = COM_TXBUFSZ,
            BOOL dtrInitHigh = TRUE, BOOL rtsInitHigh = TRUE
           );
   virtual        ~ComWin32(void);

   BOOL           IsPortAvailable(void);
   DWORD          GetComWinError(void)    {  return comLastError;       }
   int            GetComID(void)          {  return comID;              }
#ifndef NO_OVERLAPPED_SUPPORT
   HANDLE         GetComEventHandle(void) {  return ovComEvent.hEvent;  }
   HANDLE         GetRWEventHandle(void)  {  return ovReadWrite.hEvent; }
#endif // !NO_OVERLAPPED_SUPPORT
   void           GetBufferInfo(ComBufferInfo &info);
   void           Delay(DWORD period);

   long           BaudRate(long baudRate);
   long           BaudRate(void);
   int            DataLength(int length);
   int            DataLength(void);
   char           Parity(char parity);
   char           Parity(void);
   int            StopBits(int stopBits);
   int            StopBits(void);

   int            LineSignal(RS232Signal lineSignal, int state = SIGNAL_QUERY);
   int            Dtr(int state = SIGNAL_ON) {  return LineSignal(DTR, state); }
   int            Rts(int state = SIGNAL_ON) {  return LineSignal(RTS, state); }
   int            Dsr(void)      {  return LineSignal(DSR, SIGNAL_QUERY); }
   int            Cts(void)      {  return LineSignal(CTS, SIGNAL_QUERY); }
   int            Carrier(void)  {  return LineSignal(DCD, SIGNAL_QUERY); }
   int            Ring(void)     {  return LineSignal(RI,  SIGNAL_QUERY); }
   virtual void   SendBreak(DWORD duration);

   virtual DWORD  GetEventMask(DWORD &eventMask);
   virtual DWORD  SetEventMask(DWORD eventMask);
   virtual void   SetEventCharacter(char evChar);
   virtual BOOL   WaitForEvent(DWORD &eventWait, DWORD timeOut = INFINITE);

#ifndef NO_OVERLAPPED_SUPPORT
   DWORD          GetReceivedEvent(void)  {  return comEventMask; }
#endif // !NO_OVERLAPPED_SUPPORT

   virtual int    GetBuffer(char *buffer, int count);
   virtual int    GetChar(char *byte);
   virtual int    PutBuffer(char *buffer, int count);
   virtual int    PutChar(char byte);
   virtual int    PutString(char *str, int option = -2);
   int            ImmediateSend(char byte);
   virtual void   Flush(FlushType which = FLUSH_ALL);
   BOOL           SetHandshake(HandshakeType inMode,  HandshakeType outMode);
   void           GetHandshake(HandshakeType &inMode, HandshakeType &outMode);

   int            StoreRxData(void);
   void           StoreData(char *buffer, int size);
   int            RetrieveRxData(char *buffer, int size);
   BOOL           AdvanceTo(char expChar);
   int            PacketSize(char startChar, char endChar);
   int            PacketSize(char endChar);
   int            AvailRxBufData(void);
   void           FlushRxBufData(void);
   void           WaitForTxComplete(DWORD timeOut);

protected:
   DWORD          Open(void);
   void           Close(void);
   virtual void   Initialize(BOOL dtrInitHigh, BOOL rtsInitHigh);
   int            AvailableRxData(void);

protected:
   // Circular buffer
   class Circular
   {
   public:
      Circular(int size);
      virtual     ~Circular(void);

      BOOL        Good(void)           {  return objValid;     }
      int         GetBufferSize(void)  {  return cirBufSize;   }
      void        PushIt(char *data, int size);
      void        PushIt(char data);
      int         PullIt(char *data, int size);
      BOOL        PullIt(char *data);
      void        Flush(void);
      int         DataAvailable(void)  { return availData;  }
      BOOL        AdvanceTo(char expChar);
      int         SearchForChar(char expChar);

   private:
      char        *dataBuffer;
      char        *bottom;
      char        *top;
      char        *push;
      char        *pull;

      int         availData;
      int         cirBufSize;
      BOOL        objValid;
   };

protected:
   HANDLE         comHandle;
   HANDLE         delayHandle;
   DCB            comDCB;
   COMMTIMEOUTS   comTimeOuts;

#ifndef NO_OVERLAPPED_SUPPORT
   OVERLAPPED     ovReadWrite;
   OVERLAPPED     ovComEvent;
#endif // !NO_OVERLAPPED_SUPPORT

   int            comID;
   DWORD          comLastError;
   int            rxQueue;
   int            txQueue;

#ifndef NO_OVERLAPPED_SUPPORT
   DWORD          comEventMask;
#endif // !NO_OVERLAPPED_SUPPORT

   HandshakeType  inHandshake;
   HandshakeType  outHandshake;

   Circular       *circular;
};

#endif // ComWin32_h