cSerialPort.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSerialPort_H
#define _INC_cSerialPort_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
 
#include "GrayCore/include/cOSHandle.h"
#include "GrayCore/include/HResult.h"
#include "GrayCore/include/cArrayString.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/FileName.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cSerialPort);
 
        class GRAYLIB_LINK cSerialPort : public cOSHandle, public cStream
        {
 
                typedef cOSHandle SUPER_t;
 
#if defined(_WIN32) 
        protected:
                bool m_bOverlapped;             
#endif
 
        public:
                cSerialPort();
                virtual ~cSerialPort();
 
                // General Methods
                HRESULT Open(const FILECHAR_t* pszPortName, bool bOverlapped = false);
                void Close();
 
                void AttachSerial(HANDLE hComm);
 
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override;
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override;
 
                HRESULT SetTimeouts0();
 
#if defined(_WIN32) 
 
                HRESULT TransmitChar(char CChar);
 
                // Configuration Methods
                HRESULT GetCommConfigInfo(COMMCONFIG& config);
 
                static HRESULT GRAYCALL GetDefaultConfig(const FILECHAR_t* pszPortName, COMMCONFIG& config);
                static HRESULT GRAYCALL GetDefaultConfig(int nPort, COMMCONFIG& config);
                static HRESULT GRAYCALL SetDefaultConfig(const FILECHAR_t* pszPortName, COMMCONFIG& config);
                static HRESULT GRAYCALL SetDefaultConfig(int nPort, COMMCONFIG& config);
 
                HRESULT GetState(DCB& dcb);             // Baud,parity,etc
                HRESULT SetState(const DCB& dcb);
 
                HRESULT ClearError(DWORD& dwErrors);
 
                // Misc RS232 Pin/Handshake/Flow Methods
                HRESULT SetHandshakeOut(DWORD dwFunc);
                HRESULT GetHandshakeOut(COMSTAT& stat); // handshakes, etc
#if 0
                HRESULT SetDTR(bool bVal);
                HRESULT SetRTS(bool bVal);
                HRESULT SetXON(bool bVal);
#endif
                HRESULT GetHandshakeInp(DWORD& dwModemStatus);
                HRESULT SetBreak(bool bSet);
 
                // Timeouts
                HRESULT SetTimeouts(const COMMTIMEOUTS& timeouts);
                HRESULT GetTimeouts(OUT COMMTIMEOUTS& timeouts);
                HRESULT SetTimeoutWrite0();
                HRESULT SetTimeoutRead0();
 
                // Event Methods. EV_DSR
                HRESULT SetEventMask(DWORD dwEventMask);
                HRESULT GetEventMask(DWORD& dEventwMask);
                HRESULT WaitEvent(DWORD& dwEventMask);
 
                // Queue Size Methods
                HRESULT GetProperties(COMMPROP& properties);
                HRESULT Purge(DWORD dwFlags);
#if 0
                HRESULT TerminateOutstandingWrites();
                HRESULT TerminateOutstandingReads();
                HRESULT ClearWriteBuffer();
                HRESULT ClearReadBuffer();
#endif
                HRESULT SetupQueue(DWORD dwInQueue, DWORD dwOutQueue);
 
#endif  // _WIN32
 
                static HRESULT GRAYCALL GetAllSerialPorts(OUT cArrayString<FILECHAR_t>& a);
 
                UNITTEST2_PREDEF(cSerialPort);
        };
 
#if defined(_WIN32) && !defined(UNDER_CE)
        class GRAYLIB_LINK cSerialOverlapped : public cSerialPort
        {
 
                typedef cSerialPort SUPER_t;
 
        protected:
                int m_iOverlappedOps;   
 
        protected:
                static void WINAPI _OnCompletion(DWORD dwErrorCode, DWORD dwCount, LPOVERLAPPED lpOverlapped);
                virtual void OnCompletion(LSTATUS dwErrorCode, DWORD dwCount, LPOVERLAPPED lpOverlapped);
 
                HRESULT CancelIo(); // not available in Win95!
                HRESULT GetOverlappedResult(OVERLAPPED& overlapped, DWORD& dwBytesTransferred, BOOL bWait);
 
                HRESULT Read(void* lpBuf, DWORD dwCount, OVERLAPPED& overlapped);
                HRESULT Write(const void* lpBuf, DWORD dwCount, OVERLAPPED& overlapped);
 
        public:
                cSerialOverlapped()
#if defined(_WIN32) && ! defined(UNDER_CE)
                        : m_iOverlappedOps(0)
#endif
                {
                }
 
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override;
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override;
 
                HRESULT WaitEvent(DWORD& dwEventMask, OVERLAPPED& overlapped);
        };
#endif
 
};
 
#endif // _INC_cSerialPort_H