WebSVN – HomeAutomation – Diff – /branches/atomV2/PcSoftware/canBootloaderCPP/canBootloader/Serial.cpp


//  Serial.cpp - Implementation of the CSerial class
//
//  Copyright (C) 1999-2003 Ramon de Klein (Ramon.de.Klein@ict.nl)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
//////////////////////////////////////////////////////////////////////
// Include the standard header files
 
#define STRICT
#include <crtdbg.h>
#include <tchar.h>
#include <windows.h>
#include "stdafx.h"
 
 
//////////////////////////////////////////////////////////////////////
// Include module headerfile
 
#include "Serial.h"
 
 
//////////////////////////////////////////////////////////////////////
// Disable warning C4127: conditional expression is constant, which
// is generated when using the _RPTF and _ASSERTE macros.
 
#pragma warning(disable: 4127)
 
 
//////////////////////////////////////////////////////////////////////
// Enable debug memory manager
 
#ifdef _DEBUG
 
#ifdef THIS_FILE
#undef THIS_FILE
#endif
 
static const char THIS_FILE[] = __FILE__;
#define new DEBUG_NEW
 
#endif
 
 
//////////////////////////////////////////////////////////////////////
// Helper methods
 
inline void CSerial::CheckRequirements (LPOVERLAPPED lpOverlapped, DWORD dwTimeout) const
{
#ifdef SERIAL_NO_OVERLAPPED
 
    // Check if an overlapped structure has been specified
    if (lpOverlapped || (dwTimeout != INFINITE))
    {
        // Quit application
        ::MessageBox(0,_T("Overlapped I/O and time-outs are not supported, when overlapped I/O is disabled."),_T("Serial library"), MB_ICONERROR | MB_TASKMODAL);
        ::DebugBreak();
        ::ExitProcess(0xFFFFFFF);
    }
 
#endif
 
#ifdef SERIAL_NO_CANCELIO
 
    // Check if 0 or INFINITE time-out has been specified, because
    // the communication I/O cannot be cancelled.
    if ((dwTimeout != 0) && (dwTimeout != INFINITE))
    {
        // Quit application
        ::MessageBox(0,_T("Timeouts are not supported, when SERIAL_NO_CANCELIO is defined"),_T("Serial library"), MB_ICONERROR | MB_TASKMODAL);
        ::DebugBreak();
        ::ExitProcess(0xFFFFFFF);
    }
 
#endif  // SERIAL_NO_CANCELIO
 
    // Avoid warnings
    (void) dwTimeout;
    (void) lpOverlapped;
}
 
inline BOOL CSerial::CancelCommIo (void)
{
#ifdef SERIAL_NO_CANCELIO
    // CancelIo shouldn't have been called at this point
    ::DebugBreak();
    return FALSE;
#else
 
    // Cancel the I/O request
    return ::CancelIo(m_hFile);
 
#endif  // SERIAL_NO_CANCELIO
}
 
 
//////////////////////////////////////////////////////////////////////
// Code
 
CSerial::CSerial ()
    : m_lLastError(ERROR_SUCCESS)
    , m_hFile(0)
    , m_eEvent(EEventNone)
    , m_dwEventMask(0)
#ifndef SERIAL_NO_OVERLAPPED
    , m_hevtOverlapped(0)
#endif
{
}
 
CSerial::~CSerial ()
{
    // If the device is already closed,
    // then we don't need to do anything.
    if (m_hFile)
    {
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::~CSerial - Serial port not closed\n");
 
        // Close implicitly
        Close();
    }
}
 
CSerial::EPort CSerial::CheckPort (LPCTSTR lpszDevice)
{
    // Try to open the device
    HANDLE hFile = ::CreateFile(lpszDevice,
                           GENERIC_READ|GENERIC_WRITE,
                           0,
                           0,
                           OPEN_EXISTING,
                           0,
                           0);
 
    // Check if we could open the device
    if (hFile == INVALID_HANDLE_VALUE)
    {
        // Display error
        switch (::GetLastError())
        {
        case ERROR_FILE_NOT_FOUND:
            // The specified COM-port does not exist
            return EPortNotAvailable;
 
        case ERROR_ACCESS_DENIED:
            // The specified COM-port is in use
            return EPortInUse;
 
        default:
            // Something else is wrong
            return EPortUnknownError;
        }
    }
 
    // Close handle
    ::CloseHandle(hFile);
 
    // Port is available
    return EPortAvailable;
}
 
LONG CSerial::Open (LPCTSTR lpszDevice, DWORD dwInQueue, DWORD dwOutQueue, bool fOverlapped)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the port isn't already opened
    if (m_hFile)
    {
        m_lLastError = ERROR_ALREADY_INITIALIZED;
        _RPTF0(_CRT_WARN,"CSerial::Open - Port already opened\n");
        return m_lLastError;
    }
 
    // Open the device
    m_hFile = ::CreateFile(lpszDevice,
                           GENERIC_READ|GENERIC_WRITE,
                           0,
                           0,
                           OPEN_EXISTING,
                           fOverlapped?FILE_FLAG_OVERLAPPED:0,
                           0);
    if (m_hFile == INVALID_HANDLE_VALUE)
    {
        // Reset file handle
        m_hFile = 0;
 
        // Display error
        m_lLastError = ::GetLastError();
        _RPTF0(_CRT_WARN, "CSerial::Open - Unable to open port\n");
        return m_lLastError;
    }
 
#ifndef SERIAL_NO_OVERLAPPED
    // We cannot have an event handle yet
    _ASSERTE(m_hevtOverlapped == 0);
 
    // Create the event handle for internal overlapped operations (manual reset)
    if (fOverlapped)
    {
        m_hevtOverlapped = ::CreateEvent(0,true,false,0);
        if (m_hevtOverlapped == 0)
        {
            // Obtain the error information
            m_lLastError = ::GetLastError();
            _RPTF0(_CRT_WARN,"CSerial::Open - Unable to create event\n");
 
            // Close the port
            ::CloseHandle(m_hFile);
            m_hFile = 0;
 
            // Return the error
            return m_lLastError;
        }
    }
#else
   
    // Overlapped flag shouldn't be specified
    _ASSERTE(!fOverlapped);
 
#endif
 
    // Setup the COM-port
    if (dwInQueue || dwOutQueue)
    {
        // Make sure the queue-sizes are reasonable sized. Win9X systems crash
        // if the input queue-size is zero. Both queues need to be at least
        // 16 bytes large.
        _ASSERTE(dwInQueue >= 16);
        _ASSERTE(dwOutQueue >= 16);
 
        if (!::SetupComm(m_hFile,dwInQueue,dwOutQueue))
        {
            // Display a warning
            long lLastError = ::GetLastError();
            _RPTF0(_CRT_WARN,"CSerial::Open - Unable to setup the COM-port\n");
 
            // Close the port
            Close();
 
            // Save last error from SetupComm
            m_lLastError = lLastError;
            return m_lLastError;   
        }
    }
 
    // Setup the default communication mask
    SetMask();
 
    // Non-blocking reads is default
    SetupReadTimeouts(EReadTimeoutNonblocking);
 
    // Setup the device for default settings
    COMMCONFIG commConfig = {0};
    DWORD dwSize = sizeof(commConfig);
    commConfig.dwSize = dwSize;
    if (::GetDefaultCommConfig(lpszDevice,&commConfig,&dwSize))
    {
        // Set the default communication configuration
        if (!::SetCommConfig(m_hFile,&commConfig,dwSize))
        {
            // Display a warning
            _RPTF0(_CRT_WARN,"CSerial::Open - Unable to set default communication configuration.\n");
        }
    }
    else
    {
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::Open - Unable to obtain default communication configuration.\n");
    }
 
    // Return successful
    return m_lLastError;
}
 
LONG CSerial::Close (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // If the device is already closed,
    // then we don't need to do anything.
    if (m_hFile == 0)
    {
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::Close - Method called when device is not open\n");
        return m_lLastError;
    }
 
#ifndef SERIAL_NO_OVERLAPPED
    // Free event handle
    if (m_hevtOverlapped)
    {
        ::CloseHandle(m_hevtOverlapped);
        m_hevtOverlapped = 0;
    }
#endif
 
    // Close COM port
    ::CloseHandle(m_hFile);
    m_hFile = 0;
 
    // Return successful
    return m_lLastError;
}
 
LONG CSerial::Setup (EBaudrate eBaudrate, EDataBits eDataBits, EParity eParity, EStopBits eStopBits)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::Setup - Device is not opened\n");
        return m_lLastError;
    }
 
    // Obtain the DCB structure for the device
    CDCB dcb;
    if (!::GetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::   GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::Setup - Unable to obtain DCB information\n");
        return m_lLastError;
    }
 
    // Set the new data
    dcb.BaudRate = DWORD(eBaudrate);
    dcb.ByteSize = BYTE(eDataBits);
    dcb.Parity   = BYTE(eParity);
    dcb.StopBits = BYTE(eStopBits);
 
    // Determine if parity is used
    dcb.fParity  = (eParity != EParNone);
 
    // Set the new DCB structure
    if (!::SetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::Setup - Unable to set DCB information\n");
        return m_lLastError;
    }
 
    // Return successful
    return m_lLastError;
}
 
LONG CSerial::SetEventChar (BYTE bEventChar, bool fAdjustMask)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::SetEventChar - Device is not opened\n");
        return m_lLastError;
    }
 
    // Obtain the DCB structure for the device
    CDCB dcb;
    if (!::GetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::SetEventChar - Unable to obtain DCB information\n");
        return m_lLastError;
    }
 
    // Set the new event character
    dcb.EvtChar = char(bEventChar);
 
    // Adjust the event mask, to make sure the event will be received
    if (fAdjustMask)
    {
        // Enable 'receive event character' event.  Note that this
        // will generate an EEventNone if there is an asynchronous
        // WaitCommEvent pending.
        SetMask(GetEventMask() | EEventRcvEv);
    }
 
    // Set the new DCB structure
    if (!::SetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::SetEventChar - Unable to set DCB information\n");
        return m_lLastError;
    }
 
    // Return successful
    return m_lLastError;
}
 
LONG CSerial::SetMask (DWORD dwEventMask)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::SetMask - Device is not opened\n");
        return m_lLastError;
    }
 
    // Set the new mask. Note that this will generate an EEventNone
    // if there is an asynchronous WaitCommEvent pending.
    if (!::SetCommMask(m_hFile,dwEventMask))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::SetMask - Unable to set event mask\n");
        return m_lLastError;
    }
 
    // Save event mask and return successful
    m_dwEventMask = dwEventMask;
    return m_lLastError;
}
 
LONG CSerial::WaitEvent (LPOVERLAPPED lpOverlapped, DWORD dwTimeout)
{
    // Check if time-outs are supported
    CheckRequirements(lpOverlapped,dwTimeout);
 
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::WaitEvent - Device is not opened\n");
        return m_lLastError;
    }
 
#ifndef SERIAL_NO_OVERLAPPED
 
    // Check if an overlapped structure has been specified
    if (!m_hevtOverlapped && (lpOverlapped || (dwTimeout != INFINITE)))
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_FUNCTION;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::WaitEvent - Overlapped I/O is disabled, specified parameters are illegal.\n");
        return m_lLastError;
    }
 
    // Wait for the event to happen
    OVERLAPPED ovInternal;
    if (!lpOverlapped && m_hevtOverlapped)
    {
        // Setup our own overlapped structure
        memset(&ovInternal,0,sizeof(ovInternal));
        ovInternal.hEvent = m_hevtOverlapped;
 
        // Use our internal overlapped structure
        lpOverlapped = &ovInternal;
    }
 
    // Make sure the overlapped structure isn't busy
    _ASSERTE(!m_hevtOverlapped || HasOverlappedIoCompleted(lpOverlapped));
 
    // Wait for the COM event
    if (!::WaitCommEvent(m_hFile,LPDWORD(&m_eEvent),lpOverlapped))
    {
        // Set the internal error code
        long lLastError = ::GetLastError();
 
        // Overlapped operation in progress is not an actual error
        if (lLastError != ERROR_IO_PENDING)
        {
            // Save the error
            m_lLastError = lLastError;
 
            // Issue an error and quit
            _RPTF0(_CRT_WARN,"CSerial::WaitEvent - Unable to wait for COM event\n");
            return m_lLastError;
        }
 
        // We need to block if the client didn't specify an overlapped structure
        if (lpOverlapped == &ovInternal)
        {
            // Wait for the overlapped operation to complete
            switch (::WaitForSingleObject(lpOverlapped->hEvent,dwTimeout))
            {
            case WAIT_OBJECT_0:
                // The overlapped operation has completed
                break;
 
            case WAIT_TIMEOUT:
                // Cancel the I/O operation
                CancelCommIo();
 
                // The operation timed out. Set the internal error code and quit
                m_lLastError = ERROR_TIMEOUT;
                return m_lLastError;
 
            default:
                // Set the internal error code
                m_lLastError = ::GetLastError();
 
                // Issue an error and quit
                _RPTF0(_CRT_WARN,"CSerial::WaitEvent - Unable to wait until COM event has arrived\n");
                return m_lLastError;
            }
        }
    }
    else
    {
        // The operation completed immediatly. Just to be sure
        // we'll set the overlapped structure's event handle.
        if (lpOverlapped)
            ::SetEvent(lpOverlapped->hEvent);
    }
#else
 
    // Wait for the COM event
    if (!::WaitCommEvent(m_hFile,LPDWORD(&m_eEvent),0))
    {
        // Set the internal error code
        m_lLastError = ::GetLastError();
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::WaitEvent - Unable to wait for COM event\n");
        return m_lLastError;
    }
 
#endif
 
    // Return successfully
    return m_lLastError;
}
 
 
LONG CSerial::SetupHandshaking (EHandshake eHandshake)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::SetupHandshaking - Device is not opened\n");
        return m_lLastError;
    }
 
    // Obtain the DCB structure for the device
    CDCB dcb;
    if (!::GetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::SetupHandshaking - Unable to obtain DCB information\n");
        return m_lLastError;
    }
 
    // Set the handshaking flags
    switch (eHandshake)
    {
    case EHandshakeOff:
        dcb.fOutxCtsFlow = false;                   // Disable CTS monitoring
        dcb.fOutxDsrFlow = false;                   // Disable DSR monitoring
        dcb.fDtrControl = DTR_CONTROL_DISABLE;      // Disable DTR monitoring
        dcb.fOutX = false;                          // Disable XON/XOFF for transmission
        dcb.fInX = false;                           // Disable XON/XOFF for receiving
        dcb.fRtsControl = RTS_CONTROL_DISABLE;      // Disable RTS (Ready To Send)
        break;
 
    case EHandshakeHardware:
        dcb.fOutxCtsFlow = true;                    // Enable CTS monitoring
        dcb.fOutxDsrFlow = true;                    // Enable DSR monitoring
        dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;    // Enable DTR handshaking
        dcb.fOutX = false;                          // Disable XON/XOFF for transmission
        dcb.fInX = false;                           // Disable XON/XOFF for receiving
        dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;    // Enable RTS handshaking
        break;
 
    case EHandshakeSoftware:
        dcb.fOutxCtsFlow = false;                   // Disable CTS (Clear To Send)
        dcb.fOutxDsrFlow = false;                   // Disable DSR (Data Set Ready)
        dcb.fDtrControl = DTR_CONTROL_DISABLE;      // Disable DTR (Data Terminal Ready)
        dcb.fOutX = true;                           // Enable XON/XOFF for transmission
        dcb.fInX = true;                            // Enable XON/XOFF for receiving
        dcb.fRtsControl = RTS_CONTROL_DISABLE;      // Disable RTS (Ready To Send)
        break;
 
    default:
        // This shouldn't be possible
        _ASSERTE(false);
        m_lLastError = E_INVALIDARG;
        return m_lLastError;
    }
 
    // Set the new DCB structure
    if (!::SetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::SetupHandshaking - Unable to set DCB information\n");
        return m_lLastError;
    }
 
    // Return successful
    return m_lLastError;
}
 
LONG CSerial::SetupReadTimeouts (EReadTimeout eReadTimeout)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::SetupReadTimeouts - Device is not opened\n");
        return m_lLastError;
    }
 
    // Determine the time-outs
    COMMTIMEOUTS cto;
    if (!::GetCommTimeouts(m_hFile,&cto))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::SetupReadTimeouts - Unable to obtain timeout information\n");
        return m_lLastError;
    }
 
    // Set the new timeouts
    switch (eReadTimeout)
    {
    case EReadTimeoutBlocking:
        cto.ReadIntervalTimeout = 0;
        cto.ReadTotalTimeoutConstant = 0;
        cto.ReadTotalTimeoutMultiplier = 0;
        break;
    case EReadTimeoutNonblocking:
        cto.ReadIntervalTimeout = MAXDWORD;
        cto.ReadTotalTimeoutConstant = 0;
        cto.ReadTotalTimeoutMultiplier = 0;
        break;
    default:
        // This shouldn't be possible
        _ASSERTE(false);
        m_lLastError = E_INVALIDARG;
        return m_lLastError;
    }
 
    // Set the new DCB structure
    if (!::SetCommTimeouts(m_hFile,&cto))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::SetupReadTimeouts - Unable to set timeout information\n");
        return m_lLastError;
    }
 
    // Return successful
    return m_lLastError;
}
 
CSerial::EBaudrate CSerial::GetBaudrate (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::GetBaudrate - Device is not opened\n");
        return EBaudUnknown;
    }
 
    // Obtain the DCB structure for the device
    CDCB dcb;
    if (!::GetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetBaudrate - Unable to obtain DCB information\n");
        return EBaudUnknown;
    }
 
    // Return the appropriate baudrate
    return EBaudrate(dcb.BaudRate);
}
 
CSerial::EDataBits CSerial::GetDataBits (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::GetDataBits - Device is not opened\n");
        return EDataUnknown;
    }
 
    // Obtain the DCB structure for the device
    CDCB dcb;
    if (!::GetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetDataBits - Unable to obtain DCB information\n");
        return EDataUnknown;
    }
 
    // Return the appropriate bytesize
    return EDataBits(dcb.ByteSize);
}
 
CSerial::EParity CSerial::GetParity (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::GetParity - Device is not opened\n");
        return EParUnknown;
    }
 
    // Obtain the DCB structure for the device
    CDCB dcb;
    if (!::GetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetParity - Unable to obtain DCB information\n");
        return EParUnknown;
    }
 
    // Check if parity is used
    if (!dcb.fParity)
    {
        // No parity
        return EParNone;
    }
 
    // Return the appropriate parity setting
    return EParity(dcb.Parity);
}
 
CSerial::EStopBits CSerial::GetStopBits (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::GetStopBits - Device is not opened\n");
        return EStopUnknown;
    }
 
    // Obtain the DCB structure for the device
    CDCB dcb;
    if (!::GetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetStopBits - Unable to obtain DCB information\n");
        return EStopUnknown;
    }
 
    // Return the appropriate stopbits
    return EStopBits(dcb.StopBits);
}
 
DWORD CSerial::GetEventMask (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::GetEventMask - Device is not opened\n");
        return 0;
    }
 
    // Return the event mask
    return m_dwEventMask;
}
 
BYTE CSerial::GetEventChar (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::GetEventChar - Device is not opened\n");
        return 0;
    }
 
    // Obtain the DCB structure for the device
    CDCB dcb;
    if (!::GetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetEventChar - Unable to obtain DCB information\n");
        return 0;
    }
 
    // Set the new event character
    return BYTE(dcb.EvtChar);
}
 
CSerial::EHandshake CSerial::GetHandshaking (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::GetHandshaking - Device is not opened\n");
        return EHandshakeUnknown;
    }
 
    // Obtain the DCB structure for the device
    CDCB dcb;
    if (!::GetCommState(m_hFile,&dcb))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetHandshaking - Unable to obtain DCB information\n");
        return EHandshakeUnknown;
    }
 
    // Check if hardware handshaking is being used
    if ((dcb.fDtrControl == DTR_CONTROL_HANDSHAKE) && (dcb.fRtsControl == RTS_CONTROL_HANDSHAKE))
        return EHandshakeHardware;
 
    // Check if software handshaking is being used
    if (dcb.fOutX && dcb.fInX)
        return EHandshakeSoftware;
 
    // No handshaking is being used
    return EHandshakeOff;
}
 
LONG CSerial::Write (const void* pData, size_t iLen, DWORD* pdwWritten, LPOVERLAPPED lpOverlapped, DWORD dwTimeout)
{
    // Check if time-outs are supported
    CheckRequirements(lpOverlapped,dwTimeout);
 
    // Overlapped operation should specify the pdwWritten variable
    _ASSERTE(!lpOverlapped || pdwWritten);
 
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Use our own variable for read count
    DWORD dwWritten;
    if (pdwWritten == 0)
    {
        pdwWritten = &dwWritten;
    }
 
    // Reset the number of bytes written
    *pdwWritten = 0;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::Write - Device is not opened\n");
        return m_lLastError;
    }
 
#ifndef SERIAL_NO_OVERLAPPED
 
    // Check if an overlapped structure has been specified
    if (!m_hevtOverlapped && (lpOverlapped || (dwTimeout != INFINITE)))
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_FUNCTION;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::Write - Overlapped I/O is disabled, specified parameters are illegal.\n");
        return m_lLastError;
    }
 
    // Wait for the event to happen
    OVERLAPPED ovInternal;
    if (!lpOverlapped && m_hevtOverlapped)
    {
        // Setup our own overlapped structure
        memset(&ovInternal,0,sizeof(ovInternal));
        ovInternal.hEvent = m_hevtOverlapped;
 
        // Use our internal overlapped structure
        lpOverlapped = &ovInternal;
    }
 
    // Make sure the overlapped structure isn't busy
    _ASSERTE(!m_hevtOverlapped || HasOverlappedIoCompleted(lpOverlapped));
 
    // Write the data
    if (!::WriteFile(m_hFile,pData,iLen,pdwWritten,lpOverlapped))
    {
        // Set the internal error code
        long lLastError = ::GetLastError();
 
        // Overlapped operation in progress is not an actual error
        if (lLastError != ERROR_IO_PENDING)
        {
            // Save the error
            m_lLastError = lLastError;
 
            // Issue an error and quit
            _RPTF0(_CRT_WARN,"CSerial::Write - Unable to write the data\n");
            return m_lLastError;
        }
 
        // We need to block if the client didn't specify an overlapped structure
        if (lpOverlapped == &ovInternal)
        {
            // Wait for the overlapped operation to complete
            switch (::WaitForSingleObject(lpOverlapped->hEvent,dwTimeout))
            {
            case WAIT_OBJECT_0:
                // The overlapped operation has completed
                if (!::GetOverlappedResult(m_hFile,lpOverlapped,pdwWritten,FALSE))
                {
                    // Set the internal error code
                    m_lLastError = ::GetLastError();
 
                    _RPTF0(_CRT_WARN,"CSerial::Write - Overlapped completed without result\n");
                    return m_lLastError;
                }
                break;
 
            case WAIT_TIMEOUT:
                // Cancel the I/O operation
                CancelCommIo();
 
                // The operation timed out. Set the internal error code and quit
                m_lLastError = ERROR_TIMEOUT;
                return m_lLastError;
 
            default:
                // Set the internal error code
                m_lLastError = ::GetLastError();
 
                // Issue an error and quit
                _RPTF0(_CRT_WARN,"CSerial::Write - Unable to wait until data has been sent\n");
                return m_lLastError;
            }
        }
    }
    else
    {
        // The operation completed immediatly. Just to be sure
        // we'll set the overlapped structure's event handle.
        if (lpOverlapped)
            ::SetEvent(lpOverlapped->hEvent);
    }
 
#else
 
    // Write the data
    if (!::WriteFile(m_hFile,pData,iLen,pdwWritten,0))
    {
        // Set the internal error code
        m_lLastError = ::GetLastError();
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::Write - Unable to write the data\n");
        return m_lLastError;
    }
 
#endif
 
    // Return successfully
    return m_lLastError;
}
 
LONG CSerial::Write (LPCSTR pString, DWORD* pdwWritten, LPOVERLAPPED lpOverlapped, DWORD dwTimeout)
{
    // Check if time-outs are supported
    CheckRequirements(lpOverlapped,dwTimeout);
 
    // Determine the length of the string
    return Write(pString,strlen(pString),pdwWritten,lpOverlapped,dwTimeout);
}
 
LONG CSerial::Read (void* pData, size_t iLen, DWORD* pdwRead, LPOVERLAPPED lpOverlapped, DWORD dwTimeout)
{
    // Check if time-outs are supported
    CheckRequirements(lpOverlapped,dwTimeout);
 
    // Overlapped operation should specify the pdwRead variable
    _ASSERTE(!lpOverlapped || pdwRead);
 
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Use our own variable for read count
    DWORD dwRead;
    if (pdwRead == 0)
    {
        pdwRead = &dwRead;
    }
 
    // Reset the number of bytes read
    *pdwRead = 0;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::Read - Device is not opened\n");
        return m_lLastError;
    }
 
#ifdef _DEBUG
    // The debug version fills the entire data structure with
    // 0xDC bytes, to catch buffer errors as soon as possible.
    memset(pData,0xDC,iLen);
#endif
 
#ifndef SERIAL_NO_OVERLAPPED
 
    // Check if an overlapped structure has been specified
    if (!m_hevtOverlapped && (lpOverlapped || (dwTimeout != INFINITE)))
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_FUNCTION;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::Read - Overlapped I/O is disabled, specified parameters are illegal.\n");
        return m_lLastError;
    }
 
    // Wait for the event to happen
    OVERLAPPED ovInternal;
    if (lpOverlapped == 0)
    {
        // Setup our own overlapped structure
        memset(&ovInternal,0,sizeof(ovInternal));
        ovInternal.hEvent = m_hevtOverlapped;
 
        // Use our internal overlapped structure
        lpOverlapped = &ovInternal;
    }
 
    // Make sure the overlapped structure isn't busy
    _ASSERTE(!m_hevtOverlapped || HasOverlappedIoCompleted(lpOverlapped));
   
    // Read the data
    if (!::ReadFile(m_hFile,pData,iLen,pdwRead,lpOverlapped))
    {
        // Set the internal error code
        long lLastError = ::GetLastError();
 
        // Overlapped operation in progress is not an actual error
        if (lLastError != ERROR_IO_PENDING)
        {
            // Save the error
            m_lLastError = lLastError;
 
            // Issue an error and quit
            _RPTF0(_CRT_WARN,"CSerial::Read - Unable to read the data\n");
            return m_lLastError;
        }
 
        // We need to block if the client didn't specify an overlapped structure
        if (lpOverlapped == &ovInternal)
        {
            // Wait for the overlapped operation to complete
            switch (::WaitForSingleObject(lpOverlapped->hEvent,dwTimeout))
            {
            case WAIT_OBJECT_0:
                // The overlapped operation has completed
                if (!::GetOverlappedResult(m_hFile,lpOverlapped,pdwRead,FALSE))
                {
                    // Set the internal error code
                    m_lLastError = ::GetLastError();
 
                    _RPTF0(_CRT_WARN,"CSerial::Read - Overlapped completed without result\n");
                    return m_lLastError;
                }
                break;
 
            case WAIT_TIMEOUT:
                // Cancel the I/O operation
                CancelCommIo();
 
                // The operation timed out. Set the internal error code and quit
                m_lLastError = ERROR_TIMEOUT;
                return m_lLastError;
 
            default:
                // Set the internal error code
                m_lLastError = ::GetLastError();
 
                // Issue an error and quit
                _RPTF0(_CRT_WARN,"CSerial::Read - Unable to wait until data has been read\n");
                return m_lLastError;
            }
        }
    }
    else
    {
        // The operation completed immediatly. Just to be sure
        // we'll set the overlapped structure's event handle.
        if (lpOverlapped)
            ::SetEvent(lpOverlapped->hEvent);
    }
 
#else
   
    // Read the data
    if (!::ReadFile(m_hFile,pData,iLen,pdwRead,0))
    {
        // Set the internal error code
        m_lLastError = ::GetLastError();
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::Read - Unable to read the data\n");
        return m_lLastError;
    }
 
#endif
 
    // Return successfully
    return m_lLastError;
}
 
LONG CSerial::Purge()
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::Purge - Device is not opened\n");
        return m_lLastError;
    }
 
    if (!::PurgeComm(m_hFile, PURGE_TXCLEAR | PURGE_RXCLEAR))
    {
        // Set the internal error code
        m_lLastError = ::GetLastError();
        _RPTF0(_CRT_WARN,"CSerial::Purge - Overlapped completed without result\n");
    }
   
    // Return successfully
    return m_lLastError;
}
 
LONG CSerial::Break (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::Break - Device is not opened\n");
        return m_lLastError;
    }
 
    // Set the RS-232 port in break mode for a little while
    ::SetCommBreak(m_hFile);
    ::Sleep(100);
    ::ClearCommBreak(m_hFile);
 
    // Return successfully
    return m_lLastError;
}
 
CSerial::EEvent CSerial::GetEventType (void)
{
#ifdef _DEBUG
    // Check if the event is within the mask
    if ((m_eEvent & m_dwEventMask) == 0)
        _RPTF2(_CRT_WARN,"CSerial::GetEventType - Event %08Xh not within mask %08Xh.\n", m_eEvent, m_dwEventMask);
#endif
 
    // Obtain the event (mask unwanted events out)
    EEvent eEvent = EEvent(m_eEvent & m_dwEventMask);
 
    // Reset internal event type
    m_eEvent = EEventNone;
 
    // Return the current cause
    return eEvent;
}
 
CSerial::EError CSerial::GetError (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Check if the device is open
    if (m_hFile == 0)
    {
        // Set the internal error code
        m_lLastError = ERROR_INVALID_HANDLE;
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::GetError - Device is not opened\n");
        return EErrorUnknown;
    }
 
    // Obtain COM status
    DWORD dwErrors = 0;
    if (!::ClearCommError(m_hFile,&dwErrors,0))
    {
        // Set the internal error code
        m_lLastError = ::GetLastError();
 
        // Issue an error and quit
        _RPTF0(_CRT_WARN,"CSerial::GetError - Unable to obtain COM status\n");
        return EErrorUnknown;
    }
 
    // Return the error
    return EError(dwErrors);
}
 
bool CSerial::GetCTS (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Obtain the modem status
    DWORD dwModemStat = 0;
    if (!::GetCommModemStatus(m_hFile,&dwModemStat))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetCTS - Unable to obtain the modem status\n");
        return false;
    }
 
    // Determine if CTS is on
    return (dwModemStat & MS_CTS_ON) != 0;
}
 
bool CSerial::GetDSR (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Obtain the modem status
    DWORD dwModemStat = 0;
    if (!::GetCommModemStatus(m_hFile,&dwModemStat))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetDSR - Unable to obtain the modem status\n");
        return false;
    }
 
    // Determine if DSR is on
    return (dwModemStat & MS_DSR_ON) != 0;
}
 
bool CSerial::GetRing (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Obtain the modem status
    DWORD dwModemStat = 0;
    if (!::GetCommModemStatus(m_hFile,&dwModemStat))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetRing - Unable to obtain the modem status");
        return false;
    }
 
    // Determine if Ring is on
    return (dwModemStat & MS_RING_ON) != 0;
}
 
bool CSerial::GetRLSD (void)
{
    // Reset error state
    m_lLastError = ERROR_SUCCESS;
 
    // Obtain the modem status
    DWORD dwModemStat = 0;
    if (!::GetCommModemStatus(m_hFile,&dwModemStat))
    {
        // Obtain the error code
        m_lLastError = ::GetLastError();
 
        // Display a warning
        _RPTF0(_CRT_WARN,"CSerial::GetRLSD - Unable to obtain the modem status");
        return false;
    }
 
    // Determine if RLSD is on
    return (dwModemStat & MS_RLSD_ON) != 0;
}
 

Rev 270	Rev 1308
1	// Serial.cpp - Implementation of the CSerial class	1	// Serial.cpp - Implementation of the CSerial class
2	//	2	//
3	// Copyright (C) 1999-2003 Ramon de Klein (Ramon.de.Klein@ict.nl)	3	// Copyright (C) 1999-2003 Ramon de Klein (Ramon.de.Klein@ict.nl)
4	//	4	//
5	// This library is free software; you can redistribute it and/or	5	// This library is free software; you can redistribute it and/or
6	// modify it under the terms of the GNU Lesser General Public	6	// modify it under the terms of the GNU Lesser General Public
7	// License as published by the Free Software Foundation; either	7	// License as published by the Free Software Foundation; either
8	// version 2.1 of the License, or (at your option) any later version.	8	// version 2.1 of the License, or (at your option) any later version.
9	//	9	//
10	// This library is distributed in the hope that it will be useful,	10	// This library is distributed in the hope that it will be useful,
11	// but WITHOUT ANY WARRANTY; without even the implied warranty of	11	// but WITHOUT ANY WARRANTY; without even the implied warranty of
12	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	12	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13	// Lesser General Public License for more details.	13	// Lesser General Public License for more details.
14	//	14	//
15	// You should have received a copy of the GNU Lesser General Public	15	// You should have received a copy of the GNU Lesser General Public
16	// License along with this library; if not, write to the Free Software	16	// License along with this library; if not, write to the Free Software
17	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	17	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18		18
19		19
20	//////////////////////////////////////////////////////////////////////	20	//////////////////////////////////////////////////////////////////////
21	// Include the standard header files	21	// Include the standard header files
22		22
23	#define STRICT	23	#define STRICT
24	#include <crtdbg.h>	24	#include <crtdbg.h>
25	#include <tchar.h>	25	#include <tchar.h>
26	#include <windows.h>	26	#include <windows.h>
27	#include "stdafx.h"	27	#include "stdafx.h"
28		28
29		29
30	//////////////////////////////////////////////////////////////////////	30	//////////////////////////////////////////////////////////////////////
31	// Include module headerfile	31	// Include module headerfile
32		32
33	#include "Serial.h"	33	#include "Serial.h"
34		34
35		35
36	//////////////////////////////////////////////////////////////////////	36	//////////////////////////////////////////////////////////////////////
37	// Disable warning C4127: conditional expression is constant, which	37	// Disable warning C4127: conditional expression is constant, which
38	// is generated when using the _RPTF and _ASSERTE macros.	38	// is generated when using the _RPTF and _ASSERTE macros.
39		39
40	#pragma warning(disable: 4127)	40	#pragma warning(disable: 4127)
41		41
42		42
43	//////////////////////////////////////////////////////////////////////	43	//////////////////////////////////////////////////////////////////////
44	// Enable debug memory manager	44	// Enable debug memory manager
45		45
46	#ifdef _DEBUG	46	#ifdef _DEBUG
47		47
48	#ifdef THIS_FILE	48	#ifdef THIS_FILE
49	#undef THIS_FILE	49	#undef THIS_FILE
50	#endif	50	#endif
51		51
52	static const char THIS_FILE[] = __FILE__;	52	static const char THIS_FILE[] = __FILE__;
53	#define new DEBUG_NEW	53	#define new DEBUG_NEW
54		54
55	#endif	55	#endif
56		56
57		57
58	//////////////////////////////////////////////////////////////////////	58	//////////////////////////////////////////////////////////////////////
59	// Helper methods	59	// Helper methods
60		60
61	inline void CSerial::CheckRequirements (LPOVERLAPPED lpOverlapped, DWORD dwTimeout) const	61	inline void CSerial::CheckRequirements (LPOVERLAPPED lpOverlapped, DWORD dwTimeout) const
62	{	62	{
63	#ifdef SERIAL_NO_OVERLAPPED	63	#ifdef SERIAL_NO_OVERLAPPED
64		64
65	// Check if an overlapped structure has been specified	65	// Check if an overlapped structure has been specified
66	if (lpOverlapped \|\| (dwTimeout != INFINITE))	66	if (lpOverlapped \|\| (dwTimeout != INFINITE))
67	{	67	{
68	// Quit application	68	// Quit application
69	::MessageBox(0,_T("Overlapped I/O and time-outs are not supported, when overlapped I/O is disabled."),_T("Serial library"), MB_ICONERROR \| MB_TASKMODAL);	69	::MessageBox(0,_T("Overlapped I/O and time-outs are not supported, when overlapped I/O is disabled."),_T("Serial library"), MB_ICONERROR \| MB_TASKMODAL);
70	::DebugBreak();	70	::DebugBreak();
71	::ExitProcess(0xFFFFFFF);	71	::ExitProcess(0xFFFFFFF);
72	}	72	}
73		73
74	#endif	74	#endif
75		75
76	#ifdef SERIAL_NO_CANCELIO	76	#ifdef SERIAL_NO_CANCELIO
77		77
78	// Check if 0 or INFINITE time-out has been specified, because	78	// Check if 0 or INFINITE time-out has been specified, because
79	// the communication I/O cannot be cancelled.	79	// the communication I/O cannot be cancelled.
80	if ((dwTimeout != 0) && (dwTimeout != INFINITE))	80	if ((dwTimeout != 0) && (dwTimeout != INFINITE))
81	{	81	{
82	// Quit application	82	// Quit application
83	::MessageBox(0,_T("Timeouts are not supported, when SERIAL_NO_CANCELIO is defined"),_T("Serial library"), MB_ICONERROR \| MB_TASKMODAL);	83	::MessageBox(0,_T("Timeouts are not supported, when SERIAL_NO_CANCELIO is defined"),_T("Serial library"), MB_ICONERROR \| MB_TASKMODAL);
84	::DebugBreak();	84	::DebugBreak();
85	::ExitProcess(0xFFFFFFF);	85	::ExitProcess(0xFFFFFFF);
86	}	86	}
87		87
88	#endif // SERIAL_NO_CANCELIO	88	#endif // SERIAL_NO_CANCELIO
89		89
90	// Avoid warnings	90	// Avoid warnings
91	(void) dwTimeout;	91	(void) dwTimeout;
92	(void) lpOverlapped;	92	(void) lpOverlapped;
93	}	93	}
94		94
95	inline BOOL CSerial::CancelCommIo (void)	95	inline BOOL CSerial::CancelCommIo (void)
96	{	96	{
97	#ifdef SERIAL_NO_CANCELIO	97	#ifdef SERIAL_NO_CANCELIO
98	// CancelIo shouldn't have been called at this point	98	// CancelIo shouldn't have been called at this point
99	::DebugBreak();	99	::DebugBreak();
100	return FALSE;	100	return FALSE;
101	#else	101	#else
102		102
103	// Cancel the I/O request	103	// Cancel the I/O request
104	return ::CancelIo(m_hFile);	104	return ::CancelIo(m_hFile);
105		105
106	#endif // SERIAL_NO_CANCELIO	106	#endif // SERIAL_NO_CANCELIO
107	}	107	}
108		108
109		109
110	//////////////////////////////////////////////////////////////////////	110	//////////////////////////////////////////////////////////////////////
111	// Code	111	// Code
112		112
113	CSerial::CSerial ()	113	CSerial::CSerial ()
114	: m_lLastError(ERROR_SUCCESS)	114	: m_lLastError(ERROR_SUCCESS)
115	, m_hFile(0)	115	, m_hFile(0)
116	, m_eEvent(EEventNone)	116	, m_eEvent(EEventNone)
117	, m_dwEventMask(0)	117	, m_dwEventMask(0)
118	#ifndef SERIAL_NO_OVERLAPPED	118	#ifndef SERIAL_NO_OVERLAPPED
119	, m_hevtOverlapped(0)	119	, m_hevtOverlapped(0)
120	#endif	120	#endif
121	{	121	{
122	}	122	}
123		123
124	CSerial::~CSerial ()	124	CSerial::~CSerial ()
125	{	125	{
126	// If the device is already closed,	126	// If the device is already closed,
127	// then we don't need to do anything.	127	// then we don't need to do anything.
128	if (m_hFile)	128	if (m_hFile)
129	{	129	{
130	// Display a warning	130	// Display a warning
131	_RPTF0(_CRT_WARN,"CSerial::~CSerial - Serial port not closed\n");	131	_RPTF0(_CRT_WARN,"CSerial::~CSerial - Serial port not closed\n");
132		132
133	// Close implicitly	133	// Close implicitly
134	Close();	134	Close();
135	}	135	}
136	}	136	}
137		137
138	CSerial::EPort CSerial::CheckPort (LPCTSTR lpszDevice)	138	CSerial::EPort CSerial::CheckPort (LPCTSTR lpszDevice)
139	{	139	{
140	// Try to open the device	140	// Try to open the device
141	HANDLE hFile = ::CreateFile(lpszDevice,	141	HANDLE hFile = ::CreateFile(lpszDevice,
142	GENERIC_READ\|GENERIC_WRITE,	142	GENERIC_READ\|GENERIC_WRITE,
143	0,	143	0,
144	0,	144	0,
145	OPEN_EXISTING,	145	OPEN_EXISTING,
146	0,	146	0,
147	0);	147	0);
148		148
149	// Check if we could open the device	149	// Check if we could open the device
150	if (hFile == INVALID_HANDLE_VALUE)	150	if (hFile == INVALID_HANDLE_VALUE)
151	{	151	{
152	// Display error	152	// Display error
153	switch (::GetLastError())	153	switch (::GetLastError())
154	{	154	{
155	case ERROR_FILE_NOT_FOUND:	155	case ERROR_FILE_NOT_FOUND:
156	// The specified COM-port does not exist	156	// The specified COM-port does not exist
157	return EPortNotAvailable;	157	return EPortNotAvailable;
158		158
159	case ERROR_ACCESS_DENIED:	159	case ERROR_ACCESS_DENIED:
160	// The specified COM-port is in use	160	// The specified COM-port is in use
161	return EPortInUse;	161	return EPortInUse;
162		162
163	default:	163	default:
164	// Something else is wrong	164	// Something else is wrong
165	return EPortUnknownError;	165	return EPortUnknownError;
166	}	166	}
167	}	167	}
168		168
169	// Close handle	169	// Close handle
170	::CloseHandle(hFile);	170	::CloseHandle(hFile);
171		171
172	// Port is available	172	// Port is available
173	return EPortAvailable;	173	return EPortAvailable;
174	}	174	}
175		175
176	LONG CSerial::Open (LPCTSTR lpszDevice, DWORD dwInQueue, DWORD dwOutQueue, bool fOverlapped)	176	LONG CSerial::Open (LPCTSTR lpszDevice, DWORD dwInQueue, DWORD dwOutQueue, bool fOverlapped)
177	{	177	{
178	// Reset error state	178	// Reset error state
179	m_lLastError = ERROR_SUCCESS;	179	m_lLastError = ERROR_SUCCESS;
180		180
181	// Check if the port isn't already opened	181	// Check if the port isn't already opened
182	if (m_hFile)	182	if (m_hFile)
183	{	183	{
184	m_lLastError = ERROR_ALREADY_INITIALIZED;	184	m_lLastError = ERROR_ALREADY_INITIALIZED;
185	_RPTF0(_CRT_WARN,"CSerial::Open - Port already opened\n");	185	_RPTF0(_CRT_WARN,"CSerial::Open - Port already opened\n");
186	return m_lLastError;	186	return m_lLastError;
187	}	187	}
188		188
189	// Open the device	189	// Open the device
190	m_hFile = ::CreateFile(lpszDevice,	190	m_hFile = ::CreateFile(lpszDevice,
191	GENERIC_READ\|GENERIC_WRITE,	191	GENERIC_READ\|GENERIC_WRITE,
192	0,	192	0,
193	0,	193	0,
194	OPEN_EXISTING,	194	OPEN_EXISTING,
195	fOverlapped?FILE_FLAG_OVERLAPPED:0,	195	fOverlapped?FILE_FLAG_OVERLAPPED:0,
196	0);	196	0);
197	if (m_hFile == INVALID_HANDLE_VALUE)	197	if (m_hFile == INVALID_HANDLE_VALUE)
198	{	198	{
199	// Reset file handle	199	// Reset file handle
200	m_hFile = 0;	200	m_hFile = 0;
201		201
202	// Display error	202	// Display error
203	m_lLastError = ::GetLastError();	203	m_lLastError = ::GetLastError();
204	_RPTF0(_CRT_WARN, "CSerial::Open - Unable to open port\n");	204	_RPTF0(_CRT_WARN, "CSerial::Open - Unable to open port\n");
205	return m_lLastError;	205	return m_lLastError;
206	}	206	}
207		207
208	#ifndef SERIAL_NO_OVERLAPPED	208	#ifndef SERIAL_NO_OVERLAPPED
209	// We cannot have an event handle yet	209	// We cannot have an event handle yet
210	_ASSERTE(m_hevtOverlapped == 0);	210	_ASSERTE(m_hevtOverlapped == 0);
211		211
212	// Create the event handle for internal overlapped operations (manual reset)	212	// Create the event handle for internal overlapped operations (manual reset)
213	if (fOverlapped)	213	if (fOverlapped)
214	{	214	{
215	m_hevtOverlapped = ::CreateEvent(0,true,false,0);	215	m_hevtOverlapped = ::CreateEvent(0,true,false,0);
216	if (m_hevtOverlapped == 0)	216	if (m_hevtOverlapped == 0)
217	{	217	{
218	// Obtain the error information	218	// Obtain the error information
219	m_lLastError = ::GetLastError();	219	m_lLastError = ::GetLastError();
220	_RPTF0(_CRT_WARN,"CSerial::Open - Unable to create event\n");	220	_RPTF0(_CRT_WARN,"CSerial::Open - Unable to create event\n");
221		221
222	// Close the port	222	// Close the port
223	::CloseHandle(m_hFile);	223	::CloseHandle(m_hFile);
224	m_hFile = 0;	224	m_hFile = 0;
225		225
226	// Return the error	226	// Return the error
227	return m_lLastError;	227	return m_lLastError;
228	}	228	}
229	}	229	}
230	#else	230	#else
231		231
232	// Overlapped flag shouldn't be specified	232	// Overlapped flag shouldn't be specified
233	_ASSERTE(!fOverlapped);	233	_ASSERTE(!fOverlapped);
234		234
235	#endif	235	#endif
236		236
237	// Setup the COM-port	237	// Setup the COM-port
238	if (dwInQueue \|\| dwOutQueue)	238	if (dwInQueue \|\| dwOutQueue)
239	{	239	{
240	// Make sure the queue-sizes are reasonable sized. Win9X systems crash	240	// Make sure the queue-sizes are reasonable sized. Win9X systems crash
241	// if the input queue-size is zero. Both queues need to be at least	241	// if the input queue-size is zero. Both queues need to be at least
242	// 16 bytes large.	242	// 16 bytes large.
243	_ASSERTE(dwInQueue >= 16);	243	_ASSERTE(dwInQueue >= 16);
244	_ASSERTE(dwOutQueue >= 16);	244	_ASSERTE(dwOutQueue >= 16);
245		245
246	if (!::SetupComm(m_hFile,dwInQueue,dwOutQueue))	246	if (!::SetupComm(m_hFile,dwInQueue,dwOutQueue))
247	{	247	{
248	// Display a warning	248	// Display a warning
249	long lLastError = ::GetLastError();	249	long lLastError = ::GetLastError();
250	_RPTF0(_CRT_WARN,"CSerial::Open - Unable to setup the COM-port\n");	250	_RPTF0(_CRT_WARN,"CSerial::Open - Unable to setup the COM-port\n");
251		251
252	// Close the port	252	// Close the port
253	Close();	253	Close();
254		254
255	// Save last error from SetupComm	255	// Save last error from SetupComm
256	m_lLastError = lLastError;	256	m_lLastError = lLastError;
257	return m_lLastError;	257	return m_lLastError;
258	}	258	}
259	}	259	}
260		260
261	// Setup the default communication mask	261	// Setup the default communication mask
262	SetMask();	262	SetMask();
263		263
264	// Non-blocking reads is default	264	// Non-blocking reads is default
265	SetupReadTimeouts(EReadTimeoutNonblocking);	265	SetupReadTimeouts(EReadTimeoutNonblocking);
266		266
267	// Setup the device for default settings	267	// Setup the device for default settings
268	COMMCONFIG commConfig = {0};	268	COMMCONFIG commConfig = {0};
269	DWORD dwSize = sizeof(commConfig);	269	DWORD dwSize = sizeof(commConfig);
270	commConfig.dwSize = dwSize;	270	commConfig.dwSize = dwSize;
271	if (::GetDefaultCommConfig(lpszDevice,&commConfig,&dwSize))	271	if (::GetDefaultCommConfig(lpszDevice,&commConfig,&dwSize))
272	{	272	{
273	// Set the default communication configuration	273	// Set the default communication configuration
274	if (!::SetCommConfig(m_hFile,&commConfig,dwSize))	274	if (!::SetCommConfig(m_hFile,&commConfig,dwSize))
275	{	275	{
276	// Display a warning	276	// Display a warning
277	_RPTF0(_CRT_WARN,"CSerial::Open - Unable to set default communication configuration.\n");	277	_RPTF0(_CRT_WARN,"CSerial::Open - Unable to set default communication configuration.\n");
278	}	278	}
279	}	279	}
280	else	280	else
281	{	281	{
282	// Display a warning	282	// Display a warning
283	_RPTF0(_CRT_WARN,"CSerial::Open - Unable to obtain default communication configuration.\n");	283	_RPTF0(_CRT_WARN,"CSerial::Open - Unable to obtain default communication configuration.\n");
284	}	284	}
285		285
286	// Return successful	286	// Return successful
287	return m_lLastError;	287	return m_lLastError;
288	}	288	}
289		289
290	LONG CSerial::Close (void)	290	LONG CSerial::Close (void)
291	{	291	{
292	// Reset error state	292	// Reset error state
293	m_lLastError = ERROR_SUCCESS;	293	m_lLastError = ERROR_SUCCESS;
294		294
295	// If the device is already closed,	295	// If the device is already closed,
296	// then we don't need to do anything.	296	// then we don't need to do anything.
297	if (m_hFile == 0)	297	if (m_hFile == 0)
298	{	298	{
299	// Display a warning	299	// Display a warning
300	_RPTF0(_CRT_WARN,"CSerial::Close - Method called when device is not open\n");	300	_RPTF0(_CRT_WARN,"CSerial::Close - Method called when device is not open\n");
301	return m_lLastError;	301	return m_lLastError;
302	}	302	}
303		303
304	#ifndef SERIAL_NO_OVERLAPPED	304	#ifndef SERIAL_NO_OVERLAPPED
305	// Free event handle	305	// Free event handle
306	if (m_hevtOverlapped)	306	if (m_hevtOverlapped)
307	{	307	{
308	::CloseHandle(m_hevtOverlapped);	308	::CloseHandle(m_hevtOverlapped);
309	m_hevtOverlapped = 0;	309	m_hevtOverlapped = 0;
310	}	310	}
311	#endif	311	#endif
312		312
313	// Close COM port	313	// Close COM port
314	::CloseHandle(m_hFile);	314	::CloseHandle(m_hFile);
315	m_hFile = 0;	315	m_hFile = 0;
316		316
317	// Return successful	317	// Return successful
318	return m_lLastError;	318	return m_lLastError;
319	}	319	}
320		320
321	LONG CSerial::Setup (EBaudrate eBaudrate, EDataBits eDataBits, EParity eParity, EStopBits eStopBits)	321	LONG CSerial::Setup (EBaudrate eBaudrate, EDataBits eDataBits, EParity eParity, EStopBits eStopBits)
322	{	322	{
323	// Reset error state	323	// Reset error state
324	m_lLastError = ERROR_SUCCESS;	324	m_lLastError = ERROR_SUCCESS;
325		325
326	// Check if the device is open	326	// Check if the device is open
327	if (m_hFile == 0)	327	if (m_hFile == 0)
328	{	328	{
329	// Set the internal error code	329	// Set the internal error code
330	m_lLastError = ERROR_INVALID_HANDLE;	330	m_lLastError = ERROR_INVALID_HANDLE;
331		331
332	// Issue an error and quit	332	// Issue an error and quit
333	_RPTF0(_CRT_WARN,"CSerial::Setup - Device is not opened\n");	333	_RPTF0(_CRT_WARN,"CSerial::Setup - Device is not opened\n");
334	return m_lLastError;	334	return m_lLastError;
335	}	335	}
336		336
337	// Obtain the DCB structure for the device	337	// Obtain the DCB structure for the device
338	CDCB dcb;	338	CDCB dcb;
339	if (!::GetCommState(m_hFile,&dcb))	339	if (!::GetCommState(m_hFile,&dcb))
340	{	340	{
341	// Obtain the error code	341	// Obtain the error code
342	m_lLastError = :: GetLastError();	342	m_lLastError = :: GetLastError();
343		343
344	// Display a warning	344	// Display a warning
345	_RPTF0(_CRT_WARN,"CSerial::Setup - Unable to obtain DCB information\n");	345	_RPTF0(_CRT_WARN,"CSerial::Setup - Unable to obtain DCB information\n");
346	return m_lLastError;	346	return m_lLastError;
347	}	347	}
348		348
349	// Set the new data	349	// Set the new data
350	dcb.BaudRate = DWORD(eBaudrate);	350	dcb.BaudRate = DWORD(eBaudrate);
351	dcb.ByteSize = BYTE(eDataBits);	351	dcb.ByteSize = BYTE(eDataBits);
352	dcb.Parity = BYTE(eParity);	352	dcb.Parity = BYTE(eParity);
353	dcb.StopBits = BYTE(eStopBits);	353	dcb.StopBits = BYTE(eStopBits);
354		354
355	// Determine if parity is used	355	// Determine if parity is used
356	dcb.fParity = (eParity != EParNone);	356	dcb.fParity = (eParity != EParNone);
357		357
358	// Set the new DCB structure	358	// Set the new DCB structure
359	if (!::SetCommState(m_hFile,&dcb))	359	if (!::SetCommState(m_hFile,&dcb))
360	{	360	{
361	// Obtain the error code	361	// Obtain the error code
362	m_lLastError = ::GetLastError();	362	m_lLastError = ::GetLastError();
363		363
364	// Display a warning	364	// Display a warning
365	_RPTF0(_CRT_WARN,"CSerial::Setup - Unable to set DCB information\n");	365	_RPTF0(_CRT_WARN,"CSerial::Setup - Unable to set DCB information\n");
366	return m_lLastError;	366	return m_lLastError;
367	}	367	}
368		368
369	// Return successful	369	// Return successful
370	return m_lLastError;	370	return m_lLastError;
371	}	371	}
372		372
373	LONG CSerial::SetEventChar (BYTE bEventChar, bool fAdjustMask)	373	LONG CSerial::SetEventChar (BYTE bEventChar, bool fAdjustMask)
374	{	374	{
375	// Reset error state	375	// Reset error state
376	m_lLastError = ERROR_SUCCESS;	376	m_lLastError = ERROR_SUCCESS;
377		377
378	// Check if the device is open	378	// Check if the device is open
379	if (m_hFile == 0)	379	if (m_hFile == 0)
380	{	380	{
381	// Set the internal error code	381	// Set the internal error code
382	m_lLastError = ERROR_INVALID_HANDLE;	382	m_lLastError = ERROR_INVALID_HANDLE;
383		383
384	// Issue an error and quit	384	// Issue an error and quit
385	_RPTF0(_CRT_WARN,"CSerial::SetEventChar - Device is not opened\n");	385	_RPTF0(_CRT_WARN,"CSerial::SetEventChar - Device is not opened\n");
386	return m_lLastError;	386	return m_lLastError;
387	}	387	}
388		388
389	// Obtain the DCB structure for the device	389	// Obtain the DCB structure for the device
390	CDCB dcb;	390	CDCB dcb;
391	if (!::GetCommState(m_hFile,&dcb))	391	if (!::GetCommState(m_hFile,&dcb))
392	{	392	{
393	// Obtain the error code	393	// Obtain the error code
394	m_lLastError = ::GetLastError();	394	m_lLastError = ::GetLastError();
395		395
396	// Display a warning	396	// Display a warning
397	_RPTF0(_CRT_WARN,"CSerial::SetEventChar - Unable to obtain DCB information\n");	397	_RPTF0(_CRT_WARN,"CSerial::SetEventChar - Unable to obtain DCB information\n");
398	return m_lLastError;	398	return m_lLastError;
399	}	399	}
400		400
401	// Set the new event character	401	// Set the new event character
402	dcb.EvtChar = char(bEventChar);	402	dcb.EvtChar = char(bEventChar);
403		403
404	// Adjust the event mask, to make sure the event will be received	404	// Adjust the event mask, to make sure the event will be received
405	if (fAdjustMask)	405	if (fAdjustMask)
406	{	406	{
407	// Enable 'receive event character' event. Note that this	407	// Enable 'receive event character' event. Note that this
408	// will generate an EEventNone if there is an asynchronous	408	// will generate an EEventNone if there is an asynchronous
409	// WaitCommEvent pending.	409	// WaitCommEvent pending.
410	SetMask(GetEventMask() \| EEventRcvEv);	410	SetMask(GetEventMask() \| EEventRcvEv);
411	}	411	}
412		412
413	// Set the new DCB structure	413	// Set the new DCB structure
414	if (!::SetCommState(m_hFile,&dcb))	414	if (!::SetCommState(m_hFile,&dcb))
415	{	415	{
416	// Obtain the error code	416	// Obtain the error code
417	m_lLastError = ::GetLastError();	417	m_lLastError = ::GetLastError();
418		418
419	// Display a warning	419	// Display a warning
420	_RPTF0(_CRT_WARN,"CSerial::SetEventChar - Unable to set DCB information\n");	420	_RPTF0(_CRT_WARN,"CSerial::SetEventChar - Unable to set DCB information\n");
421	return m_lLastError;	421	return m_lLastError;
422	}	422	}
423		423
424	// Return successful	424	// Return successful
425	return m_lLastError;	425	return m_lLastError;
426	}	426	}
427		427
428	LONG CSerial::SetMask (DWORD dwEventMask)	428	LONG CSerial::SetMask (DWORD dwEventMask)
429	{	429	{
430	// Reset error state	430	// Reset error state
431	m_lLastError = ERROR_SUCCESS;	431	m_lLastError = ERROR_SUCCESS;
432		432
433	// Check if the device is open	433	// Check if the device is open
434	if (m_hFile == 0)	434	if (m_hFile == 0)
435	{	435	{
436	// Set the internal error code	436	// Set the internal error code
437	m_lLastError = ERROR_INVALID_HANDLE;	437	m_lLastError = ERROR_INVALID_HANDLE;
438		438
439	// Issue an error and quit	439	// Issue an error and quit
440	_RPTF0(_CRT_WARN,"CSerial::SetMask - Device is not opened\n");	440	_RPTF0(_CRT_WARN,"CSerial::SetMask - Device is not opened\n");
441	return m_lLastError;	441	return m_lLastError;
442	}	442	}
443		443
444	// Set the new mask. Note that this will generate an EEventNone	444	// Set the new mask. Note that this will generate an EEventNone
445	// if there is an asynchronous WaitCommEvent pending.	445	// if there is an asynchronous WaitCommEvent pending.
446	if (!::SetCommMask(m_hFile,dwEventMask))	446	if (!::SetCommMask(m_hFile,dwEventMask))
447	{	447	{
448	// Obtain the error code	448	// Obtain the error code
449	m_lLastError = ::GetLastError();	449	m_lLastError = ::GetLastError();
450		450
451	// Display a warning	451	// Display a warning
452	_RPTF0(_CRT_WARN,"CSerial::SetMask - Unable to set event mask\n");	452	_RPTF0(_CRT_WARN,"CSerial::SetMask - Unable to set event mask\n");
453	return m_lLastError;	453	return m_lLastError;
454	}	454	}
455		455
456	// Save event mask and return successful	456	// Save event mask and return successful
457	m_dwEventMask = dwEventMask;	457	m_dwEventMask = dwEventMask;
458	return m_lLastError;	458	return m_lLastError;
459	}	459	}
460		460
461	LONG CSerial::WaitEvent (LPOVERLAPPED lpOverlapped, DWORD dwTimeout)	461	LONG CSerial::WaitEvent (LPOVERLAPPED lpOverlapped, DWORD dwTimeout)
462	{	462	{
463	// Check if time-outs are supported	463	// Check if time-outs are supported
464	CheckRequirements(lpOverlapped,dwTimeout);	464	CheckRequirements(lpOverlapped,dwTimeout);
465		465
466	// Reset error state	466	// Reset error state
467	m_lLastError = ERROR_SUCCESS;	467	m_lLastError = ERROR_SUCCESS;
468		468
469	// Check if the device is open	469	// Check if the device is open
470	if (m_hFile == 0)	470	if (m_hFile == 0)
471	{	471	{
472	// Set the internal error code	472	// Set the internal error code
473	m_lLastError = ERROR_INVALID_HANDLE;	473	m_lLastError = ERROR_INVALID_HANDLE;
474		474
475	// Issue an error and quit	475	// Issue an error and quit
476	_RPTF0(_CRT_WARN,"CSerial::WaitEvent - Device is not opened\n");	476	_RPTF0(_CRT_WARN,"CSerial::WaitEvent - Device is not opened\n");
477	return m_lLastError;	477	return m_lLastError;
478	}	478	}
479		479
480	#ifndef SERIAL_NO_OVERLAPPED	480	#ifndef SERIAL_NO_OVERLAPPED
481		481
482	// Check if an overlapped structure has been specified	482	// Check if an overlapped structure has been specified
483	if (!m_hevtOverlapped && (lpOverlapped \|\| (dwTimeout != INFINITE)))	483	if (!m_hevtOverlapped && (lpOverlapped \|\| (dwTimeout != INFINITE)))
484	{	484	{
485	// Set the internal error code	485	// Set the internal error code
486	m_lLastError = ERROR_INVALID_FUNCTION;	486	m_lLastError = ERROR_INVALID_FUNCTION;
487		487
488	// Issue an error and quit	488	// Issue an error and quit
489	_RPTF0(_CRT_WARN,"CSerial::WaitEvent - Overlapped I/O is disabled, specified parameters are illegal.\n");	489	_RPTF0(_CRT_WARN,"CSerial::WaitEvent - Overlapped I/O is disabled, specified parameters are illegal.\n");
490	return m_lLastError;	490	return m_lLastError;
491	}	491	}
492		492
493	// Wait for the event to happen	493	// Wait for the event to happen
494	OVERLAPPED ovInternal;	494	OVERLAPPED ovInternal;
495	if (!lpOverlapped && m_hevtOverlapped)	495	if (!lpOverlapped && m_hevtOverlapped)
496	{	496	{
497	// Setup our own overlapped structure	497	// Setup our own overlapped structure
498	memset(&ovInternal,0,sizeof(ovInternal));	498	memset(&ovInternal,0,sizeof(ovInternal));
499	ovInternal.hEvent = m_hevtOverlapped;	499	ovInternal.hEvent = m_hevtOverlapped;
500		500

Subversion Repositories HomeAutomation

(root)/branches/atomV2/PcSoftware/canBootloaderCPP/canBootloader/Serial.cpp – Rev 270 → 1308