include/serial/serial.h

Go to the documentation of this file.

#ifndef SERIAL_H
#define SERIAL_H

#include <limits>
#include <vector>
#include <string>
#include <sstream>
#include <exception>
#include <stdexcept>

#define THROW(exceptionClass, message) throw exceptionClass(__FILE__, \
__LINE__, (message) )

namespace serial {

typedef enum {
  fivebits = 5,
  sixbits = 6,
  sevenbits = 7,
  eightbits = 8
} bytesize_t;

typedef enum {
  parity_none = 0,
  parity_odd = 1,
  parity_even = 2
} parity_t;

typedef enum {
  stopbits_one = 1,
  stopbits_one_point_five,
  stopbits_two = 2
} stopbits_t;

typedef enum {
  flowcontrol_none = 0,
  flowcontrol_software
} flowcontrol_t;

struct Timeout {
    Timeout (long inter_byte_timeout_=0, long read_timeout_constant_=0,
               long read_timeout_multiplier_=0, long write_timeout_constant_=0,
               long write_timeout_multiplier_=0)
    : inter_byte_timeout(inter_byte_timeout_),
      read_timeout_constant(read_timeout_constant_),
      read_timeout_multiplier(read_timeout_multiplier_),
      write_timeout_constant(write_timeout_constant_),
      write_timeout_multiplier(write_timeout_multiplier_)
    {}
    long inter_byte_timeout;
    long read_timeout_constant;
    long read_timeout_multiplier;
    long write_timeout_constant;
    long write_timeout_multiplier;
};

class Serial {
public:
  Serial (const std::string &port = "",
          unsigned long baudrate = 9600,
          Timeout timeout = Timeout(),
          bytesize_t bytesize = eightbits,
          parity_t parity = parity_none,
          stopbits_t stopbits = stopbits_one,
          flowcontrol_t flowcontrol = flowcontrol_none);

  virtual ~Serial ();

  void
  open ();

  bool
  isOpen () const;

  void
  close ();

  size_t
  available ();

  size_t
  read (unsigned char *buffer, size_t size);

  size_t
  read (std::vector<unsigned char> &buffer, size_t size = 1);

  size_t
  read (std::string &buffer, size_t size = 1);

  std::string
  read (size_t size = 1);

  size_t
  readline (std::string &buffer, size_t size = 65536, std::string eol = "\n");

  std::string
  readline (size_t size = 65536, std::string eol = "\n");

  std::vector<std::string>
  readlines (size_t size = 65536, std::string eol = "\n");

  size_t
  write (const unsigned char *data, size_t size);

  size_t
  write (const std::vector<unsigned char> &data);

  size_t
  write (const std::string &data);

  void
  setPort (const std::string &port);

  std::string
  getPort () const;

  void
  setTimeout (Timeout &timeout);

  void
  setTimeout (long inter_byte_timeout, long read_timeout_constant,
              long read_timeout_multiplier, long write_timeout_constant,
              long write_timeout_multiplier)
  {
    Timeout timeout(inter_byte_timeout, read_timeout_constant,
                      read_timeout_multiplier, write_timeout_constant,
                      write_timeout_multiplier);
    return setTimeout(timeout);
  }

  Timeout
  getTimeout () const;

  void
  setBaudrate (unsigned long baudrate);

  unsigned long
  getBaudrate () const;

  void
  setBytesize (bytesize_t bytesize);

  bytesize_t
  getBytesize () const;

  void
  setParity (parity_t parity);

  parity_t
  getParity () const;

  void
  setStopbits (stopbits_t stopbits);

  stopbits_t
  getStopbits () const;

  void
  setFlowcontrol (flowcontrol_t flowcontrol);

  flowcontrol_t
  getFlowcontrol () const;

  void
  flush ();

  void
  flushInput ();

  void
  flushOutput ();

  void
  sendBreak (int duration);

  void
  setBreak (bool level = true);

  void
  setRTS (bool level = true);

  void
  setDTR (bool level = true);

  bool
  waitForChange ();

  bool
  getCTS ();

  bool
  getDSR ();

  bool
  getRI ();

  bool
  getCD ();

private:
  // Disable copy constructors
  Serial(const Serial&);
  void operator=(const Serial&);
  const Serial& operator=(Serial);

  std::string read_cache_; 

  // Pimpl idiom, d_pointer
  class SerialImpl;
  SerialImpl *pimpl_;

  // Scoped Lock Classes
  class ScopedReadLock;
  class ScopedWriteLock;

  // Read common function
  size_t
  read_ (unsigned char *buffer, size_t size);

};

class SerialExecption : public std::exception
{
  const char* e_what_;
public:
  SerialExecption (const char *description) : e_what_ (description) {}

  virtual const char* what () const throw ()
  {
    std::stringstream ss;
    ss << "SerialException " << e_what_ << " failed.";
    return ss.str ().c_str ();
  }
};

class IOException : public std::exception
{
  std::string file_;
  int line_;
  const char* e_what_;
  int errno_;
public:
  explicit IOException (std::string file, int line, int errnum)
  : file_(file), line_(line), e_what_ (strerror (errnum)), errno_(errnum) {}
  explicit IOException (std::string file, int line, const char * description)
  : file_(file), line_(line), e_what_ (description), errno_(0) {}
  virtual ~IOException() throw() {}

  int getErrorNumber () { return errno_; }

  virtual const char* what () const throw ()
  {
    std::stringstream ss;
    if (errno_ == 0)
      ss << "IO Exception: " << e_what_;
    else
      ss << "IO Exception (" << errno_ << "): " << e_what_;
    ss << ", file " << file_ << ", line " << line_ << ".";
    return ss.str ().c_str ();
  }
};

class PortNotOpenedException : public std::exception
{
  const char * e_what_;
public:
  PortNotOpenedException (const char * description) : e_what_ (description) {}

  virtual const char* what () const throw ()
  {
    std::stringstream ss;
    ss << e_what_ << " called before port was opened.";
    return ss.str ().c_str ();
  }
};

class SerialExceptionBase : public std::exception
{
  
};

} // namespace serial

#endif