vrpn_SerialPort.h

浏览该文件的文档.

 
//          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();
    }
}