SerialPollThread.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
#include <windows.h>
 
#include <dcl/ArrayT.h>
#include <dcl/SerialPort.h>
#include <dcl/SerialPollThread.h>
 
#if __DCL_DEBUG
    #undef __THIS_FILE__
    static const char_t __THIS_FILE__[] = __T("dcl/SerialPollThread.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(SerialPollThread, PollThread)
 
SerialPollThread::SerialPollThread(const char_t *_name)
    : PollThread(_name)
{
    __pollInterrupt = CreateEvent(NULL, TRUE, FALSE, NULL);
}
 
SerialPollThread::~SerialPollThread()
{
    CloseHandle(__pollInterrupt);
}
 
bool SerialPollThread::add(PollAble* _pPollAble, short _events)
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(_pPollAble->isInstanceOf(CLASSINFO(SerialPort)));
 
    if (__terminate)
        return false;
 
    Thread::SingleLockMutex lock(__updateLock);
 
    if (((SerialPort*)_pPollAble)->__overlapped.hEvent == NULL) {
        ((SerialPort*)_pPollAble)->__overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
        if (((SerialPort*)_pPollAble)->__overlapped.hEvent == NULL)
            throw new IOException(_pPollAble->toString(), GetLastError());
    }
 
    if (!SetCommMask(_pPollAble->handle(), (DWORD)_events)) {
        CloseHandle(((SerialPort*)_pPollAble)->__overlapped.hEvent);
        throw new IOException(_pPollAble->toString(), GetLastError());
    }
 
    __updateList.add(Update(_pPollAble, true));
 
    // 스레드가 시작되고, 호출 스레드와 다르면
    if (Thread::started() && Thread::getCurrentThread() != this)
        SetEvent(__pollInterrupt);
 
    return true;
}
 
bool SerialPollThread::remove(PollAble* _pPollAble)
{
    if (__terminate)
        return false;
 
    Thread::SingleLockMutex lock(__updateLock);
 
    __updateList.add(Update(_pPollAble, false));
 
    // 스레드가 시작되고, 호출 스레드와 다르면
    if (Thread::started() && Thread::getCurrentThread() != this)
        SetEvent(__pollInterrupt);
 
    return true;
}
 
void SerialPollThread::terminate()
{
    __DCL_ASSERT(Thread::started());
    __terminate = true;
    SetEvent(__pollInterrupt);
}
 
int SerialPollThread::run()
{
    Array<SerialPort*> pollAbles;
    Array<HANDLE> fds;
 
    pollAbles.add(NULL);
    fds.add(__pollInterrupt);
 
    while (!__terminate) {
        {
            Thread::SingleLockMutex lock(__updateLock);
            if (!__updateList.isEmpty()) {
                ResetEvent(__pollInterrupt);
                for (UpdateList::Iterator itUpdate = __updateList.begin();
                        itUpdate != __updateList.end(); itUpdate++) {
                    Update& update = *itUpdate;
    //              __DCL_TRACE2(__T("add [%ls][%d]\n"), update.pPollAble->path(), update.bAdd);
                    if (update.bAdd) {
                        if (((SerialPort*) update.pPollAble)->waitCommEvent()) {
                            __DCL_TRACE1(__T("added [%ls]\n"),
                                update.pPollAble->toString().data());
                            pollAbles.add((SerialPort*) update.pPollAble);
                            fds.add(((SerialPort*) update.pPollAble)->__overlapped.hEvent);
                        }
                        else
                            onRemoved(update.pPollAble);
                    }
                    else {
                        Array<SerialPort*>::Iterator itPollAble =
                            pollAbles.find((SerialPort*) update.pPollAble);
                        if (itPollAble != pollAbles.end()) {
                            __DCL_TRACE1(__T("remove [%ls]\n"),
                                update.pPollAble->toString().data());
                            onRemoved(*itPollAble);
                            pollAbles.erase(itPollAble);
                            fds.erase(pollAbles.index(itPollAble));
                        }
                    }
                }   // end of for
                __updateList.clear();
            }
        }
 
        // Wait poll
    //  __DCL_TRACE2(__T("%d, %p\n"), fds.size(), fds.data());
        DWORD r = WaitForMultipleObjects(
            (DWORD) fds.size(),     // __in     DWORD nCount
            fds.data(),     // __in     const HANDLE* lpHandle
            FALSE,         // __in     BOOL bWaitAll
            INFINITE        // __in     DWORD dwMilliseconds
            );
 
        switch (r) {
            case WAIT_FAILED:
#if __DCL_DEBUG
                __DCL_TRACE1(__T("WaitFail! %u\n"), GetLastError());
                Thread::sleep(1000);
#endif
                break;
            case WAIT_TIMEOUT:
                // unreachable code. INFINITE
                break;
            case WAIT_OBJECT_0:
                ResetEvent(__pollInterrupt);
                break;
            default: {
                size_t index = r - WAIT_OBJECT_0;
                __DCL_ASSERT(1 <= index && index < fds.size());
                SerialPort* pSerialPort = pollAbles[index];
 
                /*
                EV_RXCHAR(0x01) 이벤트가 발생하면 SerialPortWait.revents에 0x01이 저장되고
                WaitMultipleObjects 이후 GetOverlappedResult 에서 0x04가 읽혀진다.
                2011-04-26
                
                DWORD dwEvtMask = 0;
                GetOverlappedResult(pWait->pSerialPort->handle(),
                    &(pWait->overlapped), &dwEvtMask, TRUE);
                __DCL_TRACE2(__T("%d, %d\n"), pWait->revents, dwEvtMask);
                */
 
                try {
                    if (pSerialPort->onEvent((short)(pSerialPort->__revents), this))
                        pSerialPort->waitCommEvent();
                    else
                        remove(pSerialPort);
                }
                catch (IOException* cause) {
                    remove(pSerialPort);
                    /*
                        *   복구 불가능한 치명적 포트오류가 발생했다.
                        *   USB to COM 변환기를 사용한 경우 포트가 제거된 경우일 수 있다.
                        */
                    __DCL_TRACE1(__T("onEvent or waitCommEvent Fail! %ls\n"),
                        cause->toString().data());
                    cause->destroy();
                }
            }
        }   // end of switch
    }   // end of while(!__terminate)

    for (Array<SerialPort*>::Iterator itPollAble = pollAbles.begin();
            itPollAble != pollAbles.end(); itPollAble++) {
        // NULL 인 것은 __pollInterrupt를 위한 것이다.
        if (*itPollAble != NULL) {
            __DCL_TRACE1(__T("terminate remove [%ls]\n"),
                (*itPollAble)->toString().data());
            onRemoved(*itPollAble);
        }
    }
 
    // __updateList에 추가된 것이 있을 수 있다.
    for (UpdateList::Iterator itUpdate = __updateList.begin(); 
            itUpdate != __updateList.end(); itUpdate++) {
        Update& update = *itUpdate;
        if (update.bAdd) {
            __DCL_TRACE1(__T("terminate remove [%ls]\n"),
                update.pPollAble->toString().data());
            onRemoved(update.pPollAble);
        }
    }
 
    return 0;
}
 
__DCL_END_NAMESPACE
 
#endif      // __DCL_WINDOWS