serial and logging changes

crazyflie_groundstation/Makefile

@@ -19,14 +19,21 @@ STRUCTURE := $(shell find $(SRC_DIR) -type d)
 ALL_FILES := $(addsuffix /*,$(STRUCTURE))
 ALL_FILES := $(wildcard $(ALL_FILES))
 SRC_FILES := $(filter %.cpp,$(ALL_FILES))
+SRC_FILES += $(filter %.cc,$(ALL_FILES))
 
 
 all:
 	$(g++) -I$(INC_DIR) $(FLAGS) -o $(EXE_NAME) $(SRC_FILES) $(LIBS)
-
 clean: 
 	rm -f *.o $(EXE_NAME)
 	rm -f test_connection
 
 test:
 	gcc -g -o test_connection test_connection.c
+
+serial:
+	cd src/serial && make
+
+serial_clean:
+	cd serial && make clean
+

crazyflie_groundstation/inc/CCrazyRadio.h

@@ -93,7 +93,7 @@ private:
   bool claimInterface(int nInterface);
   void closeDevice();
 
-  CCRTPPacket *readACK();
+ 
 
   CCRTPPacket *writeData(void *vdData, int nLength);
   bool writeControl(void *vdData, int nLength, uint8_t u8Request, uint16_t u16Value, uint16_t u16Index);
@@ -111,6 +111,8 @@ public:
    */
   void addCrazyflie(CCrazyflie *flie);
 
+   CCRTPPacket *readACK();
+
   /**
    * Main loop for the thread running the radio
    */

crazyflie_groundstation/inc/CCrazyflie.h

@@ -49,7 +49,7 @@
 #include "CCrazyRadio.h"
 #include "computations/NetworkForwarding.h"
 #include "CTOC.h"
-
+#include "serial/serial.h"
 #include "vrpn_Connection.h"
 #include "vrpn_Tracker.h"
 
@@ -142,6 +142,7 @@ class CCrazyflie {
   int m_quadNum;
   int m_nRadioChannel;
   XferRate m_radioDataRate;
+  std::string logfilename;
 
   int m_nAckMissTolerance;
   int m_nAckMissCounter;
@@ -202,6 +203,7 @@ class CCrazyflie {
   // Last time a position packet was received
   double lastPositionTime;
   double positionTimeDelta;
+  double testStandData;
 
   // File stream for the console output and log file
   std::ofstream file_console;
@@ -237,7 +239,6 @@ class CCrazyflie {
   double m_dSendSetpointPeriod;
   double m_dSetpointLastSent;
   
-  CTOC *m_tocLogs;
   enum State m_enumState;
 
   // Flags to say whether to send packets
@@ -248,6 +249,8 @@ class CCrazyflie {
   bool readTOCParameters();
   bool readTOCLogs();
 
+  serial::Serial * test_stand;
+
   /*! \brief Send a set point to the copter controller
 
     Send the set point for the internal copter controllers. The
@@ -290,6 +293,8 @@ class CCrazyflie {
     with. */
     lateralPosition m_currentLocalPosition;
     CTOC *m_tocParameters;
+    CTOC *m_tocLogs;
+    int testStandError = 0;
 
   CCrazyflie(CCrazyRadio *crRadio, int radioChannel, XferRate dataRate, int quadNum, double startTime);
   /*! \brief Destructor for the copter convenience class
@@ -307,6 +312,16 @@ class CCrazyflie {
    * @param baseFileName The base filename for the logfile
    */
   void openLogFile(char *baseFileName);
+
+  bool loadLoggingBlocksFromFile(std::string blockFileName);
+
+  bool resetLoggingBlocks();
+
+  bool setTestStand(serial::Serial* ptr);
+
+  bool enableLogging(std::string strBlockName);
+
+  bool disableLogging(std::string strBlockName);
   
   /*
    * Write data to the log file
@@ -322,6 +337,8 @@ class CCrazyflie {
 
   int getQuadcopterNumber();
 
+  std::string getlogfile();
+
   /*
    * Callback called whenever there is a new VRPN position packet.
    * Note: This function is static in the class.
@@ -554,6 +571,8 @@ class CCrazyflie {
     copter. */
   double batteryLevel();
 
+  double readTestStand();
+
   float batteryState();
 
   enum State getCurrentState();

crazyflie_groundstation/inc/CTOC.h

@@ -84,6 +84,8 @@ class CTOC {
   std::list<struct LoggingBlock> m_lstLoggingBlocks;
   std::ofstream param_toc_file;
   std::ofstream log_toc_file;
+  std::string paramfilename;
+  std::string logidfilename;
 
   bool requestInitialItem();
   bool requestItem(int nID, bool bInitial);
@@ -124,6 +126,7 @@ class CTOC {
   double doubleValue(std::string strName);
 
   bool enableLogging(std::string strBlockName);
+  bool disableLogging(std::string strBlockName);
 
 //  void processPackets(std::list<CCRTPPacket*> lstPackets);
   void processPackets(CCRTPPacket *crtpPacket);
@@ -135,6 +138,8 @@ class CTOC {
 
   void openLogTOCFile(char *baseFileName);
   void openParamTOCFile(char *baseFileName);
+  std::string getLogTOCFile();
+  std::string getParamTOCFile();
 };
 
 

crazyflie_groundstation/inc/serial/impl/unix.h

+/*!
+ * \file serial/impl/unix.h
+ * \author  William Woodall <wjwwood@gmail.com>
+ * \author  John Harrison <ash@greaterthaninfinity.com>
+ * \version 0.1
+ *
+ * \section LICENSE
+ *
+ * The MIT License
+ *
+ * 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"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * 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
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * \section DESCRIPTION
+ *
+ * This provides a unix based pimpl for the Serial class. This implementation is
+ * based off termios.h and uses select for multiplexing the IO ports.
+ *
+ */
+
+#if !defined(_WIN32)
+
+#ifndef SERIAL_IMPL_UNIX_H
+#define SERIAL_IMPL_UNIX_H
+
+#include "serial/serial.h"
+
+#include <pthread.h>
+
+namespace serial {
+
+using std::size_t;
+using std::string;
+using std::invalid_argument;
+
+using serial::SerialException;
+using serial::IOException;
+
+class MillisecondTimer {
+public:
+  MillisecondTimer(const uint32_t millis);         
+  int64_t remaining();
+
+private:
+  static timespec timespec_now();
+  timespec expiry;
+};
+
+class serial::Serial::SerialImpl {
+public:
+  SerialImpl (const string &port,
+              unsigned long baudrate,
+              bytesize_t bytesize,
+              parity_t parity,
+              stopbits_t stopbits,
+              flowcontrol_t flowcontrol);
+
+  virtual ~SerialImpl ();
+
+  void
+  open ();
+
+  void
+  close ();
+
+  bool
+  isOpen () const;
+
+  size_t
+  available ();
+
+  bool
+  waitReadable (uint32_t timeout);
+
+  void
+  waitByteTimes (size_t count);
+
+  size_t
+  read (uint8_t *buf, size_t size = 1);
+
+  size_t
+  write (const uint8_t *data, size_t length);
+
+  void
+  flush ();
+
+  void
+  flushInput ();
+
+  void
+  flushOutput ();
+
+  void
+  sendBreak (int duration);
+
+  void
+  setBreak (bool level);
+
+  void
+  setRTS (bool level);
+
+  void
+  setDTR (bool level);
+
+  bool
+  waitForChange ();
+
+  bool
+  getCTS ();
+
+  bool
+  getDSR ();
+
+  bool
+  getRI ();
+
+  bool
+  getCD ();
+
+  void
+  setPort (const string &port);
+
+  string
+  getPort () const;
+
+  void
+  setTimeout (Timeout &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
+  readLock ();
+
+  void
+  readUnlock ();
+
+  void
+  writeLock ();
+
+  void
+  writeUnlock ();
+
+protected:
+  void reconfigurePort ();
+
+private:
+  string port_;               // Path to the file descriptor
+  int fd_;                    // The current file descriptor
+
+  bool is_open_;
+  bool xonxoff_;
+  bool rtscts_;
+
+  Timeout timeout_;           // Timeout for read operations
+  unsigned long baudrate_;    // Baudrate
+  uint32_t byte_time_ns_;     // Nanoseconds to transmit/receive a single byte
+
+  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
+  pthread_mutex_t read_mutex;
+  // Mutex used to lock the write functions
+  pthread_mutex_t write_mutex;
+};
+
+}
+
+#endif // SERIAL_IMPL_UNIX_H
+
+#endif // !defined(_WIN32)

crazyflie_groundstation/inc/serial/impl/win.h

+/*!
+ * \file serial/impl/windows.h
+ * \author  William Woodall <wjwwood@gmail.com>
+ * \author  John Harrison <ash@greaterthaninfinity.com>
+ * \version 0.1
+ *
+ * \section LICENSE
+ *
+ * The MIT License
+ *
+ * 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"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * 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
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * \section DESCRIPTION
+ *
+ * This provides a windows implementation of the Serial class interface.
+ *
+ */
+
+#if defined(_WIN32)
+
+#ifndef SERIAL_IMPL_WINDOWS_H
+#define SERIAL_IMPL_WINDOWS_H
+
+#include "serial/serial.h"
+
+#include "windows.h"
+
+namespace serial {
+
+using std::string;
+using std::wstring;
+using std::invalid_argument;
+
+using serial::SerialException;
+using serial::IOException;
+
+class serial::Serial::SerialImpl {
+public:
+  SerialImpl (const string &port,
+              unsigned long baudrate,
+              bytesize_t bytesize,
+              parity_t parity,
+              stopbits_t stopbits,
+              flowcontrol_t flowcontrol);
+
+  virtual ~SerialImpl ();
+
+  void
+  open ();
+
+  void
+  close ();
+
+  bool
+  isOpen () const;
+
+  size_t
+  available ();
+  
+  bool
+  waitReadable (uint32_t timeout);
+
+  void
+  waitByteTimes (size_t count);
+
+  size_t
+  read (uint8_t *buf, size_t size = 1);
+
+  size_t
+  write (const uint8_t *data, size_t length);
+
+  void
+  flush ();
+
+  void
+  flushInput ();
+
+  void
+  flushOutput ();
+
+  void
+  sendBreak (int duration);
+
+  void
+  setBreak (bool level);
+
+  void
+  setRTS (bool level);
+
+  void
+  setDTR (bool level);
+
+  bool
+  waitForChange ();
+
+  bool
+  getCTS ();
+
+  bool
+  getDSR ();
+
+  bool
+  getRI ();
+
+  bool
+  getCD ();
+
+  void
+  setPort (const string &port);
+
+  string
+  getPort () const;
+
+  void
+  setTimeout (Timeout &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
+  readLock ();
+
+  void
+  readUnlock ();
+
+  void
+  writeLock ();
+
+  void
+  writeUnlock ();
+
+protected:
+  void reconfigurePort ();
+
+private:
+  wstring port_;               // Path to the file descriptor
+  HANDLE fd_;
+
+  bool is_open_;
+
+  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;
+};
+
+}
+
+#endif // SERIAL_IMPL_WINDOWS_H
+
+#endif // if defined(_WIN32)

crazyflie_groundstation/inc/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_

crazyflie_groundstation/inc/userInput.h

@@ -22,6 +22,8 @@ enum commandType {
 	ACMD_GETPARAM = 0x08,
 	ACMD_SETPARAM = 0x07,
 	ACMD_SETPOINT = 0x13,
+	ACMD_GETLOGFILE = 0x15,
+	ACMD_LOGBLOCKCOMMAND = 0x17,
 };
 
 struct metadata {
@@ -33,8 +35,8 @@ struct metadata {
 
 struct command {
 	enum commandType type;
-	struct metadata* meta;
-	uint8_t* data;
+	struct metadata meta;
+	uint8_t data[50];
 };
 
 extern const std::string CLEAR;    // When sent to cout, this clears the terminal screen

crazyflie_groundstation/loggingBlocks.txt

+START BLOCK
+0
+gyro
+100
+gyro.x
+gyro.y
+gyro.z
+END BLOCK
+
+START BLOCK
+1
+acc
+100
+acc.x
+acc.y
+acc.z
+END BLOCK
+
+START BLOCK
+2
+stabilizer
+100
+stabilizer.roll
+stabilizer.pitch
+stabilizer.yaw
+END BLOCK
+
+START BLOCK
+3
+pwm
+100
+pwm.m1_pwm
+pwm.m2_pwm
+pwm.m3_pwm
+END BLOCK
\ No newline at end of file

crazyflie_groundstation/serial/CHANGELOG.rst

+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Changelog for package serial
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+1.2.1 (2015-04-21)
+------------------
+* Removed the use of a C++11 feature for compatibility with older browsers.
+* Fixed an issue with cross compiling with mingw on Windows.
+* Restructured Visual Studio project layout.
+* Added include of ``#include <AvailabilityMacros.h>`` on OS X (listing of ports).
+* Fixed MXE for the listing of ports on Windows.
+* Now closes file device if ``reconfigureDevice`` fails (Windows).
+* Added the MARK/SPACE parity bit option, also made it optional.
+  Adding the enumeration values for MARK and SPACE was the only code change to an API header.
+  It should not affect ABI or API.
+* Added support for 576000 baud on Linux.
+* Now releases iterator properly in listing of ports code for OS X.
+* Fixed the ability to open COM ports over COM10 on Windows.
+* Fixed up some documentation about exceptions in ``serial.h``.
+
+1.2.0 (2014-07-02)
+------------------
+* Removed vestigial ``read_cache_`` private member variable from Serial::Serial
+* Fixed usage of scoped locks
+  Previously they were getting destroyed immediately because they were not stored in a temporary scope variable
+* Added check of return value from close in Serial::SerialImpl::close () in unix.cc and win.cc
+* Added ability to enumerate ports on linux and windows.
+  Updated serial_example.cc to show example of port enumeration.
+* Fixed compile on VS2013
+* Added functions ``waitReadable`` and ``waitByteTimes`` with implemenations for Unix to support high performance reading
+* Contributors: Christopher Baker, Craig Lilley, Konstantina Kastanara, Mike Purvis, William Woodall
+
+1.1.7 (2014-02-20)
+------------------
+* Improved support for mingw (mxe.cc)
+* Fix compilation warning
+  See issue `#53 <https://github.com/wjwwood/serial/issues/53>`_
+* Improved timer handling in unix implementation
+* fix broken ifdef _WIN32
+* Fix broken ioctl calls, add exception handling.
+* Code guards for platform-specific implementations. (when not using cmake / catkin)
+* Contributors: Christopher Baker, Mike Purvis, Nicolas Bigaouette, William Woodall, dawid
+
+1.1.6 (2013-10-17)
+------------------
+* Move stopbits_one_point_five to the end of the enum, so that it doesn't alias with stopbits_two.
+
+1.1.5 (2013-09-23)
+------------------
+* Fix license labeling, I put BSD, but the license has always been MIT...
+* Added Microsoft Visual Studio 2010 project to make compiling on Windows easier.
+* Implemented Serial::available() for Windows
+* Update how custom baudrates are handled on OS X
+  This is taken from the example serial program on Apple's developer website, see:
+  http://free-pascal-general.1045716.n5.nabble.com/Non-standard-baud-rates-in-OS-X-IOSSIOSPEED-IOCTL-td4699923.html
+* Timout settings are now applied by reconfigurePort
+* Pass LPCWSTR to CreateFile in Windows impl
+* Use wstring for ``port_`` type in Windows impl
+
+1.1.4 (2013-06-12 00:13:18 -0600)
+---------------------------------
+* Timing calculation fix for read and write.
+  Fixes `#27 <https://github.com/wjwwood/serial/issues/27>`_
+* Update list of exceptions thrown from constructor.
+* fix, by Thomas Hoppe <thomas.hoppe@cesys.com>
+  For SerialException's:
+  * The name was misspelled...
+  * Use std::string's for error messages to prevent corruption of messages on some platforms
+* alloca.h does not exist on OpenBSD either.
+
+1.1.3 (2013-01-09 10:54:34 -0800)
+---------------------------------
+* Install headers
+
+1.1.2 (2012-12-14 14:08:55 -0800)
+---------------------------------
+* Fix buildtool depends
+
+1.1.1 (2012-12-03)
+------------------
+* Removed rt linking on OS X. Fixes `#24 <https://github.com/wjwwood/serial/issues/24>`_.
+
+1.1.0 (2012-10-24)
+------------------
+* Previous history is unstructured and therefore has been truncated. See the commit messages for more info.

crazyflie_groundstation/serial/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8.3)
+project(serial)
+
+# Find catkin
+find_package(catkin REQUIRED)
+
+if(APPLE)
+    find_library(IOKIT_LIBRARY IOKit)
+    find_library(FOUNDATION_LIBRARY Foundation)
+endif()
+
+if(UNIX AND NOT APPLE)
+    # If Linux, add rt and pthread
+    set(rt_LIBRARIES rt)
+    set(pthread_LIBRARIES pthread) 
+    catkin_package(
+        LIBRARIES ${PROJECT_NAME}
+        INCLUDE_DIRS include
+        DEPENDS rt pthread
+    )
+else()
+    # Otherwise normal call
+    catkin_package(
+        LIBRARIES ${PROJECT_NAME}
+        INCLUDE_DIRS include
+    )
+endif()
+
+## Sources
+set(serial_SRCS
+    src/serial.cc
+    include/serial/serial.h
+    include/serial/v8stdint.h
+)
+if(APPLE)
+    # If OSX
+    list(APPEND serial_SRCS src/impl/unix.cc)
+    list(APPEND serial_SRCS src/impl/list_ports/list_ports_osx.cc)
+elseif(UNIX)
+    # If unix
+    list(APPEND serial_SRCS src/impl/unix.cc)
+    list(APPEND serial_SRCS src/impl/list_ports/list_ports_linux.cc)
+else()
+    # If windows
+    list(APPEND serial_SRCS src/impl/win.cc)
+    list(APPEND serial_SRCS src/impl/list_ports/list_ports_win.cc)
+endif()
+
+## Add serial library
+add_library(${PROJECT_NAME} ${serial_SRCS})
+if(APPLE)
+    target_link_libraries(${PROJECT_NAME} ${FOUNDATION_LIBRARY} ${IOKIT_LIBRARY})
+elseif(UNIX)
+    target_link_libraries(${PROJECT_NAME} rt pthread)
+else()
+    target_link_libraries(${PROJECT_NAME} setupapi)
+endif()
+
+## Uncomment for example
+add_executable(serial_example examples/serial_example.cc)
+add_dependencies(serial_example ${PROJECT_NAME})
+target_link_libraries(serial_example ${PROJECT_NAME})
+
+## Include headers
+include_directories(include)
+
+## Install executable
+install(TARGETS ${PROJECT_NAME}
+    ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+    LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+    RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
+)
+
+## Install headers
+install(FILES include/serial/serial.h include/serial/v8stdint.h
+  DESTINATION ${CATKIN_GLOBAL_INCLUDE_DESTINATION}/serial)
+
+## Tests
+if(CATKIN_ENABLE_TESTING)
+    add_subdirectory(tests)
+endif()
\ No newline at end of file

crazyflie_groundstation/serial/Makefile

+all: serial
+
+CMAKE_FLAGS := -DCMAKE_INSTALL_PREFIX=/tmp/usr/local
+UNAME := $(shell uname -s)
+
+install_deps:
+ifeq ($(UNAME),Darwin)
+	brew tap ros/deps
+	brew update
+	brew outdated boost || brew upgrade boost || brew install boost
+	brew outdated python || brew upgrade python || brew install python
+	sudo -H python2 -m pip install -U pip setuptools
+	sudo -H python2 -m pip install --force-reinstall --no-deps -U pip
+	sudo -H python2 -m pip install rosinstall_generator wstool rosdep empy catkin_pkg
+	sudo -H rosdep init
+	rosdep update
+	mkdir catkin_ws
+	cd catkin_ws && rosinstall_generator catkin --rosdistro hydro --tar > catkin.rosinstall
+	cd catkin_ws && wstool init src catkin.rosinstall
+	cd catkin_ws && rosdep install --from-paths src --ignore-src -y
+	cd catkin_ws && python2 ./src/catkin/bin/catkin_make -DPYTHON_EXECUTABLE=`which python2` install
+	echo "source catkin_ws/install/setup.bash" > setup.bash
+else
+	sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu precise main" > /etc/apt/sources.list.d/ros-latest.list'
+	wget http://packages.ros.org/ros.key -O - | sudo apt-key add -
+	sudo apt-get update
+	sudo apt-get install ros-hydro-catkin libboost-dev
+	echo "source /opt/ros/hydro/setup.bash" > setup.bash
+endif
+
+install:
+	cd build && make install
+
+serial:
+	@mkdir -p build
+	cd build && cmake $(CMAKE_FLAGS) ..
+ifneq ($(MAKE),)
+	cd build && $(MAKE)
+else
+	cd build && make
+endif
+
+.PHONY: clean
+clean:
+	rm -rf build
+
+.PHONY: doc
+doc:
+	@doxygen doc/Doxyfile
+ifeq ($(UNAME),Darwin)
+	@open doc/html/index.html
+endif
+
+.PHONY: test
+test:
+	@mkdir -p build
+	cd build && cmake $(CMAKE_FLAGS) ..
+ifneq ($(MAKE),)
+	cd build && $(MAKE) run_tests
+else
+	cd build && make run_tests
+endif

crazyflie_groundstation/serial/README.md

+# Serial Communication Library
+
+[![Build Status](https://travis-ci.org/wjwwood/serial.svg?branch=master)](https://travis-ci.org/wjwwood/serial)*(Linux and OS X)* [![Build Status](https://ci.appveyor.com/api/projects/status/github/wjwwood/serial)](https://ci.appveyor.com/project/wjwwood/serial)*(Windows)*
+
+This is a cross-platform library for interfacing with rs-232 serial like ports written in C++. It provides a modern C++ interface with a workflow designed to look and feel like PySerial, but with the speed and control provided by C++. 
+
+This library is in use in several robotics related projects and can be built and installed to the OS like most unix libraries with make and then sudo make install, but because it is a catkin project it can also be built along side other catkin projects in a catkin workspace.
+
+Serial is a class that provides the basic interface common to serial libraries (open, close, read, write, etc..) and requires no extra dependencies. It also provides tight control over timeouts and control over handshaking lines. 
+
+### Documentation
+
+Website: http://wjwwood.github.io/serial/
+
+API Documentation: http://wjwwood.github.io/serial/doc/1.1.0/index.html
+
+### Dependencies
+
+Required:
+* [catkin](http://www.ros.org/wiki/catkin) - cmake and Python based buildsystem
+* [cmake](http://www.cmake.org) - buildsystem
+* [Python](http://www.python.org) - scripting language
+  * [empy](http://www.alcyone.com/pyos/empy/) - Python templating library
+  * [catkin_pkg](http://pypi.python.org/pypi/catkin_pkg/) - Runtime Python library for catkin
+
+Optional (for documentation):
+* [Doxygen](http://www.doxygen.org/) - Documentation generation tool
+* [graphviz](http://www.graphviz.org/) - Graph visualization software
+
+### Install
+
+Get the code:
+
+    git clone https://github.com/wjwwood/serial.git
+
+Build:
+
+    make
+
+Build and run the tests:
+
+    make test
+
+Build the documentation:
+
+    make doc
+
+Install:
+
+    make install
+
+### License
+
+The MIT License
+
+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"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 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 DEALINGS IN THE SOFTWARE.
+
+### Authors
+
+William Woodall <wjwwood@gmail.com>
+John Harrison <ash.gti@gmail.com>
+
+### Contact
+
+William Woodall <william@osrfoundation.org>

crazyflie_groundstation/serial/changes.txt

+# 1.1.0 10-24-2012
+
+* Converted the build system to catkin
+
+# v1.0.1 8-27-2012
+
+* Added baudrates: 1000000, 11520000, 2000000, 2500000, 3000000, 3500000, and 4000000
+* Linking related bug fixes on Linux and OS X
+* Custom baudrate bug fix.  Closes issue #18.
+

crazyflie_groundstation/serial/doc/serial.dox

+/*!
+\mainpage Serial Library
+
+\author William Woodall <wjwwood@gmail.com>, John Harrison <ash@greaterthaninfinity.com>
+
+\section what_is What is serial?
+Serial is a cross-platform, simple to use library for using serial ports on computers.  This library provides a C++, object oriented interface for interacting with RS-232 like devices on Linux and Windows.
+
+Want to use it with ROS(Robot Operating System)? No problem, it compiles as a unary stack.
+
+\section getting_started Getting Started
+
+Ready to jump in?
+- Checkout our examples: \ref serial_example.cc
+- Look at the main class documentation: \ref serial::Serial
+
+\section features Features
+- Linux, Mac OS X, and Windows Support
+- Easy to use interface (modeled after PySerial)
+- Minimal dependencies (cmake)
+- Complete timeout control \ref serial::Serial::setTimeout
+- Check and set handshaking lines (CTS, DSR, RI, CD and RTS, DTR)
+- Block for changes in handshaking lines (Linux and Windows)
+- Flush I/O separately and block until all writing done
+
+\section install Installation
+
+\subsection Dependencies
+
+- CMake:
+ - CMake is required for building the system and can be located here: http://www.cmake.org/
+
+\subsection building Compiling
+
+Once you have gathered the dependencies, you need to checkout the software from github.com: 
+
+<pre>
+    git clone git://github.com/wjwwood/serial.git
+</pre>
+
+Once you have checked out the source code from github.com you can enter the directory and build the software.
+
+<pre>
+    cd serial
+    make
+    make test # (optional) builds the example and tests, and runs the tests.
+    make doc  # (optional) builds _this_ documentation.
+</pre>
+
+\subsection installing Installing
+
+To install simply:
+
+<pre>
+    sudo make install
+</pre>
+
+ */
\ No newline at end of file

crazyflie_groundstation/serial/examples/serial_example.cc

+/***
+ * This example expects the serial port has a loopback on it.
+ *
+ * Alternatively, you could use an Arduino:
+ *
+ * <pre>
+ *  void setup() {
+ *    Serial.begin(<insert your baudrate here>);
+ *  }
+ *
+ *  void loop() {
+ *    if (Serial.available()) {
+ *      Serial.write(Serial.read());
+ *    }
+ *  }
+ * </pre>
+ */
+
+#include <string>
+#include <iostream>
+#include <cstdio>
+
+// OS Specific sleep
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+#include "serial/serial.h"
+
+using std::string;
+using std::exception;
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::vector;
+
+void my_sleep(unsigned long milliseconds) {
+#ifdef _WIN32
+      Sleep(milliseconds); // 100 ms
+#else
+      usleep(milliseconds*1000); // 100 ms
+#endif
+}
+
+void enumerate_ports()
+{
+	vector<serial::PortInfo> devices_found = serial::list_ports();
+
+	vector<serial::PortInfo>::iterator iter = devices_found.begin();
+
+	while( iter != devices_found.end() )
+	{
+		serial::PortInfo device = *iter++;
+
+		printf( "(%s, %s, %s)\n", device.port.c_str(), device.description.c_str(),
+     device.hardware_id.c_str() );
+	}
+}
+
+void print_usage()
+{
+	cerr << "Usage: test_serial {-e|<serial port address>} ";
+    cerr << "<baudrate> [test string]" << endl;
+}
+
+int run(int argc, char **argv)
+{
+  if(argc < 2) {
+	  print_usage();
+    return 0;
+  }
+
+  // Argument 1 is the serial port or enumerate flag
+  string port(argv[1]);
+
+  if( port == "-e" ) {
+	  enumerate_ports();
+	  return 0;
+  }
+  else if( argc < 3 ) {
+	  print_usage();
+	  return 1;
+  }
+
+  // Argument 2 is the baudrate
+  unsigned long baud = 0;
+#if defined(WIN32) && !defined(__MINGW32__)
+  sscanf_s(argv[2], "%lu", &baud);
+#else
+  sscanf(argv[2], "%lu", &baud);
+#endif
+
+  // port, baudrate, timeout in milliseconds
+  serial::Serial my_serial(port, baud, serial::Timeout::simpleTimeout(1000));
+
+  cout << "Is the serial port open?";
+  if(my_serial.isOpen())
+    cout << " Yes." << endl;
+  else
+    cout << " No." << endl;
+
+  // Get the Test string
+  int count = 0;
+  string test_string;
+  if (argc == 4) {
+    test_string = argv[3];
+  } else {
+    test_string = "Testing.";
+  }
+
+  // Test the timeout, there should be 1 second between prints
+  cout << "Timeout == 1000ms, asking for 1 more byte than written." << endl;
+  while (count < 10) {
+    size_t bytes_wrote = my_serial.write(test_string);
+
+    string result = my_serial.read(test_string.length()+1);
+
+    cout << "Iteration: " << count << ", Bytes written: ";
+    cout << bytes_wrote << ", Bytes read: ";
+    cout << result.length() << ", String read: " << result << endl;
+
+    count += 1;
+  }
+
+  // Test the timeout at 250ms
+  my_serial.setTimeout(serial::Timeout::max(), 250, 0, 250, 0);
+  count = 0;
+  cout << "Timeout == 250ms, asking for 1 more byte than written." << endl;
+  while (count < 10) {
+    size_t bytes_wrote = my_serial.write(test_string);
+
+    string result = my_serial.read(test_string.length()+1);
+
+    cout << "Iteration: " << count << ", Bytes written: ";
+    cout << bytes_wrote << ", Bytes read: ";
+    cout << result.length() << ", String read: " << result << endl;
+
+    count += 1;
+  }
+
+  // Test the timeout at 250ms, but asking exactly for what was written
+  count = 0;
+  cout << "Timeout == 250ms, asking for exactly what was written." << endl;
+  while (count < 10) {
+    size_t bytes_wrote = my_serial.write(test_string);
+
+    string result = my_serial.read(test_string.length());
+
+    cout << "Iteration: " << count << ", Bytes written: ";
+    cout << bytes_wrote << ", Bytes read: ";
+    cout << result.length() << ", String read: " << result << endl;
+
+    count += 1;
+  }
+
+  // Test the timeout at 250ms, but asking for 1 less than what was written
+  count = 0;
+  cout << "Timeout == 250ms, asking for 1 less than was written." << endl;
+  while (count < 10) {
+    size_t bytes_wrote = my_serial.write(test_string);
+
+    string result = my_serial.read(test_string.length()-1);
+
+    cout << "Iteration: " << count << ", Bytes written: ";
+    cout << bytes_wrote << ", Bytes read: ";
+    cout << result.length() << ", String read: " << result << endl;
+
+    count += 1;
+  }
+
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  try {
+    return run(argc, argv);
+  } catch (exception &e) {
+    cerr << "Unhandled Exception: " << e.what() << endl;
+  }
+}

crazyflie_groundstation/serial/include/serial/impl/unix.h

+/*!
+ * \file serial/impl/unix.h
+ * \author  William Woodall <wjwwood@gmail.com>
+ * \author  John Harrison <ash@greaterthaninfinity.com>
+ * \version 0.1
+ *
+ * \section LICENSE
+ *
+ * The MIT License
+ *
+ * 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"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * 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
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * \section DESCRIPTION
+ *
+ * This provides a unix based pimpl for the Serial class. This implementation is
+ * based off termios.h and uses select for multiplexing the IO ports.
+ *
+ */
+
+#if !defined(_WIN32)
+
+#ifndef SERIAL_IMPL_UNIX_H
+#define SERIAL_IMPL_UNIX_H
+
+#include "serial/serial.h"
+
+#include <pthread.h>
+
+namespace serial {
+
+using std::size_t;
+using std::string;
+using std::invalid_argument;
+
+using serial::SerialException;
+using serial::IOException;
+
+class MillisecondTimer {
+public:
+  MillisecondTimer(const uint32_t millis);         
+  int64_t remaining();
+
+private:
+  static timespec timespec_now();
+  timespec expiry;
+};
+
+class serial::Serial::SerialImpl {
+public:
+  SerialImpl (const string &port,
+              unsigned long baudrate,
+              bytesize_t bytesize,
+              parity_t parity,
+              stopbits_t stopbits,
+              flowcontrol_t flowcontrol);
+
+  virtual ~SerialImpl ();
+
+  void
+  open ();
+
+  void
+  close ();
+
+  bool
+  isOpen () const;
+
+  size_t
+  available ();
+
+  bool
+  waitReadable (uint32_t timeout);
+
+  void
+  waitByteTimes (size_t count);
+
+  size_t
+  read (uint8_t *buf, size_t size = 1);
+
+  size_t
+  write (const uint8_t *data, size_t length);
+
+  void
+  flush ();
+
+  void
+  flushInput ();
+
+  void
+  flushOutput ();
+
+  void
+  sendBreak (int duration);
+
+  void
+  setBreak (bool level);
+
+  void
+  setRTS (bool level);
+
+  void
+  setDTR (bool level);
+
+  bool
+  waitForChange ();
+
+  bool
+  getCTS ();
+
+  bool
+  getDSR ();
+
+  bool
+  getRI ();
+
+  bool
+  getCD ();
+
+  void
+  setPort (const string &port);
+
+  string
+  getPort () const;
+
+  void
+  setTimeout (Timeout &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
+  readLock ();
+
+  void
+  readUnlock ();
+
+  void
+  writeLock ();
+
+  void
+  writeUnlock ();
+
+protected:
+  void reconfigurePort ();
+
+private:
+  string port_;               // Path to the file descriptor
+  int fd_;                    // The current file descriptor
+
+  bool is_open_;
+  bool xonxoff_;
+  bool rtscts_;
+
+  Timeout timeout_;           // Timeout for read operations
+  unsigned long baudrate_;    // Baudrate
+  uint32_t byte_time_ns_;     // Nanoseconds to transmit/receive a single byte
+
+  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
+  pthread_mutex_t read_mutex;
+  // Mutex used to lock the write functions
+  pthread_mutex_t write_mutex;
+};
+
+}
+
+#endif // SERIAL_IMPL_UNIX_H
+
+#endif // !defined(_WIN32)

crazyflie_groundstation/serial/include/serial/impl/win.h

+/*!
+ * \file serial/impl/windows.h
+ * \author  William Woodall <wjwwood@gmail.com>
+ * \author  John Harrison <ash@greaterthaninfinity.com>
+ * \version 0.1
+ *
+ * \section LICENSE
+ *
+ * The MIT License
+ *
+ * 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"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * 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
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * \section DESCRIPTION
+ *
+ * This provides a windows implementation of the Serial class interface.
+ *
+ */
+
+#if defined(_WIN32)
+
+#ifndef SERIAL_IMPL_WINDOWS_H
+#define SERIAL_IMPL_WINDOWS_H
+
+#include "serial/serial.h"
+
+#include "windows.h"
+
+namespace serial {
+
+using std::string;
+using std::wstring;
+using std::invalid_argument;
+
+using serial::SerialException;
+using serial::IOException;
+
+class serial::Serial::SerialImpl {
+public:
+  SerialImpl (const string &port,
+              unsigned long baudrate,
+              bytesize_t bytesize,
+              parity_t parity,
+              stopbits_t stopbits,
+              flowcontrol_t flowcontrol);
+
+  virtual ~SerialImpl ();
+
+  void
+  open ();
+
+  void
+  close ();
+
+  bool
+  isOpen () const;
+
+  size_t
+  available ();
+  
+  bool
+  waitReadable (uint32_t timeout);
+
+  void
+  waitByteTimes (size_t count);
+
+  size_t
+  read (uint8_t *buf, size_t size = 1);
+
+  size_t
+  write (const uint8_t *data, size_t length);
+
+  void
+  flush ();
+
+  void
+  flushInput ();
+
+  void
+  flushOutput ();
+
+  void
+  sendBreak (int duration);
+
+  void
+  setBreak (bool level);
+
+  void
+  setRTS (bool level);
+
+  void
+  setDTR (bool level);
+
+  bool
+  waitForChange ();
+
+  bool
+  getCTS ();
+
+  bool
+  getDSR ();
+
+  bool
+  getRI ();
+
+  bool
+  getCD ();
+
+  void
+  setPort (const string &port);
+
+  string
+  getPort () const;
+
+  void
+  setTimeout (Timeout &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
+  readLock ();
+
+  void
+  readUnlock ();
+
+  void
+  writeLock ();
+
+  void
+  writeUnlock ();
+
+protected:
+  void reconfigurePort ();
+
+private:
+  wstring port_;               // Path to the file descriptor
+  HANDLE fd_;
+
+  bool is_open_;
+
+  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;
+};
+
+}
+
+#endif // SERIAL_IMPL_WINDOWS_H
+
+#endif // if defined(_WIN32)