TnbRs232c.h

[詳解]

#pragma once
#ifdef _WIN32_WCE
 #define _TnbRS232C_EnumExistPorts_DISABLE
#endif
#include "TnbCommunication.h"
#include "TnbStrEx.h"
#ifndef _TnbRS232C_EnumExistPorts_DISABLE
 #include "TnbRegistryAccessor.h"
 #include <SetupApi.h>
 #pragma comment(lib, "setupapi.lib")
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CRs232c : public ICommunication, CCopyImpossible
{
public:
 
    class CPort
    {
    public:
 
        CPort(void)
        {
        }
 
        CPort(int portNo)
        {
            #ifndef _WIN32_WCE
                m_portName.Format(_T("\\\\.\\COM%d"), portNo);
            #else
                m_portName.Format(_T("COM%d:"), portNo);
            #endif
        }
 
        CPort(LPCTSTR lpszPortName) : m_portName(lpszPortName)
        {
        }
 
        #ifdef __AFX_H__
 
        CPort(const CString& portName) : m_portName(portName)
        {
        }
 
        #endif //__AFX_H__
 
        const CStr& GetPortName(void) const
        {
            return m_portName;
        }
 
        int GetNumber(void) const
        {
            LPCTSTR P1 = m_portName;
            LPCTSTR P2 = m_Find(P1);
            if ( P2 != NULL )
            {
                return _ttoi(P2);
            }
            return -1;
        }
 
        CStr GetPrefix(void) const
        {
            CStr s;
            LPCTSTR P1 = m_portName;
            LPCTSTR P2 = m_Find(P1);
            if ( P2 != NULL )
            {
                s = m_portName.Left(P2 - P1);
            }
            return s;
        }
 
        bool IsValid(void) const
        {
            return ! m_portName.IsEmpty();
        }
 
    private:
        LPCTSTR m_Find(LPCTSTR lpsz) const
        {
            while ( (*lpsz) != 0 )
            {
                if ( (*lpsz) >= '0' && (*lpsz) <= '9' )
                {
                    return lpsz;
                }
                lpsz++;
            }
            return NULL;
        }
        CStr m_portName;
    };
 
    enum EParity
    {
        Parity_Non      = NOPARITY,     
        Parity_Odd      = ODDPARITY,    
        Parity_Even     = EVENPARITY,   
        Parity_Mark     = MARKPARITY,   
        Parity_Space    = SPACEPARITY,  
        //
        #ifndef _TnbDOXYGEN //Document作成用シンボル
        EP_NonParity    = NOPARITY,     
        EP_OddParity    = ODDPARITY,    
        EP_EvenParity   = EVENPARITY,   
        EP_MarkParity   = MARKPARITY,   
        EP_SpaceParity  = SPACEPARITY,  
        #endif // _TnbDOXYGEN
    };
    enum EStopBits
    {
        StopBits_1      = ONESTOPBIT,   
        StopBits_1_5    = ONE5STOPBITS, 
        StopBits_2      = TWOSTOPBITS,  
        //
        #ifndef _TnbDOXYGEN //Document作成用シンボル
        ES_OneStopBit   = ONESTOPBIT,   
        ES_One5StopBits = ONE5STOPBITS, 
        ES_TwoStopBits  = TWOSTOPBITS,  
        #endif // _TnbDOXYGEN
    };
 
    
    //--------------------------------
 
 
    CRs232c(void) : m_property(_T("RS232C"), TNBVIW_KIND_RS232C), m_hComPort(INVALID_HANDLE_VALUE)
        , m_dwBaudRate(9600), m_bByteSize(7), m_eParity(Parity_Non)
        , m_eStopBits(StopBits_1), m_boCanBulkSend(true), m_boIsConnect(false), m_isCheckCts(false)
    {
        ASSERT( m_property.receiveTimeout == 0 );
    }
 
    ~CRs232c(void)
    {
        CRs232c::Close();
    }
 
    void GetParameter(CPort& _comPort, DWORD& _dwBaudRate, BYTE& _bByteSize, EParity& _eParity, EStopBits& _eStopBits) const
    {
        _comPort = m_comPort;
        _dwBaudRate = m_dwBaudRate,
        _bByteSize = m_bByteSize;
        _eParity = m_eParity;
        _eStopBits = m_eStopBits;
    }
 
    DWORD SetParameter(CPort comPort, DWORD dwBaudRate, BYTE bByteSize, EParity eParity, EStopBits eStopBits)
    {
        if ( m_comPort.GetNumber() != comPort.GetNumber() )
        {
            Close();
            m_comPort = comPort;
        }
        m_dwBaudRate = dwBaudRate,
        m_bByteSize = bByteSize;
        m_eParity = eParity;
        m_eStopBits = eStopBits;
        if ( m_hComPort != INVALID_HANDLE_VALUE )
        {
            return m_PortSetting(m_hComPort);
        }
        return 0;
    }
 
    virtual bool SetReceiveTimeout(DWORD to)
    {
        return false;
    }
 
    void SetSendMode(bool canBulk)
    {
        m_boCanBulkSend = canBulk;
    }
 
    void SetCheckCtsMode(bool r = true)
    {
        m_isCheckCts = r;
    }
    
    virtual const TProperty& GetProperty(void) const
    {
        return m_property;
    }
 
    HANDLE GetHandle(void) const
    {
        return m_hComPort;
    }
 
    virtual bool Open(void)
    {
        Close();
        if ( m_Open() == ERROR_SUCCESS )
        {
            m_property.typeName = CStr::Fmt(_T("RS232C(%s%d)"), m_comPort.GetPrefix(), m_comPort.GetNumber());      // タイプ名。
            m_property.typeId = TNBVIW_KIND_RS232C + (m_comPort.GetNumber() & 0xFFFF);
            return true;
        }
        return false;
    }
 
    virtual void Close(void)
    {
        if ( m_hComPort != INVALID_HANDLE_VALUE )
        {
            // ポートの設定を取得
            HANDLE h = m_hComPort;
            m_hComPort = INVALID_HANDLE_VALUE;
            DCB tDCB;
            if ( ::GetCommState(h, &tDCB) )
            {
                tDCB.fRtsControl = RTS_CONTROL_DISABLE;
                tDCB.fDtrControl = DTR_CONTROL_DISABLE;
                // ポートの状態を設定
                ::SetCommState(h, &tDCB);
            }
            ::CloseHandle(h);
            m_boIsConnect = false;
        }
    }
 
    virtual bool IsOpened(void) const
    {
        return m_hComPort != INVALID_HANDLE_VALUE;
    }
 
    virtual bool IsConnect(void) const
    {
        return m_boIsConnect;
    }
 
    virtual size_t GetReceivingDataSize(void) const
    {
        // 現在の状態を取得。
        DWORD dwErrors;
        COMSTAT tComStat;
        if ( ! ::ClearCommError(m_hComPort, &dwErrors, &tComStat) )
        {
            _GetLastError("ClearCommError");
            return INVALID_SIZE;
        }
        // 現在受信しているDataを取得
        return tComStat.cbInQue;
    }
 
    virtual EState Check(void) const
    {
        if ( IsOpened() )
        {
            DWORD dwStat;
            if ( ! ::GetCommModemStatus(m_hComPort, &dwStat) )
            {
                _GetLastError("GetCommModemStatus");
            }
            else if ( m_isCheckCts )
            {
                m_boIsConnect = (dwStat & MS_CTS_ON) != 0;
                return m_boIsConnect ? CONNECTING : OPENNING;
            }
            else
            {
                m_boIsConnect = true;
                return CONNECTING;
            }
        }
        return CLOSED;
    }
 
    virtual size_t Send(size_t size, LPCVOID P)
    {
        if ( ! IsOpened() )
        {
            return INVALID_SIZE;
        }
        if ( m_boCanBulkSend )
        {
            //=== 一括送信
            const BYTE* B = static_cast<const BYTE*>(P);
            size_t r = 0;
            size_t writtenSize = 0;
            while ( true )
            {
                if ( ! WritePort(writtenSize, size, B, m_hComPort) )
                {
                    return INVALID_SIZE;
                }
                if ( writtenSize == 0 )
                {
                    break;
                }
                r += writtenSize;
                if ( size <= writtenSize )
                {
                    break;
                }
                size -= writtenSize;
                B += writtenSize;
            }
            return r;
        }
        //=== 一バイトずつ送信
        const BYTE* B = static_cast<const BYTE*>(P);
        for ( UINT i = 0; i < size; i++ )
        {
            int iErrCnt = 10;           // エラーカウント
            size_t writtenSize = 0;
            while ( writtenSize == 0 && iErrCnt > 0 )
            {
                if ( ! WritePort(writtenSize, 1, &B[i], m_hComPort) )
                {
                    // WriteFile関数がエラーを返した
                    return INVALID_SIZE;
                }
                if ( writtenSize != 1 )
                {
                    iErrCnt --;
                    Sleep(1);
                }
            }
            if ( iErrCnt < 1 )
            {
                return INVALID_SIZE;
            }
        }
        return size;
    }
 
    virtual size_t Receive(size_t size, LPVOID _P)
    {
        DWORD dwErrors;
        COMSTAT tComStat;
        if ( ! ::ClearCommError(m_hComPort, &dwErrors, &tComStat) )
        {
            _GetLastError("ClearCommError");
            return INVALID_SIZE;
        }
        if ( size > tComStat.cbInQue )
        {
            size = tComStat.cbInQue;
        }
        if ( size == 0 )
        {
            return 0;
        }
        size_t redSize  = 0;
        if ( ReadPort(redSize, _P, size, m_hComPort) )
        {
            return redSize;
        }
        return INVALID_SIZE;
    }
 
    virtual void Purge(void)
    {
        ::PurgeComm(m_hComPort, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
    }
 
    bool PaddingReceive(DWORD dwTime)
    {
        if ( ! IsOpened() )
        {
            return false;
        }
        //
        bool boResult = false;
        DWORD dwLoopCount = 0;
        //
        while ( true )
        {
            // 現在の状態を取得。
            BOOL boIsClearComm;
            DWORD dwErrors;
            COMSTAT tComStat;
            // エラー状態リセット&受信文字数確認
            boIsClearComm = ::ClearCommError(m_hComPort, &dwErrors, &tComStat);
            if ( ! boIsClearComm )
            {
                boResult = false;
                break;
            }
            //
            // 現在受信しているDataを取得
            DWORD dwReceivedDataCount = tComStat.cbInQue;
            //
            if ( dwReceivedDataCount == 0 )
            {
                dwLoopCount++;
                if ( dwLoopCount * 10 > dwTime )
                {
                    boResult = true;
                    break;
                }
            }
            else
            {
                dwLoopCount = 0;
                //
                CWorkMem tmp(dwReceivedDataCount);
                // RS232Cからの読み込み
                size_t redSize = 0;
                if ( ! ReadPort(redSize, tmp.Ref(), tmp.GetSize(), m_hComPort) )
                {
                    //失敗
                    boResult = false;
                    break;
                }
                if ( redSize == 0 )
                {
                    boResult = true;
                    break;
                }
            }
            ::Sleep(10);
        }
        //
        return boResult;
    }
 
    enum
    {
        LOW  = true,    
        HI = false      
    };
 
    bool SetDtrSignal(bool isLow)
    {
        return !! ::EscapeCommFunction(m_hComPort, isLow ? SETDTR : CLRDTR);
    }
 
    bool SetRtsSignal(bool isLow)
    {
        return !! ::EscapeCommFunction(m_hComPort, isLow ? SETRTS : CLRRTS);
    }
 
    bool IsCtsSignalLow(void) const
    {
        DWORD w;
        if ( ::GetCommModemStatus(m_hComPort, &w) )
        {
            return (w & MS_CTS_ON) != 0;
        }
        return false;
    }
 
    bool IsDsrSignalLow(void) const
    {
        DWORD w;
        if ( ::GetCommModemStatus(m_hComPort, &w) )
        {
            return (w & MS_DSR_ON) != 0;
        }
        return false;
    }
 
    bool IsRingSignalLow(void) const
    {
        DWORD w;
        if ( ::GetCommModemStatus(m_hComPort, &w) )
        {
            return (w & MS_RING_ON) != 0;
        }
        return false;
    }
 
    bool IsRlsdSignalLow(void) const
    {
        DWORD w;
        if ( ::GetCommModemStatus(m_hComPort, &w) )
        {
            return (w & MS_RLSD_ON) != 0;
        }
        return false;
    }
 
    bool IsCtsSignalOn(void) const
    {
        return IsCtsSignalLow();
    }
 
    bool IsDsrSignalOn(void) const
    {
        return IsDsrSignalLow();
    }
 
    bool IsRingSignalOn(void) const
    {
        return IsRingSignalLow();
    }
 
    bool IsRlsdSignalOn(void) const
    {
        return IsRlsdSignalLow();
    }
 
    static DWORD CanPortBeOpened(CPort comPort)
    {
        // COMポート名作成
        CStr strPortName = comPort.GetPortName();
        // ポートを開く
        HANDLE hComPort = ::CreateFile(
                        strPortName,                    // ファイルの名前のアドレス
                        GENERIC_READ | GENERIC_WRITE,   // アクセス (読み取りおよび書き込み) モード
                        0,                              // 共有モード
                        NULL,                           // セキュリティ記述子のアドレス
                        OPEN_EXISTING,                  // 作成方法
                        FILE_ATTRIBUTE_NORMAL,          // ファイル属性
                        NULL                            // コピーする属性付きファイルのハンドル
        );
        // ポートを開く関数が異常を返した場合
        if ( hComPort == INVALID_HANDLE_VALUE )
        {
            return _GetLastError("CreateFile");
        }
        ::CloseHandle(hComPort);
        return 0;
    }
 
    #ifndef _TnbRS232C_EnumExistPorts_DISABLE
 
    struct TDevice : IComparableT<TDevice>
    {
        WORD    port;           
        CStr    description;    
        CStr    manufacturer;   
        WORD    vid;            
        WORD    pid;            
        TDevice(void) : port(0), vid(0), pid(0)
        {
        }
        CStr ToString(void) const
        {
            if ( description.Find(manufacturer) == 0 )
            {
                return CStr::Fmt(_T("%s (COM%d)"), description, port);
            }
            return CStr::Fmt(_T("%s %s (COM%d)"), manufacturer, description, port);
        }
        virtual INT_PTR Compare(const TDevice& t) const
        {
            return port - t.port;
        }
    };
 
    typedef CVectorT<TDevice> TDeviceVector;
 
    static TDeviceVector EnumExistPortDeviceNames(void)
    {
        CMyFinder ff;
        CRegistryAccessor reg(HKEY_LOCAL_MACHINE, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS);
        return ff.Execute(reg[_T("SYSTEM\\CurrentControlSet\\Enum")]);
    }
 
    static CWordVector EnumExistPorts(void)
    {
        CRegistryAccessor reg(HKEY_LOCAL_MACHINE, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS);
        CRegistryAccessor::CSection regsub = reg[_T("HARDWARE\\DEVICEMAP\\SERIALCOMM")];
        CStrVector vstrNames = regsub.EnumKeyNames();
        //
        CWordVector vw;
        loop ( i, vstrNames.GetSize() )
        {
            CStr str = regsub.QueryString(vstrNames[i]);
            if ( str.GetLength() >= 4 )
            {
                int iPort = str.ToInt(3);
                if ( iPort >= 0 && iPort <= 256 )
                {
                    vw.Add(static_cast<WORD>(iPort));
                }
            }
        }
        vw.Sort();
        return vw;
    }
 
    static CWordVector EnumExistPortsByUsb(WORD vid, WORD pid)
    {
        CWordVector vw;
        TDeviceVector vd = EnumExistPortDeviceNames();
        loop ( i, vd )
        {
            const TDevice& d = vd[i];
            if ( d.vid == vid && d.pid == pid )
            {
                vw.Add(d.port);
            }
        }
        vw.Sort();
        return vw;
    }
 
    #endif
 
protected:
 
    virtual bool OnRs232cOpening(HANDLE hComPort, DCB& _tDCB, COMMTIMEOUTS& _tCommTimeOuts)
    {
        return true;
    }
 
    virtual HANDLE CreatePort(LPCTSTR lpszPortName) const
    {
        DWORD desiredAccess = GENERIC_READ | GENERIC_WRITE; // アクセス (読み取りおよび書き込み) モード
        DWORD flag = FILE_ATTRIBUTE_NORMAL;
        HANDLE h = ::CreateFile(lpszPortName, desiredAccess, 0, NULL, OPEN_EXISTING, flag, NULL);
        _GetLastError("CreateFile");
        return h;
    }
 
    virtual bool WritePort(size_t& _writtenSize, size_t len, LPCVOID P, HANDLE h) const
    {
        DWORD dwWritten = 0;
        if ( ! ::WriteFile(h, P, ToDword(len), &dwWritten, NULL) )
        {
            _GetLastError("WriteFile");
            return false;
        }
        _writtenSize = dwWritten;
        return true;
    }
 
    virtual bool ReadPort(size_t& _redSize, LPVOID _P, size_t len, HANDLE h) const
    {
        DWORD dwRed = 0;
        if ( ! ::ReadFile(h, _P, ToDword(len), &dwRed, NULL) )
        {
            _GetLastError("ReadFile");
            return false;
        }
        _redSize = dwRed;
        return true;
    }
 
private:
 
    DWORD m_Open(void)
    {
        if ( ! m_comPort.IsValid() )
        {
            return ERROR_INVALID_PARAMETER;
        }
        // ポートを開く
        HANDLE hComPort = CreatePort(m_comPort.GetPortName());
        // ポートを開く関数が異常を返した場合
        if ( hComPort == INVALID_HANDLE_VALUE )
        {
            return ::GetLastError();
        }
        ::PurgeComm(hComPort, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
        // ポートの設定を取得
        DWORD r = m_PortSetting(hComPort);
        if ( r != 0 )
        {
            ::CloseHandle(hComPort);
            return r;
        }
        //
        COMSTAT tComStat;
        ::ClearCommError(hComPort, &r, &tComStat);
        ::SetCommMask(hComPort, 0);
        ::PurgeComm(hComPort, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
        m_hComPort = hComPort;
        return 0;
    }
 
    DWORD m_PortSetting(HANDLE hComPort)
    {
        DCB tDCB;
        COMMTIMEOUTS tCommTimeOuts;
        if ( ! ::GetCommState(hComPort, &tDCB) || ! ::GetCommTimeouts(hComPort, &tCommTimeOuts) )
        {
            return _GetLastError("GetCommState/GetCommTimeouts");
        }
        // ポートを設定
        tDCB.BaudRate   = m_dwBaudRate;
        tDCB.ByteSize   = m_bByteSize;
        tDCB.Parity     = static_cast<BYTE>(m_eParity);
        tDCB.StopBits   = static_cast<BYTE>(m_eStopBits);
        if ( m_eParity == EP_NonParity )
        {
            tDCB.fParity = 0;
        }
        else
        {
            tDCB.fParity = 1;
        }   
        //ソフトフロー状態にする。
        tCommTimeOuts.ReadIntervalTimeout           = 0xFFFFFFFF;
        tCommTimeOuts.ReadTotalTimeoutMultiplier    = 0;
        tCommTimeOuts.ReadTotalTimeoutConstant      = 0;
        tCommTimeOuts.WriteTotalTimeoutMultiplier   = 1;
        tCommTimeOuts.WriteTotalTimeoutConstant     = 1000; //1s
        tDCB.fRtsControl        = RTS_CONTROL_DISABLE;
        tDCB.fDtrControl        = DTR_CONTROL_DISABLE;
        tDCB.fOutxCtsFlow       = FALSE;                //ClearToSend監視しない
        tDCB.fOutxDsrFlow       = FALSE;                //DataSetReady監視しない
        tDCB.fDsrSensitivity    = FALSE;                //DSR監視しない
        tDCB.fTXContinueOnXoff  = FALSE;                //XOffCharチェックなし
        tDCB.fInX               = FALSE;                //XON/XOFFフロー制御なし
        tDCB.fOutX              = FALSE;                //XON/XOFFフロー制御なし
        if ( ! OnRs232cOpening(hComPort, tDCB, tCommTimeOuts) )
        {
            return ERROR_NOT_READY; //ユーザ停止
        }
        // ポートの状態を設定
        if ( ! ::SetCommState(hComPort, &tDCB) || ! ::SetCommTimeouts(hComPort, &tCommTimeOuts) )
        {
            return _GetLastError("SetCommState/SetCommTimeouts");
        }
        return 0;
    }
    TProperty       m_property;         
    HANDLE          m_hComPort;         
    CPort           m_comPort;          
    DWORD           m_dwBaudRate;       
    BYTE            m_bByteSize;        
    EParity         m_eParity;          
    EStopBits       m_eStopBits;        
    mutable bool    m_boIsConnect;      
    bool            m_boCanBulkSend;    
    bool            m_isCheckCts;       
 
    #ifndef _TnbRS232C_EnumExistPorts_DISABLE
 
    class CMyFinder : private CDeepAccessFinder
    {
        DEFSUPER(CDeepAccessFinder);
    public:
        // 実行
        TDeviceVector Execute(IAccessor::CSection& section)
        {
            TDeviceVector vd;
            m_foundDriver.RemoveAll();
            m_foundPort.RemoveAll();
            _super::Execute(section);
            size_t l = m_foundDriver.GetSize();
            ASSERT( l == m_foundPort.GetSize() );
            if ( l > 0 )
            {
                const int BUF_MAX = 200;
                TCHAR buf[BUF_MAX];
                DWORD len = 0;
                BYTE* B = reinterpret_cast<BYTE*>(buf);
                SP_DEVINFO_DATA dev = { sizeof(SP_DEVINFO_DATA) };
                HDEVINFO hDevInfo = ::SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_PRESENT | DIGCF_ALLCLASSES);
                for ( int i = 0; ::SetupDiEnumDeviceInfo(hDevInfo, i, &dev); i++ )
                {
                    if ( ::SetupDiGetDeviceRegistryProperty(hDevInfo, &dev, SPDRP_DRIVER, NULL, B, BUF_MAX, &len) )
                    {
                        INDEX f = m_foundDriver.Find(buf);
                        if ( f != INVALID_INDEX )
                        {
                            TDevice t;
                            if ( ::SetupDiGetDeviceRegistryProperty(hDevInfo, &dev, SPDRP_DEVICEDESC, NULL, B, BUF_MAX, &len) )
                            {
                                t.description = buf;
                            }
                            if ( ::SetupDiGetDeviceRegistryProperty(hDevInfo, &dev, SPDRP_MFG, NULL, B, BUF_MAX, &len) )
                            {
                                t.manufacturer = buf;
                            }
                            if ( ::SetupDiGetDeviceRegistryProperty(hDevInfo, &dev, SPDRP_HARDWAREID, NULL, B, BUF_MAX, &len) )
                            {
                                CStr s = LowerString(buf);  //USB\Vid_067b&Pid_2303&Rev_0300
                                INT_PTR f1 = s.Find(_T("vid_"));
                                if ( f1 >= 0 )
                                {
                                    t.vid = down_cast<WORD>(STRLIB::ToInt(s.Mid(f1 + 4, 4), 16));
                                }
                                INT_PTR f2 = s.Find(_T("pid_"));
                                if ( f2 >= 0 )
                                {
                                    t.pid = down_cast<WORD>(STRLIB::ToInt(s.Mid(f2 + 4, 4), 16));
                                }
                            }
                            t.port = m_foundPort[f];
                            vd.Add(t);
                        }
                    }
                }
                VERIFY ( ::SetupDiDestroyDeviceInfoList(hDevInfo) );
            }
            vd.Sort();
            return vd;
        }
    protected:
        virtual EResult OnFindSection(LPCTSTR lpszSection, IAccessor::CSection& sec, int depth)
        {
            if ( STRLIB::Compare(lpszSection, _T("Device Parameters")) == 0 )
            {
                if ( sec.HasKey(_T("PortName")) )
                {
                    CStr s = sec.QueryString(_T("PortName"));
                    if ( s.Find(_T("COM")) == 0 )
                    {
                        m_foundPort.Add(static_cast<WORD>(s.ToInt(3)));
                        IAccessor::CSection s = sec;
                        s.PreviousSubSection();
                        m_foundDriver.Add(s.QueryString(_T("Driver")));
                    }
                    return Previous;
                }
            }
            return Next;
        }
    private:
        CWordVector m_foundPort;
        CStrVector  m_foundDriver;
    };
 
    #endif
 
    friend class CRs232cTest;       
};
 
 
 
class CRs232cHf : public CRs232c
{
protected:
    virtual bool OnRs232cOpening(HANDLE hComPort, DCB& _tDCB, COMMTIMEOUTS& _tCommTimeOuts)
    {
        _tCommTimeOuts.WriteTotalTimeoutMultiplier = 1;
        _tCommTimeOuts.WriteTotalTimeoutConstant = 1000;
        //
//      _tDCB.fOutxDsrFlow      = TRUE;
//      _tDCB.fDtrControl       = DTR_CONTROL_HANDSHAKE;
        _tDCB.fOutxCtsFlow      = TRUE;
        _tDCB.fRtsControl       = RTS_CONTROL_HANDSHAKE;
        _tDCB.fDsrSensitivity   = FALSE;
        //
        _tDCB.fTXContinueOnXoff = FALSE;
        _tDCB.fOutX = FALSE;
        _tDCB.fInX = FALSE;
        return true;
    }
};
 
 
 
}; // TNB