Merge branch 'new_api'

.gitignore

@@ -23,3 +23,5 @@ patched
 wiped
 msg_gen
 srv_gen
+doc/html
+*sublime-workspace

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 2.4.6)
 
 set(ROS_ROOT $ENV{ROS_ROOT})
 
-option(SERIAL_BUILD_WIHOUT_ROS "Build without ROS?" OFF)
+option(SERIAL_BUILD_WIHOUT_ROS "Build without ROS?" ON)
 
 if(DEFINED ROS_ROOT AND NOT SERIAL_BUILD_WIHOUT_ROS)
   # Build with ROS

README.md

@@ -70,7 +70,7 @@ Run the example:
 
 The BSD License
 
-Copyright (c) 2011 William Woodall
+Copyright (c) 2012 William Woodall
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

doc/Doxyfile

@@ -37,7 +37,7 @@ PROJECT_NUMBER         = 1.0
 # for a project that appears at the top of each page and should give viewer
 # a quick idea about the purpose of the project. Keep the description short.
 
-PROJECT_BRIEF          = Cross-platform serial port library for C++
+PROJECT_BRIEF          = "Cross-platform serial port library for C++"
 
 # With the PROJECT_LOGO tag one can specify an logo or icon that is
 # included in the documentation. The maximum height of the logo should not
@@ -610,7 +610,7 @@ WARN_LOGFILE           =
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
-INPUT                  = include/serial include/serial/impl src src/impl
+INPUT                  = include src
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
@@ -634,7 +634,7 @@ FILE_PATTERNS          =
 # should be searched for input files as well. Possible values are YES and NO.
 # If left blank NO is used.
 
-RECURSIVE              = NO
+RECURSIVE              = YES
 
 # The EXCLUDE tag can be used to specify files and/or directories that should
 # excluded from the INPUT source files. This way you can easily exclude a

include/serial/impl/unix.h

@@ -8,9 +8,9 @@
  *
  * The MIT License
  *
- * Copyright (c) 2011 William Woodall, John Harrison
+ * Copyright (c) 2012 William Woodall, John Harrison
  *
- * Permission is hereby granted, free of charge, to any person obtaining a 
+ * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
@@ -24,8 +24,8 @@
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  *
  * \section DESCRIPTION
@@ -54,7 +54,6 @@ class serial::Serial::SerialImpl {
 public:
   SerialImpl (const string &port,
               unsigned long baudrate,
-              long timeout,
               bytesize_t bytesize,
               parity_t parity,
               stopbits_t stopbits,
@@ -75,10 +74,10 @@ public:
   available ();
 
   size_t
-  read (unsigned char* buf, size_t size = 1);
+  read (uint8_t *buf, size_t size = 1);
 
   size_t
-  write (const string &data);
+  write (const uint8_t *data, size_t length);
 
   void
   flush ();
@@ -90,28 +89,31 @@ public:
   flushOutput ();
 
   void
-  sendBreak(int duration);
+  sendBreak (int duration);
 
   void
-  setBreak(bool level);
+  setBreak (bool level);
 
   void
-  setRTS(bool level);
+  setRTS (bool level);
 
   void
-  setDTR(bool level);
+  setDTR (bool level);
 
   bool
-  getCTS();
+  waitForChange ();
 
   bool
-  getDSR();
+  getCTS ();
 
   bool
-  getRI();
+  getDSR ();
 
   bool
-  getCD();
+  getRI ();
+
+  bool
+  getCD ();
 
   void
   setPort (const string &port);
@@ -120,9 +122,9 @@ public:
   getPort () const;
 
   void
-  setTimeout (long timeout);
+  setTimeout (Timeout &timeout);
 
-  long
+  Timeout
   getTimeout () const;
 
   void
@@ -156,16 +158,16 @@ public:
   getFlowcontrol () const;
 
   void
-  readLock();
+  readLock ();
 
   void
-  readUnlock();
+  readUnlock ();
 
   void
-  writeLock();
+  writeLock ();
 
   void
-  writeUnlock();
+  writeUnlock ();
 
 protected:
   void reconfigurePort ();
@@ -178,7 +180,7 @@ private:
   bool xonxoff_;
   bool rtscts_;
 
-  long timeout_;              // Timeout for read operations
+  Timeout timeout_;         // Timeout for read operations
   unsigned long baudrate_;    // Baudrate
 
   parity_t parity_;           // Parity

include/serial/impl/windows.h → include/serial/impl/win.h

@@ -8,7 +8,7 @@
  *
  * The MIT License
  *
- * Copyright (c) 2011 William Woodall, John Harrison
+ * Copyright (c) 2012 William Woodall, John Harrison
  *
  * Permission is hereby granted, free of charge, to any person obtaining a 
  * copy of this software and associated documentation files (the "Software"),
@@ -39,6 +39,8 @@
 
 #include "serial/serial.h"
 
+#include "windows.h"
+
 namespace serial {
 
 using std::string;
@@ -51,7 +53,6 @@ class serial::Serial::SerialImpl {
 public:
   SerialImpl (const string &port,
               unsigned long baudrate,
-              long timeout,
               bytesize_t bytesize,
               parity_t parity,
               stopbits_t stopbits,
@@ -72,10 +73,10 @@ public:
   available ();
 
   size_t
-  read (char* buf, size_t size = 1);
+  read (uint8_t *buf, size_t size = 1);
 
   size_t
-  write (const string &data);
+  write (const uint8_t *data, size_t length);
 
   void
   flush ();
@@ -87,50 +88,53 @@ public:
   flushOutput ();
 
   void
-  sendBreak(int duration);
+  sendBreak (int duration);
 
   void
-  setBreak(bool level);
+  setBreak (bool level);
 
   void
-  setRTS(bool level);
+  setRTS (bool level);
 
   void
-  setDTR(bool level);
-  
+  setDTR (bool level);
+
   bool
-  getCTS();
-  
+  waitForChange ();
+
+  bool
+  getCTS ();
+
   bool
-  getDSR();
-  
+  getDSR ();
+
   bool
-  getRI();
-  
+  getRI ();
+
   bool
-  getCD();
+  getCD ();
 
   void
   setPort (const string &port);
-  
+
   string
   getPort () const;
 
   void
-  setTimeout (long timeout);
-  
-  long
+  setTimeout (Timeout &timeout);
+
+  Timeout
   getTimeout () const;
 
   void
   setBaudrate (unsigned long baudrate);
-  
+
   unsigned long
   getBaudrate () const;
 
   void
   setBytesize (bytesize_t bytesize);
-  
+
   bytesize_t
   getBytesize () const;
 
@@ -152,24 +156,39 @@ public:
   flowcontrol_t
   getFlowcontrol () const;
 
+  void
+  readLock ();
+
+  void
+  readUnlock ();
+
+  void
+  writeLock ();
+
+  void
+  writeUnlock ();
+
 protected:
   void reconfigurePort ();
 
 private:
   string port_;               // Path to the file descriptor
-  int fd_;                    // The current file descriptor
+  HANDLE fd_;
 
-  bool isOpen_;
-  bool xonxoff_;
-  bool rtscts_;
+  bool is_open_;
 
-  long timeout_;              // Timeout for read operations
+  Timeout timeout_;           // Timeout for read operations
   unsigned long baudrate_;    // Baudrate
 
   parity_t parity_;           // Parity
   bytesize_t bytesize_;       // Size of the bytes
   stopbits_t stopbits_;       // Stop Bits
   flowcontrol_t flowcontrol_; // Flow Control
+
+  // Mutex used to lock the read functions
+  HANDLE read_mutex;
+  // Mutex used to lock the write functions
+  HANDLE write_mutex;
 };
 
 }

include/serial/v8stdint.h

+// This header is from the v8 google project: 
+// http://code.google.com/p/v8/source/browse/trunk/include/v8stdint.h
+
+// Copyright 2012 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Load definitions of standard types.
+
+#ifndef V8STDINT_H_
+#define V8STDINT_H_
+
+#include <stddef.h>
+#include <stdio.h>
+
+#if defined(_WIN32) && !defined(__MINGW32__)
+
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef short int16_t;  // NOLINT
+typedef unsigned short uint16_t;  // NOLINT
+typedef int int32_t;
+typedef unsigned int uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+// intptr_t and friends are defined in crtdefs.h through stdio.h.
+
+#else
+
+#include <stdint.h>
+
+#endif
+
+#endif  // V8STDINT_H_

serial.cmake

@@ -122,6 +122,7 @@ macro(build_serial)
       )
     
       INSTALL(FILES include/serial/serial.h
+                    include/serial/v8stdint.h
               DESTINATION include/serial)
     
       IF(NOT CMAKE_FIND_INSTALL_PATH)

serial.sublime-project

+{
+	"word_wrap": "on",
+    "wrap_width": 80,
+	"folders":
+	[
+		{
+			"path": "/Users/william/devel/serial"
+		}
+	],
+	"settings":
+	{
+		"sublimeclang_options":
+		[
+			"-I/usr/include",
+			"-I/usr/local/include",
+			// "-I/usr/lib/clang/3.1/include/",
+			"-I${folder:${project_path:serial.sublime-project}}/include"
+		]
+	}
+}

src/impl/win.cc

+/* Copyright 2012 William Woodall and John Harrison */
+
+#include "serial/impl/win.h"
+
+using std::string;
+using std::stringstream;
+using std::invalid_argument;
+using serial::Serial;
+using serial::SerialExecption;
+using serial::PortNotOpenedException;
+using serial::IOException;
+
+
+Serial::SerialImpl::SerialImpl (const string &port, unsigned long baudrate,
+                                bytesize_t bytesize,
+                                parity_t parity, stopbits_t stopbits,
+                                flowcontrol_t flowcontrol)
+  : port_ (port), fd_ (INVALID_HANDLE_VALUE), is_open_ (false),
+    baudrate_ (baudrate), parity_ (parity),
+    bytesize_ (bytesize), stopbits_ (stopbits), flowcontrol_ (flowcontrol)
+{
+  read_mutex = CreateMutex(NULL, false, NULL);
+  write_mutex = CreateMutex(NULL, false, NULL);
+  if (port_.empty () == false)
+    open ();
+}
+
+Serial::SerialImpl::~SerialImpl ()
+{
+  this->close();
+  CloseHandle(read_mutex);
+  CloseHandle(write_mutex);
+}
+
+void
+Serial::SerialImpl::open ()
+{
+  if (port_.empty ()) {
+    throw invalid_argument ("Empty port is invalid.");
+  }
+  if (is_open_ == true) {
+    throw SerialExecption ("Serial port already open.");
+  }
+
+  fd_ = CreateFile(port_,
+                   GENERIC_READ | GENERIC_WRITE,
+                   0,
+                   0,
+                   OPEN_EXISTING,
+                   FILE_ATTRIBUTE_NORMAL,
+                   0);
+
+  if (fd_ == INVALID_HANDLE_VALUE) {
+    DWORD errno = GetLastError();
+    switch (errno) {
+    case ERROR_FILE_NOT_FOUND:
+      stringstream ss;
+      ss << "Specified port, " << port_ << ", does not exist."
+      THROW (IOException, ss.str().c_str());
+    default:
+      stringstream ss;
+      ss << "Unknown error opening the serial port: " << errno;
+      THROW (IOException, ss.str().c_str());
+    }
+  }
+
+  reconfigurePort();
+  is_open_ = true;
+}
+
+void
+Serial::SerialImpl::reconfigurePort ()
+{
+  if (fd_ == INVALID_HANDLE_VALUE) {
+    // Can only operate on a valid file descriptor
+    THROW (IOException, "Invalid file descriptor, is the serial port open?");
+  }
+
+  DCB dcbSerialParams = {0};
+
+  dcbSerial.DCBlength=sizeof(dcbSerialParams);
+
+  if (!GetCommState(fd_, &dcbSerialParams)) {
+    //error getting state
+    THROW (IOException, "Error getting the serial port state.");
+  }
+
+  // setup baud rate
+  switch (baudrate_) {
+#ifdef CBR_0
+  case 0: dcbSerialParams.BaudRate = CBR_0; break;
+#endif
+#ifdef CBR_50
+  case 50: dcbSerialParams.BaudRate = CBR_50; break;
+#endif
+#ifdef CBR_75
+  case 75: dcbSerialParams.BaudRate = CBR_75; break;
+#endif
+#ifdef CBR_110
+  case 110: dcbSerialParams.BaudRate = CBR_110; break;
+#endif
+#ifdef CBR_134
+  case 134: dcbSerialParams.BaudRate = CBR_134; break;
+#endif
+#ifdef CBR_150
+  case 150: dcbSerialParams.BaudRate = CBR_150; break;
+#endif
+#ifdef CBR_200
+  case 200: dcbSerialParams.BaudRate = CBR_200; break;
+#endif
+#ifdef CBR_300
+  case 300: dcbSerialParams.BaudRate = CBR_300; break;
+#endif
+#ifdef CBR_600
+  case 600: dcbSerialParams.BaudRate = CBR_600; break;
+#endif
+#ifdef CBR_1200
+  case 1200: dcbSerialParams.BaudRate = CBR_1200; break;
+#endif
+#ifdef CBR_1800
+  case 1800: dcbSerialParams.BaudRate = CBR_1800; break;
+#endif
+#ifdef CBR_2400
+  case 2400: dcbSerialParams.BaudRate = CBR_2400; break;
+#endif
+#ifdef CBR_4800
+  case 4800: dcbSerialParams.BaudRate = CBR_4800; break;
+#endif
+#ifdef CBR_7200
+  case 7200: dcbSerialParams.BaudRate = CBR_7200; break;
+#endif
+#ifdef CBR_9600
+  case 9600: dcbSerialParams.BaudRate = CBR_9600; break;
+#endif
+#ifdef CBR_14400
+  case 14400: dcbSerialParams.BaudRate = CBR_14400; break;
+#endif
+#ifdef CBR_19200
+  case 19200: dcbSerialParams.BaudRate = CBR_19200; break;
+#endif
+#ifdef CBR_28800
+  case 28800: dcbSerialParams.BaudRate = CBR_28800; break;
+#endif
+#ifdef CBR_57600
+  case 57600: dcbSerialParams.BaudRate = CBR_57600; break;
+#endif
+#ifdef CBR_76800
+  case 76800: dcbSerialParams.BaudRate = CBR_76800; break;
+#endif
+#ifdef CBR_38400
+  case 38400: dcbSerialParams.BaudRate = CBR_38400; break;
+#endif
+#ifdef CBR_115200
+  case 115200: dcbSerialParams.BaudRate = CBR_115200; break;
+#endif
+#ifdef CBR_128000
+  case 128000: dcbSerialParams.BaudRate = CBR_128000; break;
+#endif
+#ifdef CBR_153600
+  case 153600: dcbSerialParams.BaudRate = CBR_153600; break;
+#endif
+#ifdef CBR_230400
+  case 230400: dcbSerialParams.BaudRate = CBR_230400; break;
+#endif
+#ifdef CBR_256000
+  case 256000: dcbSerialParams.BaudRate = CBR_256000; break;
+#endif
+#ifdef CBR_460800
+  case 460800: dcbSerialParams.BaudRate = CBR_460800; break;
+#endif
+#ifdef CBR_921600
+  case 921600: dcbSerialParams.BaudRate = CBR_921600; break;
+#endif
+  default:
+    // Try to blindly assign it
+    dcbSerialParams.BaudRate = baudrate_;
+  }
+
+  // setup char len
+  if (bytesize_ == eightbits)
+    dcbSerialParams.ByteSize = 8;
+  else if (bytesize_ == sevenbits)
+    dcbSerialParams.ByteSize = 7;
+  else if (bytesize_ == sixbits)
+    dcbSerialParams.ByteSize = 6;
+  else if (bytesize_ == fivebits)
+    dcbSerialParams.ByteSize = 5;
+  else
+    throw invalid_argument ("invalid char len");
+
+  // setup stopbits
+  if (stopbits_ == stopbits_one)
+    dcbSerialParams.StopBits = ONESTOPBIT;
+  else if (stopbits_ == stopbits_one_point_five)
+    dcbSerialParams.StopBits = ONE5STOPBITS;
+  else if (stopbits_ == stopbits_two)
+    dcbSerialParams.StopBits = TWOSTOPBITS;
+  else
+    throw invalid_argument ("invalid stop bit");
+
+  // setup parity
+  if (parity_ == parity_none) {
+    dcbSerialParams.Parity = NOPARITY;
+  } else if (parity_ == parity_even) {
+    dcbSerialParams.Parity = EVENPARITY;
+  } else if (parity_ == parity_odd) {
+    dcbSerialParams.Parity = ODDPARITY;
+  } else {
+    throw invalid_argument ("invalid parity");
+  }
+
+  // activate settings
+  if(!SetCommState(fd_, &dcbSerialParams)){
+    THROW (IOException, "Error setting serial port settings.");
+  }
+}
+
+void
+Serial::SerialImpl::close ()
+{
+  if (is_open_ == true) {
+    if (fd_ != INVALID_HANDLE_VALUE) {
+      CloseHandle(fd_);
+      fd_ = INVALID_HANDLE_VALUE;
+    }
+    is_open_ = false;
+  }
+}
+
+bool
+Serial::SerialImpl::isOpen () const
+{
+  return is_open_;
+}
+
+size_t
+Serial::SerialImpl::available ()
+{
+  THROW (IOException, "available is not implemented on Windows.");
+}
+
+size_t
+Serial::SerialImpl::read (uint8_t *buf, size_t size)
+{
+  if (!is_open_) {
+    throw PortNotOpenedException ("Serial::read");
+  }
+  DWORD bytes_read;
+  if (!ReadFile(fd_, buf, size, &bytes_read, NULL)) {
+    stringstream ss;
+    ss << "Error while reading from the serial port: " << GetLastError();
+    THROW (IOException, ss.str().c_str());
+  }
+  return reinterpret_cast<size_t> (bytes_read);
+}
+
+size_t
+Serial::SerialImpl::write (const uint8_t *data, size_t length)
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::write");
+  }
+  DWORD bytes_written;
+  if (!ReadFile(fd_, buf, size, &bytes_written, NULL)) {
+    stringstream ss;
+    ss << "Error while writing to the serial port: " << GetLastError();
+    THROW (IOException, ss.str().c_str());
+  }
+  return reinterpret_cast<size_t> (bytes_written);
+}
+
+void
+Serial::SerialImpl::setPort (const string &port)
+{
+  port_ = port;
+}
+
+string
+Serial::SerialImpl::getPort () const
+{
+  return port_;
+}
+
+void
+Serial::SerialImpl::setTimeout (serial::Timeout &timeout)
+{
+  timeout_ = timeout;
+  COMMTIMEOUTS timeouts = {0};
+  timeouts.ReadIntervalTimeout = timeout_.inter_byte_timeout;
+  timeouts.ReadTotalTimeoutConstant = timeout_.read_timeout_constant;
+  timeouts.ReadTotalTimeoutMultiplier = timeout_.read_timeout_multiplier;
+  timeouts.WriteTotalTimeoutConstant = timeout_.write_timeout_constant;
+  timeouts.WriteTotalTimeoutMultiplier = timeout_.write_timeout_multiplier;
+  if(!SetCommTimeouts(fd_, &timeouts)){
+    THROW (IOException, "Error setting timeouts.");
+  }
+}
+
+serial::Timeout
+Serial::SerialImpl::getTimeout () const
+{
+  return timeout_;
+}
+
+void
+Serial::SerialImpl::setBaudrate (unsigned long baudrate)
+{
+  baudrate_ = baudrate;
+  if (is_open_)
+    reconfigurePort ();
+}
+
+unsigned long
+Serial::SerialImpl::getBaudrate () const
+{
+  return baudrate_;
+}
+
+void
+Serial::SerialImpl::setBytesize (serial::bytesize_t bytesize)
+{
+  bytesize_ = bytesize;
+  if (is_open_)
+    reconfigurePort ();
+}
+
+serial::bytesize_t
+Serial::SerialImpl::getBytesize () const
+{
+  return bytesize_;
+}
+
+void
+Serial::SerialImpl::setParity (serial::parity_t parity)
+{
+  parity_ = parity;
+  if (is_open_)
+    reconfigurePort ();
+}
+
+serial::parity_t
+Serial::SerialImpl::getParity () const
+{
+  return parity_;
+}
+
+void
+Serial::SerialImpl::setStopbits (serial::stopbits_t stopbits)
+{
+  stopbits_ = stopbits;
+  if (is_open_)
+    reconfigurePort ();
+}
+
+serial::stopbits_t
+Serial::SerialImpl::getStopbits () const
+{
+  return stopbits_;
+}
+
+void
+Serial::SerialImpl::setFlowcontrol (serial::flowcontrol_t flowcontrol)
+{
+  flowcontrol_ = flowcontrol;
+  if (is_open_)
+    reconfigurePort ();
+}
+
+serial::flowcontrol_t
+Serial::SerialImpl::getFlowcontrol () const
+{
+  return flowcontrol_;
+}
+
+void
+Serial::SerialImpl::flush ()
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::flush");
+  }
+  FlushFileBuffers (fd_);
+}
+
+void
+Serial::SerialImpl::flushInput ()
+{
+  THROW (IOException, "flushInput is not supported on Windows.");
+}
+
+void
+Serial::SerialImpl::flushOutput ()
+{
+  THROW (IOException, "flushOutput is not supported on Windows.");
+}
+
+void
+Serial::SerialImpl::sendBreak (int duration)
+{
+  THROW (IOException, "sendBreak is not supported on Windows.");
+}
+
+void
+Serial::SerialImpl::setBreak (bool level)
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::setBreak");
+  }
+  if (level) {
+    EscapeCommFunction (fd_, SETBREAK);
+  } else {
+    EscapeCommFunction (fd_, CLRBREAK);
+  }
+}
+
+void
+Serial::SerialImpl::setRTS (bool level)
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::setRTS");
+  }
+  if (level) {
+    EscapeCommFunction (fd_, SETRTS);
+  } else {
+    EscapeCommFunction (fd_, CLRRTS);
+  }
+}
+
+void
+Serial::SerialImpl::setDTR (bool level)
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::setDTR");
+  }
+  if (level) {
+    EscapeCommFunction (fd_, SETDTR);
+  } else {
+    EscapeCommFunction (fd_, CLRDTR);
+  }
+}
+
+bool
+Serial::SerialImpl::waitForChange ()
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::waitForChange");
+  }
+  DWORD dwCommEvent;
+
+  if (!SetCommMask(fd_, EV_CTS | EV_DSR | EV_RING | EV_RLSD)) {
+    // Error setting communications mask
+    return false;
+  }
+
+  if (!WaitCommEvent(fd_, &dwCommEvent, NULL)) {
+    // An error occurred waiting for the event.
+    return false;
+  } else {
+    // Event has occurred.
+    return true;
+  }
+}
+
+bool
+Serial::SerialImpl::getCTS ()
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::getCTS");
+  }
+  DWORD dwModemStatus;
+  if (!GetCommModemStatus(fd_, &dwModemStatus))
+    // Error in GetCommModemStatus;
+    THROW (IOException, "Error getting the status of the CTS line.");
+
+  return MS_CTS_ON & dwModemStatus;
+}
+
+bool
+Serial::SerialImpl::getDSR ()
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::getDSR");
+  }
+  DWORD dwModemStatus;
+  if (!GetCommModemStatus(fd_, &dwModemStatus))
+    // Error in GetCommModemStatus;
+    THROW (IOException, "Error getting the status of the DSR line.");
+
+  return MS_DSR_ON & dwModemStatus;
+}
+
+bool
+Serial::SerialImpl::getRI()
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::getRI");
+  }
+  DWORD dwModemStatus;
+  if (!GetCommModemStatus(fd_, &dwModemStatus))
+    // Error in GetCommModemStatus;
+    THROW (IOException, "Error getting the status of the DSR line.");
+
+  return MS_RING_ON & dwModemStatus;
+}
+
+bool
+Serial::SerialImpl::getCD()
+{
+  if (is_open_ == false) {
+    throw PortNotOpenedException ("Serial::getCD");
+  }
+  DWORD dwModemStatus;
+  if (!GetCommModemStatus(fd_, &dwModemStatus))
+    // Error in GetCommModemStatus;
+    THROW (IOException, "Error getting the status of the DSR line.");
+
+  return MS_RLSD_ON & dwModemStatus;
+}
+
+void
+Serial::SerialImpl::readLock()
+{
+  if (WaitForSingleObject(read_mutex, INFINITE) != WAIT_OBJECT_0) {
+    THROW (IOException, "Error claiming read mutex.");
+  }
+}
+
+void
+Serial::SerialImpl::readUnlock()
+{
+  if (!ReleaseMutex(read_mutex)) {
+    THROW (IOException, "Error releasing read mutex.");
+  }
+}
+
+void
+Serial::SerialImpl::writeLock()
+{
+  if (WaitForSingleObject(write_mutex, INFINITE) != WAIT_OBJECT_0) {
+    THROW (IOException, "Error claiming write mutex.");
+  }
+}
+
+void
+Serial::SerialImpl::writeUnlock()
+{
+  if (!ReleaseMutex(write_mutex)) {
+    THROW (IOException, "Error releasing write mutex.");
+  }
+}

src/impl/windows.cc

-/* Copyright 2012 William Woodall and John Harrison */
-
-#include "serial/impl/windows.h"
-
-using std::string;
-using std::invalid_argument;
-using serial::Serial;
-using serial::SerialExecption;
-using serial::PortNotOpenedException;
-using serial::IOException;
-
-
-Serial::SerialImpl::SerialImpl (const string &port, unsigned long baudrate,
-                                long timeout, bytesize_t bytesize,
-                                parity_t parity, stopbits_t stopbits,
-                                flowcontrol_t flowcontrol)
-: port_ (port), fd_ (-1), isOpen_ (false), xonxoff_ (true), rtscts_ (false),
-  timeout_ (timeout), baudrate_ (baudrate), parity_ (parity), bytesize_ (bytesize),
-  stopbits_ (stopbits), flowcontrol_ (flowcontrol)
-{
-  if (port_.empty () == false)
-    open ();
-}
-
-Serial::SerialImpl::~SerialImpl ()
-{
-  close();
-}
-
-void
-Serial::SerialImpl::open ()
-{
-  if (port_.empty())
-  {
-    throw invalid_argument ("bad port specified");
-  }
-  if (isOpen_ == true)
-  {
-    throw SerialExecption ("port already open");
-  }
-
-  fd_ = ::open (port_.c_str(), O_RDWR | O_NOCTTY | O_NONBLOCK);
-
-  if (fd_ == -1)
-  {
-    switch (errno)
-    {
-      case EINTR:
-        // Recurse because this is a recoverable error.
-        open ();
-        return;
-      case ENFILE:
-      case EMFILE:
-        throw IOException ("to many file handles open");
-        break;
-      default:
-        throw IOException (errno);
-    }
-  }
-
-  reconfigurePort();
-  isOpen_ = true;
-}
-
-void
-Serial::SerialImpl::reconfigurePort ()
-{
-  if (fd_ == -1)
-  {
-    // Can only operate on a valid file descriptor
-    throw IOException ("invalid file descriptor");
-  }
-
-  struct termios options; // The options for the file descriptor
-
-  if (tcgetattr(fd_, &options) == -1)
-  {
-    throw IOException ("::tcgetattr");
-  }
-
-  // set up raw mode / no echo / binary
-  options.c_cflag |= (unsigned long)  (CLOCAL|CREAD);
-  options.c_lflag &= (unsigned long) ~(ICANON|ECHO|ECHOE|ECHOK|ECHONL|
-                                       ISIG|IEXTEN); //|ECHOPRT
-
-  options.c_oflag &= (unsigned long) ~(OPOST);
-  options.c_iflag &= (unsigned long) ~(INLCR|IGNCR|ICRNL|IGNBRK);
-#ifdef IUCLC
-  options.c_iflag &= (unsigned long) ~IUCLC;
-#endif
-#ifdef PARMRK
-  options.c_iflag &= (unsigned long) ~PARMRK;
-#endif
-
-  // setup baud rate
-  bool custom_baud = false;
-  speed_t baud;
-  switch (baudrate_)
-  {
-#ifdef B0
-    case 0: baud = B0; break;
-#endif
-#ifdef B50
-    case 50: baud = B50; break;
-#endif
-#ifdef B75
-    case 75: baud = B75; break;
-#endif
-#ifdef B110
-    case 110: baud = B110; break;
-#endif
-#ifdef B134
-    case 134: baud = B134; break;
-#endif
-#ifdef B150
-    case 150: baud = B150; break;
-#endif
-#ifdef B200
-    case 200: baud = B200; break;
-#endif
-#ifdef B300
-    case 300: baud = B300; break;
-#endif
-#ifdef B600
-    case 600: baud = B600; break;
-#endif
-#ifdef B1200
-    case 1200: baud = B1200; break;
-#endif
-#ifdef B1800
-    case 1800: baud = B1800; break;
-#endif
-#ifdef B2400
-    case 2400: baud = B2400; break;
-#endif
-#ifdef B4800
-    case 4800: baud = B4800; break;
-#endif
-#ifdef B7200
-    case 7200: baud = B7200; break;
-#endif
-#ifdef B9600
-    case 9600: baud = B9600; break;
-#endif
-#ifdef B14400
-    case 14400: baud = B14400; break;
-#endif
-#ifdef B19200
-    case 19200: baud = B19200; break;
-#endif
-#ifdef B28800
-    case 28800: baud = B28800; break;
-#endif
-#ifdef B57600
-    case 57600: baud = B57600; break;
-#endif
-#ifdef B76800
-    case 76800: baud = B76800; break;
-#endif
-#ifdef B38400
-    case 38400: baud = B38400; break;
-#endif
-#ifdef B115200
-    case 115200: baud = B115200; break;
-#endif
-#ifdef B128000
-    case 128000: baud = B128000; break;
-#endif
-#ifdef B153600
-    case 153600: baud = B153600; break;
-#endif
-#ifdef B230400
-    case 230400: baud = B230400; break;
-#endif
-#ifdef B256000
-    case 256000: baud = B256000; break;
-#endif
-#ifdef B460800
-    case 460800: baud = B460800; break;
-#endif
-#ifdef B921600
-    case 921600: baud = B921600; break;
-#endif
-    default:
-      custom_baud = true;
-// Mac OS X 10.x Support
-#if defined(__APPLE__) && defined(__MACH__)
-#define IOSSIOSPEED _IOW('T', 2, speed_t)
-      int new_baud = static_cast<int> (baudrate_);
-      if (ioctl (fd_, IOSSIOSPEED, &new_baud, 1) < 0)
-      {
-        throw IOException (errno);
-      }
-// Linux Support
-#elif defined(__linux__)
-      struct serial_struct ser;
-      ioctl(fd_, TIOCGSERIAL, &ser);
-      // set custom divisor
-      ser.custom_divisor = ser.baud_base / baudrate_;
-      // update flags
-      ser.flags &= ~ASYNC_SPD_MASK;
-      ser.flags |= ASYNC_SPD_CUST;
-
-      if (ioctl(fd_, TIOCSSERIAL, ser) < 0)
-      {
-        throw IOException (errno);
-      }
-#else
-      throw invalid_argument ("OS does not currently support custom bauds");
-#endif
-  }
-  if (custom_baud == false)
-  {
-#ifdef _BSD_SOURCE
-    ::cfsetspeed(&options, baud);
-#else
-    ::cfsetispeed(&options, baud);
-    ::cfsetospeed(&options, baud);
-#endif
-  }
-
-  // setup char len
-  options.c_cflag &= (unsigned long) ~CSIZE;
-  if (bytesize_ == EIGHTBITS)
-      options.c_cflag |= CS8;
-  else if (bytesize_ == SEVENBITS)
-      options.c_cflag |= CS7;
-  else if (bytesize_ == SIXBITS)
-      options.c_cflag |= CS6;
-  else if (bytesize_ == FIVEBITS)
-      options.c_cflag |= CS5;
-  else
-      throw invalid_argument ("invalid char len");
-  // setup stopbits
-  if (stopbits_ == STOPBITS_ONE)
-      options.c_cflag &= (unsigned long) ~(CSTOPB);
-  else if (stopbits_ == STOPBITS_ONE_POINT_FIVE)
-      options.c_cflag |=  (CSTOPB);  // XXX same as TWO.. there is no POSIX support for 1.5
-  else if (stopbits_ == STOPBITS_TWO)
-      options.c_cflag |=  (CSTOPB);
-  else
-      throw invalid_argument ("invalid stop bit");
-  // setup parity
-  options.c_iflag &= (unsigned long) ~(INPCK|ISTRIP);
-  if (parity_ == PARITY_NONE)
-  {
-    options.c_cflag &= (unsigned long) ~(PARENB|PARODD);
-  }
-  else if (parity_ == PARITY_EVEN)
-  {
-    options.c_cflag &= (unsigned long) ~(PARODD);
-    options.c_cflag |=  (PARENB);
-  }
-  else if (parity_ == PARITY_ODD)
-  {
-    options.c_cflag |=  (PARENB|PARODD);
-  }
-  else
-  {
-    throw invalid_argument ("invalid parity");
-  }
-  // setup flow control
-  // xonxoff
-#ifdef IXANY
-  if (xonxoff_)
-    options.c_iflag |=  (IXON|IXOFF); //|IXANY)
-  else
-    options.c_iflag &= (unsigned long) ~(IXON|IXOFF|IXANY);
-#else
-  if (xonxoff_)
-    options.c_iflag |=  (IXON|IXOFF);
-  else
-    options.c_iflag &= (unsigned long) ~(IXON|IXOFF);
-#endif
-  // rtscts
-#ifdef CRTSCTS
-  if (rtscts_)
-    options.c_cflag |=  (CRTSCTS);
-  else
-    options.c_cflag &= (unsigned long) ~(CRTSCTS);
-#elif defined CNEW_RTSCTS
-  if (rtscts_)
-    options.c_cflag |=  (CNEW_RTSCTS);
-  else
-    options.c_cflag &= (unsigned long) ~(CNEW_RTSCTS);
-#else
-#error "OS Support seems wrong."
-#endif
-
-  options.c_cc[VMIN] = 1; // Minimum of 1 character in the buffer
-  options.c_cc[VTIME] = 0; // timeout on waiting for new data
-
-  // activate settings
-  ::tcsetattr (fd_, TCSANOW, &options);
-}
-
-void
-Serial::SerialImpl::close ()
-{
-  if (isOpen_ == true)
-  {
-    if (fd_ != -1)
-    {
-      ::close (fd_); // Ignoring the outcome
-      fd_ = -1;
-    }
-    isOpen_ = false;
-  }
-}
-
-bool
-Serial::SerialImpl::isOpen () const
-{
-  return isOpen_;
-}
-
-size_t
-Serial::SerialImpl::available ()
-{
-  if (!isOpen_)
-  {
-    return 0;
-  }
-  int count = 0;
-  int result = ioctl (fd_, TIOCINQ, &count);
-  if (result == 0)
-  {
-    return static_cast<size_t> (count);
-  }
-  else
-  {
-    throw IOException (errno);
-  }
-}
-
-size_t
-Serial::SerialImpl::read (char* buf, size_t size)
-{
-  if (!isOpen_)
-  {
-    throw PortNotOpenedException ("Serial::read");
-  }
-  fd_set readfds;
-  ssize_t bytes_read = 0;
-  int count = 0;
-  while (true)
-  {
-    count++;
-    if (timeout_ != -1)
-    {
-      FD_ZERO (&readfds);
-      FD_SET (fd_, &readfds);
-      struct timeval timeout;
-      timeout.tv_sec =                    timeout_ / 1000;
-      timeout.tv_usec = static_cast<int> (timeout_ % 1000) * 1000;
-      int r = select (fd_ + 1, &readfds, NULL, NULL, &timeout);
-
-      if (r == -1 && errno == EINTR)
-        continue;
-
-      if (r == -1)
-      {
-        throw IOException (errno);
-      }
-    }
-
-    if (timeout_ == -1 || FD_ISSET (fd_, &readfds))
-    {
-      bytes_read = ::read (fd_, buf, size);
-      // read should always return some data as select reported it was
-      // ready to read when we get to this point.
-      if (bytes_read < 1)
-      {
-        // Disconnected devices, at least on Linux, show the
-        // behavior that they are always ready to read immediately
-        // but reading returns nothing.
-        throw SerialExecption ("device reports readiness to read but "
-                               "returned no data (device disconnected?)");
-      }
-      break;
-    }
-    else
-    {
-      break;
-    }
-  }
-  return static_cast<size_t> (bytes_read);
-}
-
-size_t
-Serial::SerialImpl::write (const string &data)
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::write");
-  }
-  
-  fd_set writefds;
-  ssize_t bytes_written = 0;
-  while (true)
-  {
-    if (timeout_ != -1)
-    {
-      FD_ZERO (&writefds);
-      FD_SET (fd_, &writefds);
-      struct timeval timeout;
-      timeout.tv_sec =                    timeout_ / 1000;
-      timeout.tv_usec = static_cast<int> (timeout_ % 1000) * 1000;
-      int r = select (fd_ + 1, NULL, &writefds, NULL, &timeout);
-
-      if (r == -1 && errno == EINTR)
-        continue;
-
-      if (r == -1)
-      {
-        throw IOException (errno);
-      }
-    }
-
-    if (timeout_ == -1 || FD_ISSET (fd_, &writefds))
-    {
-      bytes_written = ::write (fd_, data.c_str (), data.length ());
-      // read should always return some data as select reported it was
-      // ready to read when we get to this point.
-      if (bytes_written < 1)
-      {
-        // Disconnected devices, at least on Linux, show the
-        // behavior that they are always ready to read immediately
-        // but reading returns nothing.
-        throw SerialExecption ("device reports readiness to read but "
-                               "returned no data (device disconnected?)");
-      }
-      break;
-    }
-    else
-    {
-      break;
-    }
-  }
-
-  return static_cast<size_t> (bytes_written);
-}
-
-void
-Serial::SerialImpl::setPort (const string &port)
-{
-  port_ = port;
-}
-
-string
-Serial::SerialImpl::getPort () const
-{
-  return port_;
-}
-
-void
-Serial::SerialImpl::setTimeout (long timeout)
-{
-  timeout_ = timeout;
-}
-
-long
-Serial::SerialImpl::getTimeout () const
-{
-  return timeout_;
-}
-
-void
-Serial::SerialImpl::setBaudrate (unsigned long baudrate)
-{
-  baudrate_ = baudrate;
-  if (isOpen_)
-    reconfigurePort ();
-}
-
-unsigned long
-Serial::SerialImpl::getBaudrate () const
-{
-  return baudrate_;
-}
-
-void
-Serial::SerialImpl::setBytesize (serial::bytesize_t bytesize)
-{
-  bytesize_ = bytesize;
-  if (isOpen_)
-    reconfigurePort ();
-}
-
-serial::bytesize_t
-Serial::SerialImpl::getBytesize () const
-{
-  return bytesize_;
-}
-
-void
-Serial::SerialImpl::setParity (serial::parity_t parity)
-{
-  parity_ = parity;
-  if (isOpen_)
-    reconfigurePort ();
-}
-
-serial::parity_t
-Serial::SerialImpl::getParity () const
-{
-  return parity_;
-}
-
-void
-Serial::SerialImpl::setStopbits (serial::stopbits_t stopbits)
-{
-  stopbits_ = stopbits;
-  if (isOpen_)
-    reconfigurePort ();
-}
-
-serial::stopbits_t
-Serial::SerialImpl::getStopbits () const
-{
-  return stopbits_;
-}
-
-void
-Serial::SerialImpl::setFlowcontrol (serial::flowcontrol_t flowcontrol)
-{
-  flowcontrol_ = flowcontrol;
-  if (isOpen_)
-    reconfigurePort ();
-}
-
-serial::flowcontrol_t
-Serial::SerialImpl::getFlowcontrol () const
-{
-  return flowcontrol_;
-}
-
-void
-Serial::SerialImpl::flush ()
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::flush");
-  }
-  tcdrain (fd_);
-}
-
-void
-Serial::SerialImpl::flushInput ()
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::flushInput");
-  }
-  tcflush (fd_, TCIFLUSH);
-}
-
-void
-Serial::SerialImpl::flushOutput ()
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::flushOutput");
-  }
-  tcflush (fd_, TCOFLUSH);
-}
-
-void
-Serial::SerialImpl::sendBreak (int duration)
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::sendBreak");
-  }
-  tcsendbreak (fd_, static_cast<int> (duration/4));
-}
-
-void
-Serial::SerialImpl::setBreak (bool level)
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::setBreak");
-  }
-  if (level)
-  {
-    ioctl (fd_, TIOCSBRK);
-  }
-  else {
-    ioctl (fd_, TIOCCBRK);
-  }
-}
-
-void
-Serial::SerialImpl::setRTS (bool level)
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::setRTS");
-  }
-  if (level)
-  {
-    ioctl (fd_, TIOCMBIS, TIOCM_RTS);
-  }
-  else {
-    ioctl (fd_, TIOCMBIC, TIOCM_RTS);
-  }
-}
-
-void
-Serial::SerialImpl::setDTR (bool level)
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::setDTR");
-  }
-  if (level)
-  {
-    ioctl (fd_, TIOCMBIS, TIOCM_DTR);
-  }
-  else
-  {
-    ioctl (fd_, TIOCMBIC, TIOCM_DTR);
-  }
-}
-
-bool
-Serial::SerialImpl::getCTS ()
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::getCTS");
-  }
-  int s = ioctl (fd_, TIOCMGET, 0);
-  return (s & TIOCM_CTS) != 0;
-}
-
-bool
-Serial::SerialImpl::getDSR()
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::getDSR");
-  }
-  int s = ioctl(fd_, TIOCMGET, 0);
-  return (s & TIOCM_DSR) != 0;
-}
-
-bool
-Serial::SerialImpl::getRI()
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::getRI");
-  }
-  int s = ioctl (fd_, TIOCMGET, 0);
-  return (s & TIOCM_RI) != 0;
-}
-
-bool
-Serial::SerialImpl::getCD()
-{
-  if (isOpen_ == false)
-  {
-    throw PortNotOpenedException ("Serial::getCD");
-  }
-  int s = ioctl (fd_, TIOCMGET, 0);
-  return (s & TIOCM_CD) != 0;
-}
-

src/serial.cc

@@ -33,6 +33,11 @@ public:
     this->pimpl_->readUnlock();
   }
 private:
+  // Disable copy constructors
+  ScopedReadLock(const ScopedReadLock&);
+  void operator=(const ScopedReadLock&);
+  const ScopedReadLock& operator=(ScopedReadLock);
+
   SerialImpl *pimpl_;
 };
 
@@ -45,16 +50,20 @@ public:
     this->pimpl_->writeUnlock();
   }
 private:
+  // Disable copy constructors
+  ScopedWriteLock(const ScopedWriteLock&);
+  void operator=(const ScopedWriteLock&);
+  const ScopedWriteLock& operator=(ScopedWriteLock);
   SerialImpl *pimpl_;
 };
 
-Serial::Serial (const string &port, unsigned long baudrate, long timeout,
+Serial::Serial (const string &port, uint32_t baudrate, Timeout timeout,
                 bytesize_t bytesize, parity_t parity, stopbits_t stopbits,
                 flowcontrol_t flowcontrol)
- : read_cache_("")
+ : read_cache_(""), pimpl_(new SerialImpl (port, baudrate, bytesize, parity,
+                                           stopbits, flowcontrol))
 {
-  pimpl_ = new SerialImpl (port, baudrate, timeout, bytesize, parity,
-                           stopbits, flowcontrol);
+  pimpl_->setTimeout(timeout);
 }
 
 Serial::~Serial ()
@@ -87,23 +96,23 @@ Serial::available ()
 }
 
 size_t
-Serial::read_ (unsigned char *buffer, size_t size)
+Serial::read_ (uint8_t *buffer, size_t size)
 {
   return this->pimpl_->read (buffer, size);
 }
 
 size_t
-Serial::read (unsigned char *buffer, size_t size)
+Serial::read (uint8_t *buffer, size_t size)
 {
   ScopedReadLock (this->pimpl_);
   return this->pimpl_->read (buffer, size);
 }
 
 size_t
-Serial::read (std::vector<unsigned char> &buffer, size_t size)
+Serial::read (std::vector<uint8_t> &buffer, size_t size)
 {
   ScopedReadLock (this->pimpl_);
-  unsigned char *buffer_ = new unsigned char[size];
+  uint8_t *buffer_ = new uint8_t[size];
   size_t bytes_read = this->pimpl_->read (buffer_, size);
   buffer.insert (buffer.end (), buffer_, buffer_+bytes_read);
   delete[] buffer_;
@@ -114,7 +123,7 @@ size_t
 Serial::read (std::string &buffer, size_t size)
 {
   ScopedReadLock (this->pimpl_);
-  unsigned char *buffer_ = new unsigned char[size];
+  uint8_t *buffer_ = new uint8_t[size];
   size_t bytes_read = this->pimpl_->read (buffer_, size);
   buffer.append (reinterpret_cast<const char*>(buffer_), bytes_read);
   delete[] buffer_;
@@ -134,8 +143,8 @@ Serial::readline (string &buffer, size_t size, string eol)
 {
   ScopedReadLock (this->pimpl_);
   size_t eol_len = eol.length ();
-  unsigned char *buffer_ = static_cast<unsigned char*>
-                              (alloca (size * sizeof (unsigned char)));
+  uint8_t *buffer_ = static_cast<uint8_t*>
+                              (alloca (size * sizeof (uint8_t)));
   size_t read_so_far = 0;
   while (true)
   {
@@ -170,8 +179,8 @@ Serial::readlines (size_t size, string eol)
   ScopedReadLock (this->pimpl_);
   std::vector<std::string> lines;
   size_t eol_len = eol.length ();
-  unsigned char *buffer_ = static_cast<unsigned char*>
-    (alloca (size * sizeof (unsigned char)));
+  uint8_t *buffer_ = static_cast<uint8_t*>
+    (alloca (size * sizeof (uint8_t)));
   size_t read_so_far = 0;
   size_t start_of_line = 0;
   while (read_so_far < size) {
@@ -209,7 +218,28 @@ size_t
 Serial::write (const string &data)
 {
   ScopedWriteLock(this->pimpl_);
-  return pimpl_->write (data);
+  return this->write_ (reinterpret_cast<const uint8_t*>(data.c_str()),
+                       data.length());
+}
+
+size_t
+Serial::write (const std::vector<uint8_t> &data)
+{
+  ScopedWriteLock(this->pimpl_);
+  return this->write_ (&data[0], data.size());
+}
+
+size_t
+Serial::write (const uint8_t *data, size_t size)
+{
+  ScopedWriteLock(this->pimpl_);
+  return this->write_(data, size);
+}
+
+size_t
+Serial::write_ (const uint8_t *data, size_t length)
+{
+  return pimpl_->write (data, length);
 }
 
 void
@@ -230,26 +260,26 @@ Serial::getPort () const
 }
 
 void
-Serial::setTimeout (long timeout)
+Serial::setTimeout (serial::Timeout &timeout)
 {
   pimpl_->setTimeout (timeout);
 }
 
-long
+serial::Timeout
 Serial::getTimeout () const {
   return pimpl_->getTimeout ();
 }
 
 void
-Serial::setBaudrate (unsigned long baudrate)
+Serial::setBaudrate (uint32_t baudrate)
 {
   pimpl_->setBaudrate (baudrate);
 }
 
-unsigned long
+uint32_t
 Serial::getBaudrate () const
 {
-  return pimpl_->getBaudrate ();
+  return uint32_t(pimpl_->getBaudrate ());
 }
 
 void
@@ -341,6 +371,11 @@ void Serial::setDTR (bool level)
   pimpl_->setDTR (level);
 }
 
+bool Serial::waitForChange()
+{
+  return pimpl_->waitForChange();
+}
+
 bool Serial::getCTS ()
 {
   return pimpl_->getCTS ();