Public Support

/**

 * This 

 * 

 *

 * @file

 * Copyright © Audi Electronics Venture GmbH. All rights reserved.

 *

 * $Author: ELAMIHA $

 * $Date: 2014-11-21 11:30:22 +0100 (Fri, 21 Nov 2014) $

 * $Revision: 1180 $

 *

 * @remarks

 *

 */

#include "stdafx.h"

#ifdef NO_GLOBAL_WINDOWS_SDK_FROM_STDAFX 

    #include "../library_includes_windows.h"

#endif

#ifndef WIN32

    #include <poll.h>

    #include <termios.h>

#endif

#include "a_utils_comm.h"

#ifdef WIN32

/*

                //open COM1 for read and write

                hPort=CreateFile( "COM1",

                  GENERIC_READ | GENERIC_WRITE, //bidirectional

                  0, 

                  NULL, //no security

                  OPEN_EXISTING,  //this must be set; the ports are already created

                  FILE_ATTRIBUTE_NORMAL, // maybe with | FILE_FLAG_OVERLAPPED  

                  NULL );

Standard ReadFile() and WriteFile() functions can then be used to read or write to the port.

To set the port up reliably, COM port specific functions need to be used, so look up the online

help for details on the following functions:

    GetCommModemStatus(), SetCommState(), SetCommMask(), SetupComm(),

    PurgeComm(), ClearCommError(), SetCommTimeouts() and EscapeCommFunction() 

Tips:- 

Even on Win9x, you can use overlapped IO with a com port 

The Signalled state of a port seems to indicates it is ready for reading or writing, even if you only opened the port unidirectionally. 

WaitCommEvent() lets you block waiting for something interesting to happen, such as data arriving or various lines (e.g. RI -Ring Indicator) toggling. 

On win98/NT5, RequestDeviceWakeup() may even let the external port wake up your app -especially if RI is used as the signal. 

*/

namespace A_UTILS_NS

{

/**************************************/

/* This still needs to be implemented.*/

/**************************************/

A_UTILS_P_DECLARE_PRE(cSerialDevice);

cSerialDevice::cSerialDevice()

{

    m_hDevice = NULL;

}

cSerialDevice::~cSerialDevice()

{

    Close();

}

tResult cSerialDevice::Open(const tChar* strDeviceName, tInt nBaudRate, tInt nParity, tInt nDataBits, 

                            tInt nStopBits, tInt nRxQueue, tInt nTxQueue, tTimeStamp nReadTimeout)

{

    RETURN_IF_POINTER_NULL(strDeviceName);

    if (nBaudRate < 0 ||

        nParity < 0 ||

        nDataBits < 0 ||

        nStopBits < 0 ||

        nRxQueue < 0 ||

        nTxQueue < 0 ||

        nReadTimeout < 0)

    {

        RETURN_ERROR(ERR_INVALID_ARG);

    }

    Close();

    BOOL bStatus = TRUE;

    m_hDevice = ::CreateFile(strDeviceName,

                           GENERIC_READ | GENERIC_WRITE,

                           0,

                           NULL,

                           OPEN_EXISTING,

                           FILE_ATTRIBUTE_NORMAL,

                           NULL);

    if (m_hDevice == NULL || m_hDevice == INVALID_HANDLE_VALUE)

    {

        DWORD dwError = cSystem::GetLastSystemError();

        RETURN_ERROR(ERR_OPEN_FAILED);

    }

    // get current config

    DCB sDevCtrl;

    sDevCtrl.DCBlength = sizeof(sDevCtrl);

    bStatus = ::GetCommState(m_hDevice, &sDevCtrl);

    if (bStatus == FALSE)

    {

        RETURN_ERROR(ERR_DEVICE_NOT_READY);

    }

    sDevCtrl.BaudRate    = nBaudRate;

    switch (nParity)

    {

        case SER_EVENPARITY:

            sDevCtrl.Parity = EVENPARITY;

            break;

        case SER_MARKPARITY:

            sDevCtrl.Parity = MARKPARITY;

            break;

        case SER_NOPARITY:

            sDevCtrl.Parity = NOPARITY;

            break;

        case SER_ODDPARITY:

            sDevCtrl.Parity = ODDPARITY;

            break;

        case SER_SPACEPARITY:

            sDevCtrl.Parity = SPACEPARITY;

            break;

        default:

            RETURN_ERROR(ERR_INVALID_ARG);

    }

    switch (nStopBits)

    {

        case SER_ONESTOPBIT:

            sDevCtrl.StopBits = ONESTOPBIT;

            break;

        case SER_ONE5STOPBITS:

            sDevCtrl.StopBits = ONE5STOPBITS;

            break;

        case SER_TWOSTOPBITS:

            sDevCtrl.StopBits = TWOSTOPBITS;

            break;

        default:

            RETURN_ERROR(ERR_INVALID_ARG);

    }

    sDevCtrl.ByteSize    = nDataBits;

    bStatus = ::SetCommState(m_hDevice, &sDevCtrl);

    if (bStatus == FALSE)

    {

        DWORD dwError = cSystem::GetLastSystemError();

        RETURN_ERROR(ERR_DEVICE_NOT_READY);

    }

    bStatus = ::SetupComm(m_hDevice, nRxQueue, nTxQueue);

    if (bStatus == FALSE)

    {

        DWORD dwError = cSystem::GetLastSystemError();

        RETURN_ERROR(ERR_DEVICE_NOT_READY);

    }

    COMMTIMEOUTS sCommTimeOuts;

    sCommTimeOuts.ReadIntervalTimeout         = MAXDWORD;

    sCommTimeOuts.ReadTotalTimeoutMultiplier  = MAXDWORD;

    sCommTimeOuts.ReadTotalTimeoutConstant    = (DWORD)(nReadTimeout / 1000);

    sCommTimeOuts.WriteTotalTimeoutMultiplier = 0;

    sCommTimeOuts.WriteTotalTimeoutConstant   = 5000;

    ::SetCommTimeouts(m_hDevice, &sCommTimeOuts);

    RETURN_NOERROR;

}

tResult cSerialDevice::Close()

{

    if (m_hDevice != NULL)

    {

        ::CloseHandle(m_hDevice);

        m_hDevice = NULL;

    }

    RETURN_NOERROR;

}

tResult cSerialDevice::CheckForDevice(const tChar* strDeviceName)

{

    HANDLE hDevice = ::CreateFile(strDeviceName,

                                  GENERIC_READ | GENERIC_WRITE,

                                  0,

                                  NULL,

                                  OPEN_EXISTING,

                                  FILE_ATTRIBUTE_NORMAL,

                                  NULL);

    if (hDevice != NULL)

    {

        ::CloseHandle(hDevice);

    }

    if (hDevice == NULL || hDevice == INVALID_HANDLE_VALUE)

    {

        RETURN_ERROR(ERR_NOT_FOUND);

    }

    RETURN_NOERROR;

}

tUInt32 cSerialDevice::GetDeviceMask()

{

    tUInt32 nMask = 0x0;

    for (tInt nDevNr=0; nDevNr<32; nDevNr++)

    {

        if (IS_OK(CheckForDevice("\\\\.\\COM" + cString::Format("%d", nDevNr+1))))

        {

            nMask |= (1 << nDevNr);

        }

    }

    return nMask;

}

tUInt32 cSerialDevice::GetUnusedDeviceMask()

{

    tUInt32 nMask = GetDeviceMask();

    tHandle hDevice;

    for (tInt nDevNr=0; nDevNr<32; nDevNr++)

    {

        if ((nMask & (1 << nDevNr)) != 0)

        {

            hDevice = ::CreateFile(cString::Format("COM%d", nDevNr+1),

                                GENERIC_READ | GENERIC_WRITE,

                                0,

                                NULL,

                                OPEN_EXISTING,

                                FILE_ATTRIBUTE_NORMAL,

                                NULL );

            if (hDevice == NULL  || hDevice == INVALID_HANDLE_VALUE)

            {

                nMask &= (~(1 << nDevNr));

            }

            else

            {

                ::CloseHandle(hDevice);

            }

        }

    }

    return nMask;

}

tResult cSerialDevice::FindUnusedDevice(cString& strDeviceName)

{

    tUInt32 nMask = GetUnusedDeviceMask();

    if (nMask == 0x0)

    {

        strDeviceName.Clear();

        RETURN_ERROR(ERR_BAD_DEVICE);

    }

    tInt nDevNr = 0;

    for (nDevNr = 0; nDevNr<32; nDevNr++)

    {

        if ((nMask & (1 << nDevNr)) != 0)

        {

            break;

        }

    }

    strDeviceName = cString::Format("COM%d", nDevNr+1);

    RETURN_NOERROR;

}

tInt32 cSerialDevice::Read(tVoid* pBuffer, tInt32 nBufferSize)

{

    if (pBuffer == NULL)

    {

        return -1;

    }

    tInt32 nReadCount = 0;

    #ifdef WIN32

        DWORD dwReadCount = 0;

        BOOL bStatus = ::ReadFile(m_hDevice, (BYTE*) pBuffer, nBufferSize, &dwReadCount, NULL);

        if (bStatus)

        {

            nReadCount = (tInt32) dwReadCount;

        }

        else

        {

            nReadCount = -1;

        }

    #else // WIN32

        nReadCount = -1;

    #endif // WIN32

    return nReadCount;

}

tInt32 cSerialDevice::Write(const tVoid* pBuffer, tInt32 nBufferSize)

{

    if (pBuffer == NULL)

    {

        return -1;

    }

    #ifdef WIN32

        DWORD dwWriteCount = 0;

        BOOL bStatus = ::WriteFile(m_hDevice,

            pBuffer,

            nBufferSize,

            &dwWriteCount,

            NULL);

        if (!bStatus || dwWriteCount != nBufferSize)

        {

            return -1;

        }

        return (tInt32) dwWriteCount;

    #else // WIN32

        return -1;

    #endif // WIN32

}

tBool cSerialDevice::IsConnected()

{

    return (m_hDevice != NULL);

}

} // namespace A_UTILS_NS

#else // WIN32

namespace A_UTILS_NS

{

A_UTILS_P_DECLARE(cSerialDevice)

{

    friend class cSerialDevice;

    public:

        pollfd m_sPoll;

        tInt   m_nTimeoutMilli;

};

cSerialDevice::cSerialDevice():

        m_nDev(-1)

{

    A_UTILS_D_CREATE(cSerialDevice);

}

cSerialDevice::~ cSerialDevice()

{

    Close();

}

#define BAUDCASE(rate) case rate: nBaudSetting = B##rate; break;

tResult cSerialDevice::Open(const tChar * strDeviceName, 

                            tInt nBaudRate, 

                            tInt nParity, 

                            tInt nDataBits, 

                            tInt nStopBits, 

                            tInt nRxQueue, 

                            tInt nTxQueue, 

                            tTimeStamp nReadTimeout)

{

    RETURN_IF_POINTER_NULL(strDeviceName);

    if (nBaudRate < 0 ||

        nParity < 0 ||

        nDataBits < 0 ||

        nStopBits < 0 ||

        nRxQueue < 0 ||

        nTxQueue < 0 ||

        nReadTimeout < 0)

    {

        RETURN_ERROR(ERR_INVALID_ARG);

    }

    m_nDev = open(strDeviceName, O_RDWR|O_NOCTTY);

    if (m_nDev < 0)

    {

        RETURN_ERROR(ERR_OPEN_FAILED);

    }

    // please see http://www.easysw.com/~mike/serial/serial.html

    // for an in-depth description of the following options.

    struct termios sOptions;

    if (tcgetattr(m_nDev, &sOptions) < 0)

    {

        Close();

        LOG_ERROR(cString::Format("Unable to get serial device options: %s", strerror(errno)));

        RETURN_ERROR(ERR_DEVICE_IO);

    }

    // set baud-rate 

    tInt nBaudSetting = 0;

    switch (nBaudRate)

    {

        BAUDCASE(0)

        BAUDCASE(50)

        BAUDCASE(75)

        BAUDCASE(110)

        BAUDCASE(134)

        BAUDCASE(150)

        BAUDCASE(300)

        BAUDCASE(600)

        BAUDCASE(1200)

        BAUDCASE(1800)

        BAUDCASE(2400)

        BAUDCASE(4800)

        BAUDCASE(9600)

        BAUDCASE(19200)

        BAUDCASE(38400)

        BAUDCASE(57600)

        //BAUDCASE(76800)

        BAUDCASE(115200)

        BAUDCASE(230400 )

        #ifndef __APPLE__

            BAUDCASE(460800)

            BAUDCASE(500000)

            BAUDCASE(576000)

            BAUDCASE(921600)

            BAUDCASE(1000000)

            BAUDCASE(1152000)

            BAUDCASE(1500000)

            BAUDCASE(2000000)

            BAUDCASE(2500000)

            BAUDCASE(3000000)

            BAUDCASE(3500000)

            BAUDCASE(4000000)

        #endif //__APPLE__

        default:

            RETURN_ERROR(ERR_NOT_SUPPORTED);

    }

    cfsetispeed(&sOptions, nBaudSetting);

    cfsetospeed(&sOptions, nBaudSetting);

    sOptions.c_cflag |= (CLOCAL | CREAD);

    // set parity

    switch (nParity)

    {

        case SER_EVENPARITY:

            sOptions.c_cflag |= PARENB;

            sOptions.c_cflag &= ~PARODD;

            sOptions.c_cflag &= ~CSTOPB;

            sOptions.c_cflag &= ~CSIZE;

            sOptions.c_cflag |= CS7;

            break;

        case SER_MARKPARITY:

            RETURN_ERROR(ERR_NOT_SUPPORTED);

            break;

        case SER_NOPARITY:

            sOptions.c_cflag &= ~PARENB;

            sOptions.c_cflag &= ~CSTOPB;

            sOptions.c_cflag &= ~CSIZE;

            sOptions.c_cflag |= CS8;

            break;

        case SER_ODDPARITY:

            sOptions.c_cflag |= PARENB;

            sOptions.c_cflag |= PARODD;

            sOptions.c_cflag &= ~CSTOPB;

            sOptions.c_cflag &= ~CSIZE;

            sOptions.c_cflag |= CS7;

            break;

        case SER_SPACEPARITY:

            RETURN_ERROR(ERR_NOT_SUPPORTED);

        default:

            RETURN_ERROR(ERR_INVALID_ARG);

    }

    // set data size

    sOptions.c_cflag &= ~CSIZE;

    switch (nDataBits)

    {

        case 5:

            sOptions.c_cflag |= CS5;

            break;

        case 6:

            sOptions.c_cflag |= CS6;

            break;

        case 7:

            sOptions.c_cflag |= CS7;

            break;

        case 8:

            sOptions.c_cflag |= CS8;

            break;

        default:

            RETURN_ERROR(ERR_INVALID_ARG);

    }

    // set stop bits

    switch (nStopBits)

    {

        case SER_ONESTOPBIT:

            sOptions.c_cflag &= ~CSTOPB;

            break;

        case SER_ONE5STOPBITS:

            RETURN_ERROR(ERR_NOT_SUPPORTED);

            break;

        case SER_TWOSTOPBITS:

            sOptions.c_cflag |= CSTOPB;

            break;

        default:

            RETURN_ERROR(ERR_INVALID_ARG);

    }

    // use raw mode

    sOptions.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);

    sOptions.c_oflag &= ~OPOST;

#ifdef IUCLC

    sOptions.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |

                          INLCR | IGNCR | ICRNL | IXON | IXOFF | IUCLC | IXANY |

                          IMAXBEL | ISIG);

#else

    sOptions.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |

                          INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY |

                          IMAXBEL | ISIG);

#endif //IUCLC

    //set timeout

    sOptions.c_cc[VMIN] = 0;

    sOptions.c_cc[VTIME] = nReadTimeout / 100000;

    //Set the new options for the port...

    if (tcsetattr(m_nDev, TCSANOW, &sOptions) < 0)

    {

        Close();

        LOG_ERROR(cString::Format("Unable to set serial device options: %s", strerror(errno)));

        RETURN_ERROR(ERR_DEVICE_IO);

    }

    _d->m_sPoll.fd = m_nDev;

    _d->m_sPoll.events = POLLIN;

    _d->m_nTimeoutMilli = nReadTimeout / 1000;

    RETURN_NOERROR;

}

tResult cSerialDevice::Close()

{

    if (IsConnected())

    {

        close(m_nDev);

        m_nDev = -1;

    }

    RETURN_NOERROR;

}

tInt32 cSerialDevice::Read(tVoid * pBuffer, tInt32 nBufferSize)

{

    if (m_nDev == -1)

    {

        return -1;

    }

    if (_d->m_nTimeoutMilli)

    {

        if (0 == poll(&_d->m_sPoll, 1, _d->m_nTimeoutMilli))

        {

            // timeout

            return 0;

        }

    }

    return read(m_nDev, pBuffer, nBufferSize);;

}

tInt32 cSerialDevice::Write(const tVoid * pBuffer, tInt32 nBufferSize)

{

    return write(m_nDev, pBuffer, nBufferSize);

}

tBool cSerialDevice::IsConnected()

{

    return m_nDev != -1;

}

tResult cSerialDevice::CheckForDevice(const tChar* strDeviceName)

{

    if (cFileSystem::Exists(strDeviceName))

    {

        RETURN_NOERROR;

    }

    RETURN_ERROR(ERR_NOT_FOUND);

}

tUInt32 cSerialDevice::GetDeviceMask()

{

    return 0;

}

tUInt32 cSerialDevice::GetUnusedDeviceMask()

{

    return 0;

}

tResult cSerialDevice::FindUnusedDevice(cString& strDeviceName)

{

    RETURN_ERROR(ERR_NOT_SUPPORTED);

}

}

#endif

tResult A_UTILS_NS::cSerialDevice::WriteByteByByte(const cString &strCmd)

{

    char acSign[1];

    for (tInt32 nChar=0; nChar < strCmd.GetLength(); nChar++)

    {

        acSign[0] = strCmd.GetAt(nChar);

        if (Write(acSign, 1) != 1)

        {

            RETURN_ERROR(ERR_FAILED);

        }

        cSystem::Sleep(50);

    }

    RETURN_NOERROR;

}