TnbRs232cEx.h

[詳解]

#pragma once
#include "TnbRs232c.h"
#include "TnbThread.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
class COverlapped : CCopyImpossible
{
public:
 
    COverlapped(void) : m_hEvent(NULL)
    {
        Zero(m_overLapped);
    }
 
    ~COverlapped(void)
    {
        if ( m_hEvent != NULL )
        {
            ::CloseHandle(m_hEvent);
            m_hEvent = NULL; 
        }
    }
 
    operator OVERLAPPED*(void)
    {
        Zero(m_overLapped);
        if ( m_hEvent == NULL )
        {
            m_hEvent = ::CreateEvent(NULL, FALSE, TRUE, NULL); 
            ::ResetEvent(m_hEvent);
        }
        ::ResetEvent(m_hEvent);
        m_overLapped.hEvent = m_hEvent; 
        return &m_overLapped;
    }
    
    size_t GetResult(HANDLE h, DWORD wait = 0)
    {
        if ( ::GetLastError() == ERROR_IO_PENDING )
        {
            // 非同期読み取り操作の結果をチェックする。
            ::Sleep(0);
            DWORD work = 0;
            if( ::GetOverlappedResult(h, &m_overLapped, &work, FALSE) )
            {
                return work;
            }
            else if ( ::GetLastError() != ERROR_IO_INCOMPLETE )
            {
                return INVALID_SIZE;
            }
        }
        size_t result = INVALID_SIZE;
        DWORD r = 0;
        switch ( ::WaitForSingleObject(m_overLapped.hEvent, wait) )
        {
        case WAIT_OBJECT_0:
            if ( ::GetOverlappedResult(h, &m_overLapped, &r, FALSE) )
            {
                result = r; // 成功
                ::CancelIo(h);
            }
            break;
        case WAIT_TIMEOUT:
            result = 0;
            break;
        case WAIT_ABANDONED:
        case WAIT_FAILED:
        default:
            ::CancelIo(h);
            break;
        }
        return result;
    }
    HANDLE          m_hEvent;       
    OVERLAPPED      m_overLapped;   
};
 
#endif //_TnbDOXYGEN
 
 
 
class CRs232cEx : public CRs232c, CThread::IRunner
{
    DEFSUPER(CRs232c);
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual void OnRs232cEvent(DWORD event) = 0;
    };
 
 
    //-----------------------------
 
 
    CRs232cEx(void) : m_propertyEx(_T("RS232C"), TNBVIW_KIND_RS232C), m_pListener(NULL)
    {
        m_propertyEx = _super::GetProperty();
        m_propertyEx.receiveTimeout = 300;
        m_eventMask = EV_RXCHAR | EV_RXFLAG | EV_TXEMPTY | EV_CTS | EV_DSR | EV_RLSD | EV_BREAK;
        m_eventMask |= EV_ERR | EV_RING | EV_PERR | EV_RX80FULL | EV_EVENT1 | EV_EVENT2;
    }
 
    ~CRs232cEx(void)
    {
        Close();
    }
 
 
    void SetListenEvent(DWORD event)
    {
        m_eventMask = event;
    }
 
    void SetListener(IListener* P)
    {
        m_pListener = P;
    }
 
    virtual const TProperty& GetProperty(void) const
    {
        return m_propertyEx;
    }
 
    virtual bool SetReceiveTimeout(DWORD to)
    {
        m_propertyEx.receiveTimeout = to;
        return true;
    }
 
    virtual bool Open(void)
    {
        bool r = _super::Open();
        m_propertyEx.typeName = _super::GetProperty().typeName;
        m_propertyEx.typeId = _super::GetProperty().typeId;
        if ( r )
        {
            m_thread.SetRunner(this);
            return m_thread.Start();
        }
        Close();
        return false;
    }
 
    virtual void Close(void)
    {
        ::SetCommMask(GetHandle(), 0);
        _super::Close();
        m_thread.Stop();
        m_propertyEx.typeName = _super::GetProperty().typeName;
        m_propertyEx.typeId = _super::GetProperty().typeId;
    }
 
 
    virtual size_t Receive(size_t size, LPVOID _P)
    {
        if ( size == 0 || m_propertyEx.receiveTimeout == 0 )
        {
            DWORD dwErrors;
            COMSTAT tComStat;
            if ( ! ::ClearCommError(GetHandle(), &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, GetHandle()) )
        {
            return redSize;
        }
        return INVALID_SIZE;
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_thread;
    }
 
protected:
 
    virtual DWORD Run(void)
    {
        ::SetCommMask(GetHandle(), m_eventMask);
        DWORD event;
        while ( IsRunnable() )
        {
            ::WaitCommEvent(GetHandle(), &event, m_eventOverlapped);
            if ( ::GetLastError() != ERROR_ACCESS_DENIED )
            {
                DWORD r = m_eventOverlapped.GetResult(GetHandle(), INFINITE);
                if ( r == sizeof(DWORD) )
                {
//                  TRACE1("★ RS232C Event = 0x%04X\n", event);
                    if ( m_pListener != NULL )
                    {
                        m_pListener->OnRs232cEvent(event);
                    }
                    if ( event == 0 )
                    {
                        break;
                    }
                }
            }
            else
            {
                ::SetCommMask(GetHandle(), m_eventMask);
            }
        }
        return 0;
    };
 
    virtual HANDLE CreatePort(LPCTSTR lpszPortName) const
    {
        DWORD desiredAccess = GENERIC_READ | GENERIC_WRITE; // アクセス (読み取りおよび書き込み) モード
        DWORD flag = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
        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;
        ::WriteFile(h, P, ToDword(len), &dwWritten, m_writeOverlapped);
        dwWritten = m_writeOverlapped.GetResult(h, INFINITE);
        if ( dwWritten == INVALID_SIZE )
        {
            return false;
        }
        _writtenSize = dwWritten;
        return true;
    }
 
    virtual bool ReadPort(size_t& _redSize, LPVOID _P, size_t len, HANDLE h) const
    {
        DWORD dwRed = 0;
        ::ReadFile(h, _P, ToDword(len), &dwRed, m_readOverlapped);
        dwRed = m_readOverlapped.GetResult(h, m_propertyEx.receiveTimeout);
        if ( dwRed == INVALID_SIZE )
        {
            return false;
        }
        _redSize = dwRed;
        return true;
    }
 
private:
    DWORD                   m_eventMask;        
    IListener*              m_pListener;        
    TProperty               m_propertyEx;       
    mutable CThread         m_thread;           
    mutable COverlapped     m_readOverlapped;   
    mutable COverlapped     m_writeOverlapped;  
    mutable COverlapped     m_eventOverlapped;  
};
 
 
 
}; // TNB