osaSerialPort.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s): Anton Deguet
  Created on: 2004-12-06

  (C) Copyright 2004-2009 Johns Hopkins University (JHU), All Rights
  Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/


#ifndef _osaSerialPort_h
#define _osaSerialPort_h


#include <cisstCommon/cmnPortability.h>
#include <cisstCommon/cmnGenericObject.h>
#include <cisstOSAbstraction/osaExport.h>

#if (CISST_OS == CISST_WINDOWS)
#include <windows.h>
#else
#include <termios.h>
#endif

#include <sstream>


class CISST_EXPORT osaSerialPort: public cmnGenericObject
{
    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);

public:
#if (CISST_OS == CISST_WINDOWS)
    enum BaudRateType {BaudRate300 = CBR_300,
                       BaudRate1200 = CBR_1200,
                       BaudRate9600 = CBR_9600,
                       BaudRate19200 = CBR_19200,
                       BaudRate38400 = CBR_38400,
                       BaudRate57600 = CBR_57600,
                       BaudRate115200 = CBR_115200};
#else
    enum BaudRateType {BaudRate300 = B300,
                       BaudRate1200 = B1200,
                       BaudRate9600 = B9600,
                       BaudRate19200 = B19200,
                       BaudRate38400 = B38400,
                       BaudRate57600 = B57600,
                       BaudRate115200 = B115200};
#endif


#if (CISST_OS == CISST_WINDOWS)
    enum CharacterSizeType {CharacterSize5 = 5,
                            CharacterSize6 = 6,
                            CharacterSize7 = 7,
                            CharacterSize8 = 8};
#else
    enum CharacterSizeType {CharacterSize5 = CS5,
                            CharacterSize6 = CS6,
                            CharacterSize7 = CS7,
                            CharacterSize8 = CS8};
#endif


#if (CISST_OS == CISST_WINDOWS)
    enum ParityCheckingType {ParityCheckingNone = NOPARITY,
                             ParityCheckingEven = EVENPARITY,
                             ParityCheckingOdd = ODDPARITY};
#else
    enum ParityCheckingType {ParityCheckingNone,
                             ParityCheckingEven,
                             ParityCheckingOdd};
#endif


    enum FlowControlType {FlowControlNone,
                          FlowControlSoftware,
                          FlowControlHardware};

    enum StopBitsType {StopBitsOne,
                       StopBitsTwo};


    osaSerialPort(void):
        PortName("Undefined"),
        IsOpenedFlag(false),
        BaudRate(BaudRate9600),
        CharacterSize(CharacterSize8),
        ParityChecking(ParityCheckingNone),
        StopBits(StopBitsOne),
        FlowControl(FlowControlNone)
    {
#if (CISST_OS == CISST_WINDOWS)
        memset(&OverlappedStructureRead, 0, sizeof(OverlappedStructureRead));
        memset(&OverlappedStructureWrite, 0, sizeof(OverlappedStructureWrite));
#else // Unix
        FileDescriptor = -1;
#endif
    }

  
    virtual ~osaSerialPort(void);
    
    inline void SetBaudRate(const BaudRateType & baudRate) {
        this->BaudRate = baudRate;
        CMN_LOG_CLASS_INIT_VERBOSE << "Baud rate modified to " << this->BaudRate
                                   << " on port " << this->PortName << " (not effective until Configure)" << std::endl;
    }

    inline void SetCharacterSize(const CharacterSizeType & characterSize) {
        this->CharacterSize = characterSize;
        CMN_LOG_CLASS_INIT_VERBOSE << "Character size modified to " << this->CharacterSize
                                   << " on port " << this->PortName << " (not effective until Configure)" << std::endl;
    }

    inline void SetParityChecking(const ParityCheckingType & parityChecking) {
        this->ParityChecking = parityChecking;
        CMN_LOG_CLASS_INIT_VERBOSE << "Parity checking modified to " << this->ParityChecking
                                   << " on port " << this->PortName << " (not effective until Configure)" << std::endl;
    }

    inline void SetStopBits(const StopBitsType & stopBits) {
        this->StopBits = stopBits;
        CMN_LOG_CLASS_INIT_VERBOSE << "Stop bits modified to " << this->StopBits
                                   << " on port " << this->PortName << " (not effective until Configure)" << std::endl;
    }

    inline void SetFlowControl(const FlowControlType & flowControl) {
        this->FlowControl = flowControl;
        CMN_LOG_CLASS_INIT_VERBOSE << "Flow control modified to " << this->FlowControl
                                   << " on port " << this->PortName << " (not effective until Configure)" << std::endl;
    }

    inline void SetPortName(const std::string & portName) {
        this->PortName = portName;
    }

    inline std::string GetPortName(void) const {
        return this->PortName;
    }

    std::string SetPortNumber(unsigned int portNumber);

    bool Open(bool blocking = false);

    bool Configure(void);

    bool Close(void);

    inline bool IsOpened(void) const {
        return this->IsOpenedFlag;
    }

    // PK: why overload for char and uchar?
    int Write(const char * data, int nBytes);
    int Write(const unsigned char * data, int nBytes);
    inline int Write(const std::string & data) {
        return this->Write(data.c_str(), static_cast<int>(data.size()));
    }
    
    // PK: why overload for char and uchar?
    int Read(char * data, int nBytes);
    int Read(unsigned char * data, int nBytes);

    bool WriteBreak(double breakLengthInSeconds);
  
    bool Flush(void);

private:
    // full port name
    std::string PortName;
    bool IsOpenedFlag;

    // parameters
    BaudRateType BaudRate;
    CharacterSizeType CharacterSize;
    ParityCheckingType ParityChecking;
    StopBitsType StopBits;
    FlowControlType FlowControl;
    
#if (CISST_OS == CISST_WINDOWS)
    HANDLE PortHandle;
    OVERLAPPED OverlappedStructureRead, OverlappedStructureWrite;
    COMMTIMEOUTS TimeOuts;
    bool isBlocking;
#else // Unix
    int FileDescriptor;
#endif  
};


CMN_DECLARE_SERVICES_INSTANTIATION(osaSerialPort);


#endif // _osaSerialPort_h