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-2023 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)
    // Windows defines standard baud rates in WinBase.h, which does not include
    // CBR_230400 or CBR_460800.
    #ifndef CBR_230400
    #define CBR_230400 230400
    #endif
    #ifndef CBR_460800
    #define CBR_460800 460800
    #endif
    enum BaudRateType {BaudRate300 = CBR_300,
                       BaudRate1200 = CBR_1200,
                       BaudRate9600 = CBR_9600,
                       BaudRate19200 = CBR_19200,
                       BaudRate38400 = CBR_38400,
                       BaudRate57600 = CBR_57600,
                       BaudRate115200 = CBR_115200,
                       BaudRate230400 = CBR_230400,
                       BaudRate460800 = CBR_460800};
#else
    // MacOS doesn't define some of the baud rates
    #ifndef B460800
    #define B460800 460800
    #endif
    enum BaudRateType {BaudRate300 = B300,
                       BaudRate1200 = B1200,
                       BaudRate9600 = B9600,
                       BaudRate19200 = B19200,
                       BaudRate38400 = B38400,
                       BaudRate57600 = B57600,
                       BaudRate115200 = B115200,
                       BaudRate230400 = B230400,
                       BaudRate460800 = B460800};
#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