---

serialPAL.hpp

Go to the documentation of this file.

#ifndef __SERIAL_WIN32_PAL_HPP__
#define __SERIAL_WIN32_PAL_HPP__

//#include <winbase.h>
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <windows.h>

namespace lfc
{
namespace win32PAL
{


namespace serial
{

const int MAX_ERROR_CODE = 2;

enum ErrorCodes
{
    errOk,
    errGeneric,
    errNotSupported,
};

extern const char *messagesTable[MAX_ERROR_CODE + 1];


typedef ::HANDLE Handle;

const Handle NULL_HANDLE = INVALID_HANDLE_VALUE;


struct PortSettings
{
    DCB dcb;
    COMMTIMEOUTS commTimeouts;
};


const int
    purgeInput      = 0x0001,
    purgeOutput     = 0x0002;

const int
    mstatusDSR      = 0x0001,
    mstatusDTR      = 0x0002,//$ not supported!
    mstatusRTS      = 0x0004,//$ not supported!
    mstatusCTS      = 0x0008,
    mstatusDCD      = 0x0010,
    mstatusRNG      = 0x0020;



inline int init()
{
    return errOk;
}



inline int cleanup()
{
    return errOk;
}



inline int open(Handle &handle, const char *name)
{
    assert(handle == NULL_HANDLE);

    HANDLE h = ::CreateFile(name, GENERIC_READ | GENERIC_WRITE,
        0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if(h != INVALID_HANDLE_VALUE)
    {
        handle = h;
        return errOk;
    }
    else
        return errGeneric;
}



inline int close(Handle handle)
{
    assert(handle != NULL_HANDLE);
    return ::CloseHandle(handle) ? errOk : errGeneric;
}



inline int write(Handle handle, const void *buff, long count, long &writtenCount)
{
    assert(handle != NULL_HANDLE);

    DWORD dwCount = static_cast<DWORD>(count);
    DWORD dwWritten = 0;

    if(::WriteFile(handle, buff, dwCount, &dwWritten, NULL))
    {
        writtenCount = static_cast<long>(dwWritten);
        return errOk;
    }
    else
        return errGeneric;
}


inline int read(Handle handle, void *buff, long count, long &readCount)
{
    assert(handle != NULL_HANDLE);

    DWORD dwCount = static_cast<DWORD>(count);
    DWORD dwRead = 0;

    if(::ReadFile(handle, buff, dwCount, &dwRead, NULL))
    {
        readCount = static_cast<long>(dwRead);
        return errOk;
    }
    else
        return errGeneric;
}



inline int flush(Handle handle)
{
    assert(handle != NULL_HANDLE);
    return ::FlushFileBuffers(handle) ? errOk : errGeneric;
}



inline int setup(Handle handle, const char *portSettings)
{
    assert(handle != NULL_HANDLE);
    assert(portSettings != NULL);

    const char *p = portSettings;
    long baud = 0;
    long byteSize = 0;
    long stopBits = 0;
    char parity = '#';
    
    // parse settings
    while( isdigit(*p) )
        baud = baud * 10 + *p++ - '0';
    if(*p++ != ',')
        return errGeneric;
    byteSize = *p++ - '0';
    if(byteSize < 5 || byteSize > 8)
        return errGeneric;
    parity = toupper(*p++);
    if(::strchr("NOES", parity) == NULL)
        return errGeneric;
    stopBits = *p++ - '0';
    if(stopBits != 1 && stopBits != 2)
        return errGeneric;
    if(*p != 0)
        return errGeneric;
        
    // setup DCB
    char buff[1024];
    ::sprintf(buff, "%ld,%c,%ld,%ld", baud, parity, byteSize, stopBits);
    
    DCB dcb = {0};
    dcb.DCBlength = sizeof(DCB);
    
    // warning: under win9x first BuildCommDCB must not be r/o!
    if(!::BuildCommDCB(buff, &dcb))
        return errGeneric;
        
    return ::SetCommState(handle, &dcb) ? errOk : errGeneric;
}



inline int availableCount(Handle handle, long &count)
{
    assert(handle != NULL_HANDLE);

    DWORD dwErrors;
    COMSTAT comStat = {0};

    ::ClearCommError(handle, &dwErrors, &comStat);
    assert(dwErrors == 0);

    count = static_cast<long>(comStat.cbInQue);
    return errOk;
}



inline int setHardwareFlowControl(Handle handle, bool bEnable)
{
    assert(handle != NULL_HANDLE);

    DCB dcb = {0};
    dcb.DCBlength = sizeof(DCB);

    if(!::GetCommState(handle, &dcb))
        return errGeneric;

    if(bEnable)
    {
        dcb.fOutxCtsFlow = true;
        dcb.fOutxDsrFlow = true;
        dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;//$?
        dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;//$?
    }
    else
    {
        dcb.fOutxCtsFlow = false;
        dcb.fOutxDsrFlow = false;
        dcb.fDtrControl = DTR_CONTROL_ENABLE;
        dcb.fRtsControl = RTS_CONTROL_ENABLE;
    }

    return ::SetCommState(handle, &dcb) ? errOk : errGeneric;
}



inline int setSoftwareFlowControl(Handle handle, bool bEnable, char Xon, char Xoff)
{
    assert(handle != NULL_HANDLE);

    DCB dcb = {0};
    dcb.DCBlength = sizeof(DCB);

    if(!::GetCommState(handle, &dcb))
        return errGeneric;

    if(bEnable)
    {
        dcb.fOutX = true;
        dcb.fInX = true;
        dcb.fTXContinueOnXoff = false;//$?
        dcb.XonLim = 256;//$?
        dcb.XoffLim = 512;//$?
    }
    else
    {
        dcb.fOutX = false;
        dcb.fInX = false;
    }

    return ::SetCommState(handle, &dcb) ? errOk : errGeneric;
}



inline int setReadTimeouts(Handle handle, long timeout)
{
    assert(handle != NULL_HANDLE);

    COMMTIMEOUTS to = {0};

    if(!::GetCommTimeouts(handle, &to))
        return errGeneric;

    to.ReadIntervalTimeout = MAXDWORD;
    to.ReadTotalTimeoutMultiplier = MAXDWORD;
    to.ReadTotalTimeoutConstant = timeout;

    return ::SetCommTimeouts(handle, &to) ? errOk : errGeneric;
}



inline int setBlockingRead(Handle handle, bool bBlocking)
{
    assert(handle != NULL_HANDLE);

    COMMTIMEOUTS to = {0};

    if(!::GetCommTimeouts(handle, &to))
        return errGeneric;

    if(bBlocking)
    {
        to.ReadIntervalTimeout = 0;
        to.ReadTotalTimeoutMultiplier = 0;
        to.ReadTotalTimeoutConstant = 0;
    }
    else
    {
        to.ReadIntervalTimeout = MAXDWORD;
        to.ReadTotalTimeoutMultiplier = 0;
        to.ReadTotalTimeoutConstant = 0;
    }

    return ::SetCommTimeouts(handle, &to) ? errOk : errGeneric;
}



inline int purgeBuffer(Handle handle, int flags)
{
    assert(handle != NULL_HANDLE);
    
    DWORD win32flags = 0;
    win32flags |= flags & purgeInput ? PURGE_RXCLEAR : 0;
    win32flags |= flags & purgeOutput ? PURGE_TXCLEAR : 0;

    return ::PurgeComm(handle, win32flags) ? errOk : errGeneric;
}



inline int sendBreak(Handle handle)
{
    assert(handle != NULL_HANDLE);

    if(!::SetCommBreak(handle))
        return errGeneric;
    ::Sleep(500);
    if(!::ClearCommBreak(handle))
        return errGeneric;
        
    return errOk;
}



inline int getModemStatus(Handle handle, int &status)
{
    assert(handle != NULL_HANDLE);
    
    DWORD win32status = 0;
    
    if(!::GetCommModemStatus(handle, &win32status))
        return errGeneric;
        
    status = 0;
    status |= win32status & MS_CTS_ON ? mstatusCTS : 0;
    status |= win32status & MS_DSR_ON ? mstatusDSR : 0;
    status |= win32status & MS_RING_ON ? mstatusRNG : 0;
    status |= win32status & MS_RLSD_ON ? mstatusDCD : 0;
    
    return errOk;
}



inline int setDTR(Handle handle, bool bEnable)
{
    assert(handle != NULL_HANDLE);
    return ::EscapeCommFunction(handle, bEnable ? SETDTR : CLRDTR) ?
        errOk : errGeneric;
}



inline int setRTS(Handle handle, bool bEnable)
{
    assert(handle != NULL_HANDLE);
    return ::EscapeCommFunction(handle, bEnable ? SETRTS : CLRRTS) ?
        errOk : errGeneric;
}



inline int saveSettings(Handle handle, PortSettings &settings)
{
    assert(handle != NULL_HANDLE);
    
    // get current DCB
    DCB dcb = {0};
    dcb.DCBlength = sizeof(DCB);
    if(!::GetCommState(handle, &dcb))
        return errGeneric;

    // get current comm timeouts
    COMMTIMEOUTS to = {0};
    if(!::GetCommTimeouts(handle, &to))
        return errGeneric;
        
    settings.dcb = dcb;
    settings.commTimeouts = to;
    return errOk;
}



inline int restoreSettings(Handle handle, const PortSettings &settings)
{
    assert(handle != NULL_HANDLE);
    
    DCB dcb = settings.dcb;
    COMMTIMEOUTS commTimeouts = settings.commTimeouts;
    
    // restore DCB
    if(!::SetCommState(handle, &dcb))
        return errGeneric;
    
    // restore comm timeouts
    if(!::SetCommTimeouts(handle, &commTimeouts))
        return errGeneric;
        
    return errOk;
}



inline const char *message(int index)
{
    assert(index >= 0 && index <= MAX_ERROR_CODE);
    return messagesTable[index];
}


} // namespace win32PAL::serial
} // namespace win32PAL

namespace pal = win32PAL;

} // namespace lfc


#endif  // __SERIAL_WIN32_PAL_HPP__

---