vrpn_SerialPort.h

Go to the documentation of this file.

 
//          Copyright Iowa State University 2012.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
// Internal Includes
#include "vrpn_Configure.h" // for VRPN_API
#include "vrpn_Serial.h"    // for ::vrpn_SER_PARITY_NONE, etc
 
// Library/third-party includes
// - none
 
// Standard includes
#include <stdexcept> // for runtime_error, logic_error
#include <string>    // for string

class VRPN_API vrpn_SerialPort {
public:
    typedef int file_handle_type;
    vrpn_SerialPort(const char *portname, long baud, int charsize = 8,
                    vrpn_SER_PARITY parity = vrpn_SER_PARITY_NONE);

    vrpn_SerialPort();

    ~vrpn_SerialPort();

    void open(const char *portname, long baud, int charsize = 8,
              vrpn_SER_PARITY parity = vrpn_SER_PARITY_NONE);
    bool is_open() const;

    void close();

    int write(std::string const &buffer);
    int write(const unsigned char *buffer, int bytes);

    int read_available_characters(unsigned char *buffer, int count);

    std::string read_available_characters(int count = -1);

    int read_available_characters(unsigned char *buffer, int count,
                                  struct timeval &timeout);

    std::string read_available_characters(int count, struct timeval &timeout);


    void flush_input_buffer();

    void flush_output_buffer();

    void drain_output_buffer();

    void set_rts();
    void clear_rts();
    void assign_rts(bool set);

    struct AlreadyOpen;
    struct CloseFailure;
    struct DrainFailure;
    struct FlushFailure;
    struct NotOpen;
    struct OpenFailure;
    struct RTSFailure;
    struct ReadFailure;
    struct WriteFailure;
 
private:
    void requiresOpen() const;
    vrpn_SerialPort(vrpn_SerialPort const &);
    vrpn_SerialPort const &operator=(vrpn_SerialPort const &);
    file_handle_type _comm;
    bool _rts_status;
};
 
struct vrpn_SerialPort::AlreadyOpen : std::logic_error {
    AlreadyOpen()
        : std::logic_error("Tried to open a serial port that was already open.")
    {
    }
};
 
struct vrpn_SerialPort::NotOpen : std::logic_error {
    NotOpen()
        : std::logic_error("Tried to use a serial port that was not yet open.")
    {
    }
};
 
struct vrpn_SerialPort::OpenFailure : std::runtime_error {
    OpenFailure()
        : std::runtime_error(
              "Received an error when trying to open serial port.")
    {
    }
};
 
struct vrpn_SerialPort::CloseFailure : std::runtime_error {
    CloseFailure()
        : std::runtime_error(
              "Received an error when trying to close serial port.")
    {
    }
};
 
struct vrpn_SerialPort::RTSFailure : std::runtime_error {
    RTSFailure()
        : std::runtime_error("Failed to modify serial port RTS status.")
    {
    }
};
 
struct vrpn_SerialPort::ReadFailure : std::runtime_error {
    ReadFailure()
        : std::runtime_error("Failure on serial port read.")
    {
    }
};
 
struct vrpn_SerialPort::WriteFailure : std::runtime_error {
    WriteFailure()
        : std::runtime_error("Failure on serial port write.")
    {
    }
};
 
struct vrpn_SerialPort::FlushFailure : std::runtime_error {
    FlushFailure()
        : std::runtime_error("Failure on serial port flush.")
    {
    }
};
 
struct vrpn_SerialPort::DrainFailure : std::runtime_error {
    DrainFailure()
        : std::runtime_error("Failure on serial port drain.")
    {
    }
};
 
inline bool vrpn_SerialPort::is_open() const { return _comm != -1; }
 
inline void vrpn_SerialPort::assign_rts(bool set)
{
    if (set) {
        set_rts();
    }
    else {
        clear_rts();
    }
}
 
inline void vrpn_SerialPort::requiresOpen() const
{
    if (!is_open()) {
        throw NotOpen();
    }
}