updated package structure and more fixes

scout_base/CMakeLists.txt

@@ -4,9 +4,10 @@ project(scout_base)
 ## Compile as C++11, supported in ROS Kinetic and newer
 add_compile_options(-std=c++11)
 
-find_package(catkin REQUIRED COMPONENTS 
-    controller_manager 
-    hardware_interface 
+# cmake module path
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+find_package(catkin REQUIRED COMPONENTS    
     roslaunch 
     roslint 
     roscpp 
@@ -14,8 +15,13 @@ find_package(catkin REQUIRED COMPONENTS
     std_msgs
     geometry_msgs
     scout_msgs
-    tf)
+    scout_sdk
+    tf2 
+    tf2_ros
+)
     
+find_package(LCM REQUIRED)
+
 # find_package(Boost REQUIRED COMPONENTS chrono)
 
 ###################################
@@ -24,8 +30,8 @@ find_package(catkin REQUIRED COMPONENTS
 
 catkin_package(
   INCLUDE_DIRS include
-  LIBRARIES scout_base
-  CATKIN_DEPENDS hardware_interface scout_msgs roscpp sensor_msgs
+  LIBRARIES scout_messenger
+  CATKIN_DEPENDS scout_msgs roscpp sensor_msgs scout_sdk
 #   DEPENDS Boost
 )
 
@@ -38,31 +44,35 @@ catkin_package(
 include_directories(
     include
     ${catkin_INCLUDE_DIRS}
+    ${LCM_INCLUDE_DIRS}
 )
 
-# add scout sdk
-add_subdirectory(src/scout_sdk)
-
 add_library(scout_messenger STATIC src/scout_messenger.cpp)
-target_link_libraries(scout_messenger scoutbase ${catkin_LIBRARIES})
+target_link_libraries(scout_messenger ${catkin_LIBRARIES})
 set_property(TARGET scout_messenger PROPERTY POSITION_INDEPENDENT_CODE ON)
 
 add_executable(scout_base_node src/scout_base_node.cpp)
-target_link_libraries(scout_base_node scoutbase scout_messenger ${catkin_LIBRARIES})
+target_link_libraries(scout_base_node scout_messenger ${catkin_LIBRARIES})
+
+add_executable(imu_broadcast_node src/imu_broadcast_node.cpp)
+target_link_libraries(imu_broadcast_node ${catkin_LIBRARIES} ${LCM_LIBRARIES})
 
 #############
 ## Install ##
 #############
 
-# roslaunch_add_file_check(launch)
+roslaunch_add_file_check(launch)
 
-# install(TARGETS scoutcpp scoutio scout_base
-#   RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
-#   LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
-#   ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION})
+install(TARGETS scout_messenger scout_base_node
+  RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+  LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+  ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION})
 
-# install(DIRECTORY include/${PROJECT_NAME}/
-#   DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION})
+install(DIRECTORY include/${PROJECT_NAME}/
+  DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION})
 
-# install(DIRECTORY launch config
-#   DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION})
+  install(DIRECTORY include/lcmtypes
+  DESTINATION ${CATKIN_GLOBAL_INCLUDE_DESTINATION})
+
+install(DIRECTORY launch urdf
+  DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION})

scout_base/cmake/FindLCM.cmake

@@ -0,0 +1,36 @@
+###############################################################################
+# Find package: lcm
+#
+# This sets the following variables:
+
+# <package>_FOUND
+# <package>_INCLUDE_DIRS
+# <package>_LIBRARIES
+# Source: https://github.com/RobotLocomotion/director/blob/master/cmake/modules/FindLCM.cmake
+
+
+macro(pkg_config_find_module varname pkgname header library pathsuffix)
+
+    find_package(PkgConfig)
+    pkg_check_modules(${varname}_pkgconfig ${pkgname})
+
+    find_path(${varname}_INCLUDE_DIR ${header}
+        HINTS ${${varname}_pkgconfig_INCLUDEDIR}
+        PATH_SUFFIXES ${pathsuffix}
+        DOC "Path to ${pkgname} include directory")
+
+    find_library(${varname}_LIBRARY ${library} HINTS ${${varname}_pkgconfig_LIBDIR} DOC "Path to ${pkgname} library")
+
+    set(${varname}_INCLUDE_DIRS ${${varname}_INCLUDE_DIR})
+    set(${varname}_LIBRARIES ${${varname}_LIBRARY})
+
+    include(FindPackageHandleStandardArgs)
+    find_package_handle_standard_args(${varname} DEFAULT_MSG ${varname}_INCLUDE_DIR ${varname}_LIBRARY)
+
+    mark_as_advanced(${varname}_INCLUDE_DIR)
+    mark_as_advanced(${varname}_LIBRARY)
+
+endmacro()
+
+
+pkg_config_find_module(LCM lcm lcm/lcm.h lcm lcm)

scout_base/include/lcmtypes/wescore.h

@@ -0,0 +1,17 @@
+#ifndef __lcmtypes_wescore_h__
+#define __lcmtypes_wescore_h__
+
+#include "wescore_lcm_msgs_IMU.h"
+#include "wescore_lcm_msgs_NavSatFix.h"
+#include "wescore_lcm_msgs_NavSatStatus.h"
+#include "wescore_lcm_msgs_Quaternion.h"
+#include "wescore_lcm_msgs_RawAccel.h"
+#include "wescore_lcm_msgs_RawGyro.h"
+#include "wescore_lcm_msgs_RawIMU10DOF.h"
+#include "wescore_lcm_msgs_RawIMU6DOF.h"
+#include "wescore_lcm_msgs_RawIMU9DOF.h"
+#include "wescore_lcm_msgs_RawMag.h"
+#include "wescore_lcm_msgs_Vector2.h"
+#include "wescore_lcm_msgs_Vector3.h"
+
+#endif

scout_base/include/lcmtypes/wescore.hpp

@@ -0,0 +1,17 @@
+#ifndef __lcmtypes_wescore_hpp__
+#define __lcmtypes_wescore_hpp__
+
+#include "wescore_lcm_msgs/IMU.hpp"
+#include "wescore_lcm_msgs/NavSatFix.hpp"
+#include "wescore_lcm_msgs/NavSatStatus.hpp"
+#include "wescore_lcm_msgs/Quaternion.hpp"
+#include "wescore_lcm_msgs/RawAccel.hpp"
+#include "wescore_lcm_msgs/RawGyro.hpp"
+#include "wescore_lcm_msgs/RawIMU10DOF.hpp"
+#include "wescore_lcm_msgs/RawIMU6DOF.hpp"
+#include "wescore_lcm_msgs/RawIMU9DOF.hpp"
+#include "wescore_lcm_msgs/RawMag.hpp"
+#include "wescore_lcm_msgs/Vector2.hpp"
+#include "wescore_lcm_msgs/Vector3.hpp"
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/IMU.hpp

@@ -0,0 +1,215 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_IMU_hpp__
+#define __wescore_lcm_msgs_IMU_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+#include "lcmtypes/wescore_lcm_msgs/Quaternion.hpp"
+#include "lcmtypes/wescore_lcm_msgs/Vector3.hpp"
+#include "lcmtypes/wescore_lcm_msgs/Vector3.hpp"
+
+namespace wescore_lcm_msgs
+{
+
+class IMU
+{
+    public:
+        int64_t    mtime;
+
+        wescore_lcm_msgs::Quaternion orientation;
+
+        double     orientation_covariance[9];
+
+        wescore_lcm_msgs::Vector3 angular_velocity;
+
+        double     angular_velocity_covariance[9];
+
+        wescore_lcm_msgs::Vector3 linear_acceleration;
+
+        double     linear_acceleration_covariance[9];
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "IMU"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int IMU::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int IMU::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int IMU::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t IMU::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* IMU::getTypeName()
+{
+    return "IMU";
+}
+
+int IMU::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->orientation._encodeNoHash(buf, offset + pos, maxlen - pos);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->orientation_covariance[0], 9);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->angular_velocity._encodeNoHash(buf, offset + pos, maxlen - pos);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->angular_velocity_covariance[0], 9);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->linear_acceleration._encodeNoHash(buf, offset + pos, maxlen - pos);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->linear_acceleration_covariance[0], 9);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int IMU::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->orientation._decodeNoHash(buf, offset + pos, maxlen - pos);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->orientation_covariance[0], 9);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->angular_velocity._decodeNoHash(buf, offset + pos, maxlen - pos);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->angular_velocity_covariance[0], 9);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->linear_acceleration._decodeNoHash(buf, offset + pos, maxlen - pos);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->linear_acceleration_covariance[0], 9);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int IMU::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __int64_t_encoded_array_size(NULL, 1);
+    enc_size += this->orientation._getEncodedSizeNoHash();
+    enc_size += __double_encoded_array_size(NULL, 9);
+    enc_size += this->angular_velocity._getEncodedSizeNoHash();
+    enc_size += __double_encoded_array_size(NULL, 9);
+    enc_size += this->linear_acceleration._getEncodedSizeNoHash();
+    enc_size += __double_encoded_array_size(NULL, 9);
+    return enc_size;
+}
+
+uint64_t IMU::_computeHash(const __lcm_hash_ptr *p)
+{
+    const __lcm_hash_ptr *fp;
+    for(fp = p; fp != NULL; fp = fp->parent)
+        if(fp->v == IMU::getHash)
+            return 0;
+    const __lcm_hash_ptr cp = { p, IMU::getHash };
+
+    uint64_t hash = 0xac2e31fe8e135e97LL +
+         wescore_lcm_msgs::Quaternion::_computeHash(&cp) +
+         wescore_lcm_msgs::Vector3::_computeHash(&cp) +
+         wescore_lcm_msgs::Vector3::_computeHash(&cp);
+
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/NavSatFix.hpp

@@ -0,0 +1,224 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_NavSatFix_hpp__
+#define __wescore_lcm_msgs_NavSatFix_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+#include "lcmtypes/wescore_lcm_msgs/NavSatStatus.hpp"
+
+namespace wescore_lcm_msgs
+{
+
+class NavSatFix
+{
+    public:
+        wescore_lcm_msgs::NavSatStatus status;
+
+        double     latitude;
+
+        double     longitude;
+
+        double     altitude;
+
+        double     position_covariance[9];
+
+        int8_t     position_covariance_type;
+
+    public:
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int8_t   COVARIANCE_TYPE_UNKNOWN = 0;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int8_t   COVARIANCE_TYPE_APPROXIMATED = 1;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int8_t   COVARIANCE_TYPE_DIAGONAL_KNOWN = 2;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int8_t   COVARIANCE_TYPE_KNOWN = 3;
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "NavSatFix"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int NavSatFix::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int NavSatFix::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int NavSatFix::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t NavSatFix::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* NavSatFix::getTypeName()
+{
+    return "NavSatFix";
+}
+
+int NavSatFix::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = this->status._encodeNoHash(buf, offset + pos, maxlen - pos);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->latitude, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->longitude, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->altitude, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->position_covariance[0], 9);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __int8_t_encode_array(buf, offset + pos, maxlen - pos, &this->position_covariance_type, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int NavSatFix::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = this->status._decodeNoHash(buf, offset + pos, maxlen - pos);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->latitude, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->longitude, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->altitude, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->position_covariance[0], 9);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __int8_t_decode_array(buf, offset + pos, maxlen - pos, &this->position_covariance_type, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int NavSatFix::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += this->status._getEncodedSizeNoHash();
+    enc_size += __double_encoded_array_size(NULL, 1);
+    enc_size += __double_encoded_array_size(NULL, 1);
+    enc_size += __double_encoded_array_size(NULL, 1);
+    enc_size += __double_encoded_array_size(NULL, 9);
+    enc_size += __int8_t_encoded_array_size(NULL, 1);
+    return enc_size;
+}
+
+uint64_t NavSatFix::_computeHash(const __lcm_hash_ptr *p)
+{
+    const __lcm_hash_ptr *fp;
+    for(fp = p; fp != NULL; fp = fp->parent)
+        if(fp->v == NavSatFix::getHash)
+            return 0;
+    const __lcm_hash_ptr cp = { p, NavSatFix::getHash };
+
+    uint64_t hash = 0x60c5a36268b1a1a0LL +
+         wescore_lcm_msgs::NavSatStatus::_computeHash(&cp);
+
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/NavSatStatus.hpp

@@ -0,0 +1,200 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_NavSatStatus_hpp__
+#define __wescore_lcm_msgs_NavSatStatus_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+/// GPS
+class NavSatStatus
+{
+    public:
+        int8_t     status;
+
+        int16_t    service;
+
+    public:
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int8_t   STATUS_NO_FIX = -1;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int8_t   STATUS_FIX = 0;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int8_t   STATUS_SBAS_FIX = 1;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int8_t   STATUS_GBAS_FIX = 2;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int16_t  SERVICE_GPS = 1;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int16_t  SERVICE_GLONASS = 2;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int16_t  SERVICE_COMPASS = 4;
+        // If you're using C++11 and are getting compiler errors saying
+        // things like ‘constexpr’ needed for in-class initialization of
+        // static data member then re-run lcm-gen with '--cpp-std=c++11'
+        // to generate code that is compliant with C++11
+        static const int16_t  SERVICE_GALILEO = 8;
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "NavSatStatus"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int NavSatStatus::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int NavSatStatus::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int NavSatStatus::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t NavSatStatus::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* NavSatStatus::getTypeName()
+{
+    return "NavSatStatus";
+}
+
+int NavSatStatus::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __int8_t_encode_array(buf, offset + pos, maxlen - pos, &this->status, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __int16_t_encode_array(buf, offset + pos, maxlen - pos, &this->service, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int NavSatStatus::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __int8_t_decode_array(buf, offset + pos, maxlen - pos, &this->status, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __int16_t_decode_array(buf, offset + pos, maxlen - pos, &this->service, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int NavSatStatus::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __int8_t_encoded_array_size(NULL, 1);
+    enc_size += __int16_t_encoded_array_size(NULL, 1);
+    return enc_size;
+}
+
+uint64_t NavSatStatus::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0x76b236592075c1dbLL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/Quaternion.hpp

@@ -0,0 +1,175 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_Quaternion_hpp__
+#define __wescore_lcm_msgs_Quaternion_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+class Quaternion
+{
+    public:
+        double     x;
+
+        double     y;
+
+        double     z;
+
+        double     w;
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "Quaternion"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int Quaternion::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int Quaternion::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int Quaternion::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t Quaternion::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* Quaternion::getTypeName()
+{
+    return "Quaternion";
+}
+
+int Quaternion::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->x, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->y, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->z, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->w, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int Quaternion::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->x, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->y, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->z, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->w, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int Quaternion::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __double_encoded_array_size(NULL, 1);
+    enc_size += __double_encoded_array_size(NULL, 1);
+    enc_size += __double_encoded_array_size(NULL, 1);
+    enc_size += __double_encoded_array_size(NULL, 1);
+    return enc_size;
+}
+
+uint64_t Quaternion::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0x9b1dee9dfc8c0515LL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/RawAccel.hpp

@@ -0,0 +1,157 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_RawAccel_hpp__
+#define __wescore_lcm_msgs_RawAccel_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+class RawAccel
+{
+    public:
+        int64_t    mtime;
+
+        float      accel[3];
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "RawAccel"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int RawAccel::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawAccel::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int RawAccel::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t RawAccel::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* RawAccel::getTypeName()
+{
+    return "RawAccel";
+}
+
+int RawAccel::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->accel[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawAccel::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->accel[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawAccel::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __int64_t_encoded_array_size(NULL, 1);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    return enc_size;
+}
+
+uint64_t RawAccel::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0x1317644918cca9a1LL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/RawGyro.hpp

@@ -0,0 +1,158 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_RawGyro_hpp__
+#define __wescore_lcm_msgs_RawGyro_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+/// IMU data
+class RawGyro
+{
+    public:
+        int64_t    mtime;
+
+        float      gyro[3];
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "RawGyro"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int RawGyro::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawGyro::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int RawGyro::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t RawGyro::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* RawGyro::getTypeName()
+{
+    return "RawGyro";
+}
+
+int RawGyro::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->gyro[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawGyro::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->gyro[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawGyro::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __int64_t_encoded_array_size(NULL, 1);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    return enc_size;
+}
+
+uint64_t RawGyro::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0xc2ebea5c61fc00c8LL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/RawIMU10DOF.hpp

@@ -0,0 +1,175 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_RawIMU10DOF_hpp__
+#define __wescore_lcm_msgs_RawIMU10DOF_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+class RawIMU10DOF
+{
+    public:
+        int64_t    mtime;
+
+        float      gyro[3];
+
+        float      accel[3];
+
+        float      baro;
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "RawIMU10DOF"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int RawIMU10DOF::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawIMU10DOF::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int RawIMU10DOF::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t RawIMU10DOF::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* RawIMU10DOF::getTypeName()
+{
+    return "RawIMU10DOF";
+}
+
+int RawIMU10DOF::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->gyro[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->accel[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->baro, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawIMU10DOF::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->gyro[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->accel[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->baro, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawIMU10DOF::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __int64_t_encoded_array_size(NULL, 1);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    enc_size += __float_encoded_array_size(NULL, 1);
+    return enc_size;
+}
+
+uint64_t RawIMU10DOF::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0xd27571225f0da045LL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/RawIMU6DOF.hpp

@@ -0,0 +1,166 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_RawIMU6DOF_hpp__
+#define __wescore_lcm_msgs_RawIMU6DOF_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+class RawIMU6DOF
+{
+    public:
+        int64_t    mtime;
+
+        float      gyro[3];
+
+        float      accel[3];
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "RawIMU6DOF"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int RawIMU6DOF::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawIMU6DOF::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int RawIMU6DOF::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t RawIMU6DOF::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* RawIMU6DOF::getTypeName()
+{
+    return "RawIMU6DOF";
+}
+
+int RawIMU6DOF::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->gyro[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->accel[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawIMU6DOF::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->gyro[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->accel[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawIMU6DOF::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __int64_t_encoded_array_size(NULL, 1);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    return enc_size;
+}
+
+uint64_t RawIMU6DOF::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0x825c4435b1c7fa46LL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/RawIMU9DOF.hpp

@@ -0,0 +1,175 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_RawIMU9DOF_hpp__
+#define __wescore_lcm_msgs_RawIMU9DOF_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+class RawIMU9DOF
+{
+    public:
+        int64_t    mtime;
+
+        float      gyro[3];
+
+        float      accel[3];
+
+        float      magn[3];
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "RawIMU9DOF"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int RawIMU9DOF::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawIMU9DOF::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int RawIMU9DOF::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t RawIMU9DOF::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* RawIMU9DOF::getTypeName()
+{
+    return "RawIMU9DOF";
+}
+
+int RawIMU9DOF::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->gyro[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->accel[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->magn[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawIMU9DOF::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->gyro[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->accel[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->magn[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawIMU9DOF::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __int64_t_encoded_array_size(NULL, 1);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    return enc_size;
+}
+
+uint64_t RawIMU9DOF::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0x225ef7a05c5d1715LL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/RawMag.hpp

@@ -0,0 +1,157 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_RawMag_hpp__
+#define __wescore_lcm_msgs_RawMag_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+class RawMag
+{
+    public:
+        int64_t    mtime;
+
+        float      magn[3];
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "RawMag"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int RawMag::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawMag::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int RawMag::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t RawMag::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* RawMag::getTypeName()
+{
+    return "RawMag";
+}
+
+int RawMag::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_encode_array(buf, offset + pos, maxlen - pos, &this->magn[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawMag::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this->mtime, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __float_decode_array(buf, offset + pos, maxlen - pos, &this->magn[0], 3);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int RawMag::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __int64_t_encoded_array_size(NULL, 1);
+    enc_size += __float_encoded_array_size(NULL, 3);
+    return enc_size;
+}
+
+uint64_t RawMag::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0xc2ebe073b6fa00c8LL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/Vector2.hpp

@@ -0,0 +1,157 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_Vector2_hpp__
+#define __wescore_lcm_msgs_Vector2_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+class Vector2
+{
+    public:
+        double     x;
+
+        double     y;
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "Vector2"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int Vector2::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int Vector2::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int Vector2::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t Vector2::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* Vector2::getTypeName()
+{
+    return "Vector2";
+}
+
+int Vector2::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->x, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->y, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int Vector2::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->x, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->y, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int Vector2::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __double_encoded_array_size(NULL, 1);
+    enc_size += __double_encoded_array_size(NULL, 1);
+    return enc_size;
+}
+
+uint64_t Vector2::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0xd259512e30b44885LL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs/Vector3.hpp

@@ -0,0 +1,166 @@
+/** THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+ * BY HAND!!
+ *
+ * Generated by lcm-gen
+ **/
+
+#ifndef __wescore_lcm_msgs_Vector3_hpp__
+#define __wescore_lcm_msgs_Vector3_hpp__
+
+#include <lcm/lcm_coretypes.h>
+
+
+namespace wescore_lcm_msgs
+{
+
+class Vector3
+{
+    public:
+        double     x;
+
+        double     y;
+
+        double     z;
+
+    public:
+        /**
+         * Encode a message into binary form.
+         *
+         * @param buf The output buffer.
+         * @param offset Encoding starts at thie byte offset into @p buf.
+         * @param maxlen Maximum number of bytes to write.  This should generally be
+         *  equal to getEncodedSize().
+         * @return The number of bytes encoded, or <0 on error.
+         */
+        inline int encode(void *buf, int offset, int maxlen) const;
+
+        /**
+         * Check how many bytes are required to encode this message.
+         */
+        inline int getEncodedSize() const;
+
+        /**
+         * Decode a message from binary form into this instance.
+         *
+         * @param buf The buffer containing the encoded message.
+         * @param offset The byte offset into @p buf where the encoded message starts.
+         * @param maxlen The maximum number of bytes to read while decoding.
+         * @return The number of bytes decoded, or <0 if an error occured.
+         */
+        inline int decode(const void *buf, int offset, int maxlen);
+
+        /**
+         * Retrieve the 64-bit fingerprint identifying the structure of the message.
+         * Note that the fingerprint is the same for all instances of the same
+         * message type, and is a fingerprint on the message type definition, not on
+         * the message contents.
+         */
+        inline static int64_t getHash();
+
+        /**
+         * Returns "Vector3"
+         */
+        inline static const char* getTypeName();
+
+        // LCM support functions. Users should not call these
+        inline int _encodeNoHash(void *buf, int offset, int maxlen) const;
+        inline int _getEncodedSizeNoHash() const;
+        inline int _decodeNoHash(const void *buf, int offset, int maxlen);
+        inline static uint64_t _computeHash(const __lcm_hash_ptr *p);
+};
+
+int Vector3::encode(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+    int64_t hash = getHash();
+
+    tlen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = this->_encodeNoHash(buf, offset + pos, maxlen - pos);
+    if (tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int Vector3::decode(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, thislen;
+
+    int64_t msg_hash;
+    thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &msg_hash, 1);
+    if (thislen < 0) return thislen; else pos += thislen;
+    if (msg_hash != getHash()) return -1;
+
+    thislen = this->_decodeNoHash(buf, offset + pos, maxlen - pos);
+    if (thislen < 0) return thislen; else pos += thislen;
+
+    return pos;
+}
+
+int Vector3::getEncodedSize() const
+{
+    return 8 + _getEncodedSizeNoHash();
+}
+
+int64_t Vector3::getHash()
+{
+    static int64_t hash = static_cast<int64_t>(_computeHash(NULL));
+    return hash;
+}
+
+const char* Vector3::getTypeName()
+{
+    return "Vector3";
+}
+
+int Vector3::_encodeNoHash(void *buf, int offset, int maxlen) const
+{
+    int pos = 0, tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->x, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->y, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_encode_array(buf, offset + pos, maxlen - pos, &this->z, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int Vector3::_decodeNoHash(const void *buf, int offset, int maxlen)
+{
+    int pos = 0, tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->x, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->y, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    tlen = __double_decode_array(buf, offset + pos, maxlen - pos, &this->z, 1);
+    if(tlen < 0) return tlen; else pos += tlen;
+
+    return pos;
+}
+
+int Vector3::_getEncodedSizeNoHash() const
+{
+    int enc_size = 0;
+    enc_size += __double_encoded_array_size(NULL, 1);
+    enc_size += __double_encoded_array_size(NULL, 1);
+    enc_size += __double_encoded_array_size(NULL, 1);
+    return enc_size;
+}
+
+uint64_t Vector3::_computeHash(const __lcm_hash_ptr *)
+{
+    uint64_t hash = 0x573f2fdd2f76508fLL;
+    return (hash<<1) + ((hash>>63)&1);
+}
+
+}
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_IMU.h

@@ -0,0 +1,155 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_IMU_h
+#define _wescore_lcm_msgs_IMU_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lcmtypes/wescore_lcm_msgs_Quaternion.h"
+#include "lcmtypes/wescore_lcm_msgs_Vector3.h"
+#include "lcmtypes/wescore_lcm_msgs_Vector3.h"
+typedef struct _wescore_lcm_msgs_IMU wescore_lcm_msgs_IMU;
+struct _wescore_lcm_msgs_IMU
+{
+    int64_t    mtime;
+    wescore_lcm_msgs_Quaternion orientation;
+    double     orientation_covariance[9];
+    wescore_lcm_msgs_Vector3 angular_velocity;
+    double     angular_velocity_covariance[9];
+    wescore_lcm_msgs_Vector3 linear_acceleration;
+    double     linear_acceleration_covariance[9];
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_IMU.
+ * When no longer needed, destroy it with wescore_lcm_msgs_IMU_destroy()
+ */
+wescore_lcm_msgs_IMU* wescore_lcm_msgs_IMU_copy(const wescore_lcm_msgs_IMU* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_IMU created by wescore_lcm_msgs_IMU_copy()
+ */
+void wescore_lcm_msgs_IMU_destroy(wescore_lcm_msgs_IMU* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_IMU_subscription_t wescore_lcm_msgs_IMU_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_IMU is received.
+ */
+typedef void(*wescore_lcm_msgs_IMU_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_IMU *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_IMU using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_IMU_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_IMU *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_IMU using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_IMU_subscription_t* wescore_lcm_msgs_IMU_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_IMU_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_IMU_subscribe()
+ */
+int wescore_lcm_msgs_IMU_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_IMU_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_IMU_subscription_set_queue_capacity(
+    wescore_lcm_msgs_IMU_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_IMU into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_IMU_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_IMU_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_IMU *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_IMU from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_IMU_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_IMU_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_IMU *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_IMU_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_IMU_decode_cleanup(wescore_lcm_msgs_IMU *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_IMU
+ */
+int wescore_lcm_msgs_IMU_encoded_size(const wescore_lcm_msgs_IMU *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_IMU_get_hash(void);
+uint64_t __wescore_lcm_msgs_IMU_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_IMU_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_IMU *p, int elements);
+int __wescore_lcm_msgs_IMU_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_IMU *p, int elements);
+int __wescore_lcm_msgs_IMU_decode_array_cleanup(wescore_lcm_msgs_IMU *p, int elements);
+int __wescore_lcm_msgs_IMU_encoded_array_size(const wescore_lcm_msgs_IMU *p, int elements);
+int __wescore_lcm_msgs_IMU_clone_array(const wescore_lcm_msgs_IMU *p, wescore_lcm_msgs_IMU *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_NavSatFix.h

@@ -0,0 +1,157 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_NavSatFix_h
+#define _wescore_lcm_msgs_NavSatFix_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lcmtypes/wescore_lcm_msgs_NavSatStatus.h"
+#define WESCORE_LCM_MSGS_NAVSATFIX_COVARIANCE_TYPE_UNKNOWN 0
+#define WESCORE_LCM_MSGS_NAVSATFIX_COVARIANCE_TYPE_APPROXIMATED 1
+#define WESCORE_LCM_MSGS_NAVSATFIX_COVARIANCE_TYPE_DIAGONAL_KNOWN 2
+#define WESCORE_LCM_MSGS_NAVSATFIX_COVARIANCE_TYPE_KNOWN 3
+
+typedef struct _wescore_lcm_msgs_NavSatFix wescore_lcm_msgs_NavSatFix;
+struct _wescore_lcm_msgs_NavSatFix
+{
+    wescore_lcm_msgs_NavSatStatus status;
+    double     latitude;
+    double     longitude;
+    double     altitude;
+    double     position_covariance[9];
+    int8_t     position_covariance_type;
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_NavSatFix.
+ * When no longer needed, destroy it with wescore_lcm_msgs_NavSatFix_destroy()
+ */
+wescore_lcm_msgs_NavSatFix* wescore_lcm_msgs_NavSatFix_copy(const wescore_lcm_msgs_NavSatFix* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_NavSatFix created by wescore_lcm_msgs_NavSatFix_copy()
+ */
+void wescore_lcm_msgs_NavSatFix_destroy(wescore_lcm_msgs_NavSatFix* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_NavSatFix_subscription_t wescore_lcm_msgs_NavSatFix_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_NavSatFix is received.
+ */
+typedef void(*wescore_lcm_msgs_NavSatFix_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_NavSatFix *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_NavSatFix using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_NavSatFix_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_NavSatFix *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_NavSatFix using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_NavSatFix_subscription_t* wescore_lcm_msgs_NavSatFix_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_NavSatFix_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_NavSatFix_subscribe()
+ */
+int wescore_lcm_msgs_NavSatFix_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_NavSatFix_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_NavSatFix_subscription_set_queue_capacity(
+    wescore_lcm_msgs_NavSatFix_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_NavSatFix into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_NavSatFix_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_NavSatFix_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_NavSatFix *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_NavSatFix from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_NavSatFix_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_NavSatFix_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_NavSatFix *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_NavSatFix_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_NavSatFix_decode_cleanup(wescore_lcm_msgs_NavSatFix *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_NavSatFix
+ */
+int wescore_lcm_msgs_NavSatFix_encoded_size(const wescore_lcm_msgs_NavSatFix *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_NavSatFix_get_hash(void);
+uint64_t __wescore_lcm_msgs_NavSatFix_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_NavSatFix_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_NavSatFix *p, int elements);
+int __wescore_lcm_msgs_NavSatFix_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_NavSatFix *p, int elements);
+int __wescore_lcm_msgs_NavSatFix_decode_array_cleanup(wescore_lcm_msgs_NavSatFix *p, int elements);
+int __wescore_lcm_msgs_NavSatFix_encoded_array_size(const wescore_lcm_msgs_NavSatFix *p, int elements);
+int __wescore_lcm_msgs_NavSatFix_clone_array(const wescore_lcm_msgs_NavSatFix *p, wescore_lcm_msgs_NavSatFix *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_NavSatStatus.h

@@ -0,0 +1,157 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_NavSatStatus_h
+#define _wescore_lcm_msgs_NavSatStatus_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WESCORE_LCM_MSGS_NAVSATSTATUS_STATUS_NO_FIX -1
+#define WESCORE_LCM_MSGS_NAVSATSTATUS_STATUS_FIX 0
+#define WESCORE_LCM_MSGS_NAVSATSTATUS_STATUS_SBAS_FIX 1
+#define WESCORE_LCM_MSGS_NAVSATSTATUS_STATUS_GBAS_FIX 2
+#define WESCORE_LCM_MSGS_NAVSATSTATUS_SERVICE_GPS 1
+#define WESCORE_LCM_MSGS_NAVSATSTATUS_SERVICE_GLONASS 2
+#define WESCORE_LCM_MSGS_NAVSATSTATUS_SERVICE_COMPASS 4
+#define WESCORE_LCM_MSGS_NAVSATSTATUS_SERVICE_GALILEO 8
+
+/// GPS
+typedef struct _wescore_lcm_msgs_NavSatStatus wescore_lcm_msgs_NavSatStatus;
+struct _wescore_lcm_msgs_NavSatStatus
+{
+    int8_t     status;
+    int16_t    service;
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_NavSatStatus.
+ * When no longer needed, destroy it with wescore_lcm_msgs_NavSatStatus_destroy()
+ */
+wescore_lcm_msgs_NavSatStatus* wescore_lcm_msgs_NavSatStatus_copy(const wescore_lcm_msgs_NavSatStatus* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_NavSatStatus created by wescore_lcm_msgs_NavSatStatus_copy()
+ */
+void wescore_lcm_msgs_NavSatStatus_destroy(wescore_lcm_msgs_NavSatStatus* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_NavSatStatus_subscription_t wescore_lcm_msgs_NavSatStatus_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_NavSatStatus is received.
+ */
+typedef void(*wescore_lcm_msgs_NavSatStatus_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_NavSatStatus *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_NavSatStatus using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_NavSatStatus_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_NavSatStatus *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_NavSatStatus using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_NavSatStatus_subscription_t* wescore_lcm_msgs_NavSatStatus_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_NavSatStatus_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_NavSatStatus_subscribe()
+ */
+int wescore_lcm_msgs_NavSatStatus_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_NavSatStatus_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_NavSatStatus_subscription_set_queue_capacity(
+    wescore_lcm_msgs_NavSatStatus_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_NavSatStatus into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_NavSatStatus_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_NavSatStatus_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_NavSatStatus *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_NavSatStatus from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_NavSatStatus_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_NavSatStatus_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_NavSatStatus *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_NavSatStatus_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_NavSatStatus_decode_cleanup(wescore_lcm_msgs_NavSatStatus *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_NavSatStatus
+ */
+int wescore_lcm_msgs_NavSatStatus_encoded_size(const wescore_lcm_msgs_NavSatStatus *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_NavSatStatus_get_hash(void);
+uint64_t __wescore_lcm_msgs_NavSatStatus_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_NavSatStatus_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_NavSatStatus *p, int elements);
+int __wescore_lcm_msgs_NavSatStatus_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_NavSatStatus *p, int elements);
+int __wescore_lcm_msgs_NavSatStatus_decode_array_cleanup(wescore_lcm_msgs_NavSatStatus *p, int elements);
+int __wescore_lcm_msgs_NavSatStatus_encoded_array_size(const wescore_lcm_msgs_NavSatStatus *p, int elements);
+int __wescore_lcm_msgs_NavSatStatus_clone_array(const wescore_lcm_msgs_NavSatStatus *p, wescore_lcm_msgs_NavSatStatus *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_Quaternion.h

@@ -0,0 +1,149 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_Quaternion_h
+#define _wescore_lcm_msgs_Quaternion_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _wescore_lcm_msgs_Quaternion wescore_lcm_msgs_Quaternion;
+struct _wescore_lcm_msgs_Quaternion
+{
+    double     x;
+    double     y;
+    double     z;
+    double     w;
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_Quaternion.
+ * When no longer needed, destroy it with wescore_lcm_msgs_Quaternion_destroy()
+ */
+wescore_lcm_msgs_Quaternion* wescore_lcm_msgs_Quaternion_copy(const wescore_lcm_msgs_Quaternion* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_Quaternion created by wescore_lcm_msgs_Quaternion_copy()
+ */
+void wescore_lcm_msgs_Quaternion_destroy(wescore_lcm_msgs_Quaternion* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_Quaternion_subscription_t wescore_lcm_msgs_Quaternion_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_Quaternion is received.
+ */
+typedef void(*wescore_lcm_msgs_Quaternion_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_Quaternion *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_Quaternion using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_Quaternion_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_Quaternion *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_Quaternion using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_Quaternion_subscription_t* wescore_lcm_msgs_Quaternion_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_Quaternion_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_Quaternion_subscribe()
+ */
+int wescore_lcm_msgs_Quaternion_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_Quaternion_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_Quaternion_subscription_set_queue_capacity(
+    wescore_lcm_msgs_Quaternion_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_Quaternion into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_Quaternion_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_Quaternion_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_Quaternion *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_Quaternion from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_Quaternion_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_Quaternion_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_Quaternion *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_Quaternion_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_Quaternion_decode_cleanup(wescore_lcm_msgs_Quaternion *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_Quaternion
+ */
+int wescore_lcm_msgs_Quaternion_encoded_size(const wescore_lcm_msgs_Quaternion *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_Quaternion_get_hash(void);
+uint64_t __wescore_lcm_msgs_Quaternion_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_Quaternion_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_Quaternion *p, int elements);
+int __wescore_lcm_msgs_Quaternion_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_Quaternion *p, int elements);
+int __wescore_lcm_msgs_Quaternion_decode_array_cleanup(wescore_lcm_msgs_Quaternion *p, int elements);
+int __wescore_lcm_msgs_Quaternion_encoded_array_size(const wescore_lcm_msgs_Quaternion *p, int elements);
+int __wescore_lcm_msgs_Quaternion_clone_array(const wescore_lcm_msgs_Quaternion *p, wescore_lcm_msgs_Quaternion *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_RawAccel.h

@@ -0,0 +1,147 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_RawAccel_h
+#define _wescore_lcm_msgs_RawAccel_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _wescore_lcm_msgs_RawAccel wescore_lcm_msgs_RawAccel;
+struct _wescore_lcm_msgs_RawAccel
+{
+    int64_t    mtime;
+    float      accel[3];
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_RawAccel.
+ * When no longer needed, destroy it with wescore_lcm_msgs_RawAccel_destroy()
+ */
+wescore_lcm_msgs_RawAccel* wescore_lcm_msgs_RawAccel_copy(const wescore_lcm_msgs_RawAccel* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_RawAccel created by wescore_lcm_msgs_RawAccel_copy()
+ */
+void wescore_lcm_msgs_RawAccel_destroy(wescore_lcm_msgs_RawAccel* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_RawAccel_subscription_t wescore_lcm_msgs_RawAccel_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_RawAccel is received.
+ */
+typedef void(*wescore_lcm_msgs_RawAccel_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_RawAccel *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_RawAccel using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_RawAccel_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_RawAccel *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_RawAccel using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_RawAccel_subscription_t* wescore_lcm_msgs_RawAccel_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_RawAccel_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_RawAccel_subscribe()
+ */
+int wescore_lcm_msgs_RawAccel_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_RawAccel_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_RawAccel_subscription_set_queue_capacity(
+    wescore_lcm_msgs_RawAccel_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_RawAccel into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_RawAccel_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawAccel_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawAccel *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_RawAccel from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_RawAccel_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawAccel_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawAccel *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_RawAccel_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_RawAccel_decode_cleanup(wescore_lcm_msgs_RawAccel *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_RawAccel
+ */
+int wescore_lcm_msgs_RawAccel_encoded_size(const wescore_lcm_msgs_RawAccel *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_RawAccel_get_hash(void);
+uint64_t __wescore_lcm_msgs_RawAccel_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_RawAccel_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawAccel *p, int elements);
+int __wescore_lcm_msgs_RawAccel_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawAccel *p, int elements);
+int __wescore_lcm_msgs_RawAccel_decode_array_cleanup(wescore_lcm_msgs_RawAccel *p, int elements);
+int __wescore_lcm_msgs_RawAccel_encoded_array_size(const wescore_lcm_msgs_RawAccel *p, int elements);
+int __wescore_lcm_msgs_RawAccel_clone_array(const wescore_lcm_msgs_RawAccel *p, wescore_lcm_msgs_RawAccel *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_RawGyro.h

@@ -0,0 +1,148 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_RawGyro_h
+#define _wescore_lcm_msgs_RawGyro_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// IMU data
+typedef struct _wescore_lcm_msgs_RawGyro wescore_lcm_msgs_RawGyro;
+struct _wescore_lcm_msgs_RawGyro
+{
+    int64_t    mtime;
+    float      gyro[3];
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_RawGyro.
+ * When no longer needed, destroy it with wescore_lcm_msgs_RawGyro_destroy()
+ */
+wescore_lcm_msgs_RawGyro* wescore_lcm_msgs_RawGyro_copy(const wescore_lcm_msgs_RawGyro* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_RawGyro created by wescore_lcm_msgs_RawGyro_copy()
+ */
+void wescore_lcm_msgs_RawGyro_destroy(wescore_lcm_msgs_RawGyro* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_RawGyro_subscription_t wescore_lcm_msgs_RawGyro_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_RawGyro is received.
+ */
+typedef void(*wescore_lcm_msgs_RawGyro_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_RawGyro *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_RawGyro using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_RawGyro_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_RawGyro *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_RawGyro using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_RawGyro_subscription_t* wescore_lcm_msgs_RawGyro_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_RawGyro_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_RawGyro_subscribe()
+ */
+int wescore_lcm_msgs_RawGyro_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_RawGyro_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_RawGyro_subscription_set_queue_capacity(
+    wescore_lcm_msgs_RawGyro_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_RawGyro into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_RawGyro_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawGyro_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawGyro *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_RawGyro from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_RawGyro_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawGyro_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawGyro *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_RawGyro_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_RawGyro_decode_cleanup(wescore_lcm_msgs_RawGyro *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_RawGyro
+ */
+int wescore_lcm_msgs_RawGyro_encoded_size(const wescore_lcm_msgs_RawGyro *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_RawGyro_get_hash(void);
+uint64_t __wescore_lcm_msgs_RawGyro_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_RawGyro_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawGyro *p, int elements);
+int __wescore_lcm_msgs_RawGyro_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawGyro *p, int elements);
+int __wescore_lcm_msgs_RawGyro_decode_array_cleanup(wescore_lcm_msgs_RawGyro *p, int elements);
+int __wescore_lcm_msgs_RawGyro_encoded_array_size(const wescore_lcm_msgs_RawGyro *p, int elements);
+int __wescore_lcm_msgs_RawGyro_clone_array(const wescore_lcm_msgs_RawGyro *p, wescore_lcm_msgs_RawGyro *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_RawIMU10DOF.h

@@ -0,0 +1,149 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_RawIMU10DOF_h
+#define _wescore_lcm_msgs_RawIMU10DOF_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _wescore_lcm_msgs_RawIMU10DOF wescore_lcm_msgs_RawIMU10DOF;
+struct _wescore_lcm_msgs_RawIMU10DOF
+{
+    int64_t    mtime;
+    float      gyro[3];
+    float      accel[3];
+    float      baro;
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_RawIMU10DOF.
+ * When no longer needed, destroy it with wescore_lcm_msgs_RawIMU10DOF_destroy()
+ */
+wescore_lcm_msgs_RawIMU10DOF* wescore_lcm_msgs_RawIMU10DOF_copy(const wescore_lcm_msgs_RawIMU10DOF* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_RawIMU10DOF created by wescore_lcm_msgs_RawIMU10DOF_copy()
+ */
+void wescore_lcm_msgs_RawIMU10DOF_destroy(wescore_lcm_msgs_RawIMU10DOF* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_RawIMU10DOF_subscription_t wescore_lcm_msgs_RawIMU10DOF_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_RawIMU10DOF is received.
+ */
+typedef void(*wescore_lcm_msgs_RawIMU10DOF_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_RawIMU10DOF *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_RawIMU10DOF using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_RawIMU10DOF_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_RawIMU10DOF *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_RawIMU10DOF using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_RawIMU10DOF_subscription_t* wescore_lcm_msgs_RawIMU10DOF_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_RawIMU10DOF_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_RawIMU10DOF_subscribe()
+ */
+int wescore_lcm_msgs_RawIMU10DOF_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_RawIMU10DOF_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_RawIMU10DOF_subscription_set_queue_capacity(
+    wescore_lcm_msgs_RawIMU10DOF_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_RawIMU10DOF into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_RawIMU10DOF_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawIMU10DOF_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawIMU10DOF *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_RawIMU10DOF from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_RawIMU10DOF_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawIMU10DOF_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawIMU10DOF *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_RawIMU10DOF_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_RawIMU10DOF_decode_cleanup(wescore_lcm_msgs_RawIMU10DOF *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_RawIMU10DOF
+ */
+int wescore_lcm_msgs_RawIMU10DOF_encoded_size(const wescore_lcm_msgs_RawIMU10DOF *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_RawIMU10DOF_get_hash(void);
+uint64_t __wescore_lcm_msgs_RawIMU10DOF_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_RawIMU10DOF_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawIMU10DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU10DOF_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawIMU10DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU10DOF_decode_array_cleanup(wescore_lcm_msgs_RawIMU10DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU10DOF_encoded_array_size(const wescore_lcm_msgs_RawIMU10DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU10DOF_clone_array(const wescore_lcm_msgs_RawIMU10DOF *p, wescore_lcm_msgs_RawIMU10DOF *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_RawIMU6DOF.h

@@ -0,0 +1,148 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_RawIMU6DOF_h
+#define _wescore_lcm_msgs_RawIMU6DOF_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _wescore_lcm_msgs_RawIMU6DOF wescore_lcm_msgs_RawIMU6DOF;
+struct _wescore_lcm_msgs_RawIMU6DOF
+{
+    int64_t    mtime;
+    float      gyro[3];
+    float      accel[3];
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_RawIMU6DOF.
+ * When no longer needed, destroy it with wescore_lcm_msgs_RawIMU6DOF_destroy()
+ */
+wescore_lcm_msgs_RawIMU6DOF* wescore_lcm_msgs_RawIMU6DOF_copy(const wescore_lcm_msgs_RawIMU6DOF* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_RawIMU6DOF created by wescore_lcm_msgs_RawIMU6DOF_copy()
+ */
+void wescore_lcm_msgs_RawIMU6DOF_destroy(wescore_lcm_msgs_RawIMU6DOF* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_RawIMU6DOF_subscription_t wescore_lcm_msgs_RawIMU6DOF_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_RawIMU6DOF is received.
+ */
+typedef void(*wescore_lcm_msgs_RawIMU6DOF_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_RawIMU6DOF *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_RawIMU6DOF using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_RawIMU6DOF_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_RawIMU6DOF *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_RawIMU6DOF using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_RawIMU6DOF_subscription_t* wescore_lcm_msgs_RawIMU6DOF_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_RawIMU6DOF_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_RawIMU6DOF_subscribe()
+ */
+int wescore_lcm_msgs_RawIMU6DOF_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_RawIMU6DOF_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_RawIMU6DOF_subscription_set_queue_capacity(
+    wescore_lcm_msgs_RawIMU6DOF_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_RawIMU6DOF into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_RawIMU6DOF_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawIMU6DOF_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawIMU6DOF *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_RawIMU6DOF from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_RawIMU6DOF_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawIMU6DOF_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawIMU6DOF *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_RawIMU6DOF_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_RawIMU6DOF_decode_cleanup(wescore_lcm_msgs_RawIMU6DOF *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_RawIMU6DOF
+ */
+int wescore_lcm_msgs_RawIMU6DOF_encoded_size(const wescore_lcm_msgs_RawIMU6DOF *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_RawIMU6DOF_get_hash(void);
+uint64_t __wescore_lcm_msgs_RawIMU6DOF_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_RawIMU6DOF_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawIMU6DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU6DOF_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawIMU6DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU6DOF_decode_array_cleanup(wescore_lcm_msgs_RawIMU6DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU6DOF_encoded_array_size(const wescore_lcm_msgs_RawIMU6DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU6DOF_clone_array(const wescore_lcm_msgs_RawIMU6DOF *p, wescore_lcm_msgs_RawIMU6DOF *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_RawIMU9DOF.h

@@ -0,0 +1,149 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_RawIMU9DOF_h
+#define _wescore_lcm_msgs_RawIMU9DOF_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _wescore_lcm_msgs_RawIMU9DOF wescore_lcm_msgs_RawIMU9DOF;
+struct _wescore_lcm_msgs_RawIMU9DOF
+{
+    int64_t    mtime;
+    float      gyro[3];
+    float      accel[3];
+    float      magn[3];
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_RawIMU9DOF.
+ * When no longer needed, destroy it with wescore_lcm_msgs_RawIMU9DOF_destroy()
+ */
+wescore_lcm_msgs_RawIMU9DOF* wescore_lcm_msgs_RawIMU9DOF_copy(const wescore_lcm_msgs_RawIMU9DOF* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_RawIMU9DOF created by wescore_lcm_msgs_RawIMU9DOF_copy()
+ */
+void wescore_lcm_msgs_RawIMU9DOF_destroy(wescore_lcm_msgs_RawIMU9DOF* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_RawIMU9DOF_subscription_t wescore_lcm_msgs_RawIMU9DOF_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_RawIMU9DOF is received.
+ */
+typedef void(*wescore_lcm_msgs_RawIMU9DOF_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_RawIMU9DOF *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_RawIMU9DOF using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_RawIMU9DOF_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_RawIMU9DOF *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_RawIMU9DOF using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_RawIMU9DOF_subscription_t* wescore_lcm_msgs_RawIMU9DOF_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_RawIMU9DOF_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_RawIMU9DOF_subscribe()
+ */
+int wescore_lcm_msgs_RawIMU9DOF_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_RawIMU9DOF_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_RawIMU9DOF_subscription_set_queue_capacity(
+    wescore_lcm_msgs_RawIMU9DOF_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_RawIMU9DOF into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_RawIMU9DOF_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawIMU9DOF_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawIMU9DOF *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_RawIMU9DOF from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_RawIMU9DOF_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawIMU9DOF_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawIMU9DOF *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_RawIMU9DOF_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_RawIMU9DOF_decode_cleanup(wescore_lcm_msgs_RawIMU9DOF *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_RawIMU9DOF
+ */
+int wescore_lcm_msgs_RawIMU9DOF_encoded_size(const wescore_lcm_msgs_RawIMU9DOF *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_RawIMU9DOF_get_hash(void);
+uint64_t __wescore_lcm_msgs_RawIMU9DOF_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_RawIMU9DOF_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawIMU9DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU9DOF_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawIMU9DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU9DOF_decode_array_cleanup(wescore_lcm_msgs_RawIMU9DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU9DOF_encoded_array_size(const wescore_lcm_msgs_RawIMU9DOF *p, int elements);
+int __wescore_lcm_msgs_RawIMU9DOF_clone_array(const wescore_lcm_msgs_RawIMU9DOF *p, wescore_lcm_msgs_RawIMU9DOF *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_RawMag.h

@@ -0,0 +1,147 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_RawMag_h
+#define _wescore_lcm_msgs_RawMag_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _wescore_lcm_msgs_RawMag wescore_lcm_msgs_RawMag;
+struct _wescore_lcm_msgs_RawMag
+{
+    int64_t    mtime;
+    float      magn[3];
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_RawMag.
+ * When no longer needed, destroy it with wescore_lcm_msgs_RawMag_destroy()
+ */
+wescore_lcm_msgs_RawMag* wescore_lcm_msgs_RawMag_copy(const wescore_lcm_msgs_RawMag* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_RawMag created by wescore_lcm_msgs_RawMag_copy()
+ */
+void wescore_lcm_msgs_RawMag_destroy(wescore_lcm_msgs_RawMag* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_RawMag_subscription_t wescore_lcm_msgs_RawMag_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_RawMag is received.
+ */
+typedef void(*wescore_lcm_msgs_RawMag_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_RawMag *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_RawMag using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_RawMag_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_RawMag *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_RawMag using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_RawMag_subscription_t* wescore_lcm_msgs_RawMag_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_RawMag_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_RawMag_subscribe()
+ */
+int wescore_lcm_msgs_RawMag_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_RawMag_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_RawMag_subscription_set_queue_capacity(
+    wescore_lcm_msgs_RawMag_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_RawMag into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_RawMag_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawMag_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawMag *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_RawMag from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_RawMag_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_RawMag_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawMag *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_RawMag_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_RawMag_decode_cleanup(wescore_lcm_msgs_RawMag *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_RawMag
+ */
+int wescore_lcm_msgs_RawMag_encoded_size(const wescore_lcm_msgs_RawMag *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_RawMag_get_hash(void);
+uint64_t __wescore_lcm_msgs_RawMag_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_RawMag_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_RawMag *p, int elements);
+int __wescore_lcm_msgs_RawMag_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_RawMag *p, int elements);
+int __wescore_lcm_msgs_RawMag_decode_array_cleanup(wescore_lcm_msgs_RawMag *p, int elements);
+int __wescore_lcm_msgs_RawMag_encoded_array_size(const wescore_lcm_msgs_RawMag *p, int elements);
+int __wescore_lcm_msgs_RawMag_clone_array(const wescore_lcm_msgs_RawMag *p, wescore_lcm_msgs_RawMag *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_Vector2.h

@@ -0,0 +1,147 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_Vector2_h
+#define _wescore_lcm_msgs_Vector2_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _wescore_lcm_msgs_Vector2 wescore_lcm_msgs_Vector2;
+struct _wescore_lcm_msgs_Vector2
+{
+    double     x;
+    double     y;
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_Vector2.
+ * When no longer needed, destroy it with wescore_lcm_msgs_Vector2_destroy()
+ */
+wescore_lcm_msgs_Vector2* wescore_lcm_msgs_Vector2_copy(const wescore_lcm_msgs_Vector2* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_Vector2 created by wescore_lcm_msgs_Vector2_copy()
+ */
+void wescore_lcm_msgs_Vector2_destroy(wescore_lcm_msgs_Vector2* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_Vector2_subscription_t wescore_lcm_msgs_Vector2_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_Vector2 is received.
+ */
+typedef void(*wescore_lcm_msgs_Vector2_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_Vector2 *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_Vector2 using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_Vector2_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_Vector2 *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_Vector2 using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_Vector2_subscription_t* wescore_lcm_msgs_Vector2_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_Vector2_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_Vector2_subscribe()
+ */
+int wescore_lcm_msgs_Vector2_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_Vector2_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_Vector2_subscription_set_queue_capacity(
+    wescore_lcm_msgs_Vector2_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_Vector2 into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_Vector2_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_Vector2_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_Vector2 *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_Vector2 from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_Vector2_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_Vector2_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_Vector2 *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_Vector2_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_Vector2_decode_cleanup(wescore_lcm_msgs_Vector2 *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_Vector2
+ */
+int wescore_lcm_msgs_Vector2_encoded_size(const wescore_lcm_msgs_Vector2 *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_Vector2_get_hash(void);
+uint64_t __wescore_lcm_msgs_Vector2_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_Vector2_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_Vector2 *p, int elements);
+int __wescore_lcm_msgs_Vector2_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_Vector2 *p, int elements);
+int __wescore_lcm_msgs_Vector2_decode_array_cleanup(wescore_lcm_msgs_Vector2 *p, int elements);
+int __wescore_lcm_msgs_Vector2_encoded_array_size(const wescore_lcm_msgs_Vector2 *p, int elements);
+int __wescore_lcm_msgs_Vector2_clone_array(const wescore_lcm_msgs_Vector2 *p, wescore_lcm_msgs_Vector2 *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/lcmtypes/wescore_lcm_msgs_Vector3.h

@@ -0,0 +1,148 @@
+// THIS IS AN AUTOMATICALLY GENERATED FILE.  DO NOT MODIFY
+// BY HAND!!
+//
+// Generated by lcm-gen
+
+#ifndef _wescore_lcm_msgs_Vector3_h
+#define _wescore_lcm_msgs_Vector3_h
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <lcm/lcm_coretypes.h>
+#include <lcm/lcm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _wescore_lcm_msgs_Vector3 wescore_lcm_msgs_Vector3;
+struct _wescore_lcm_msgs_Vector3
+{
+    double     x;
+    double     y;
+    double     z;
+};
+
+/**
+ * Create a deep copy of a wescore_lcm_msgs_Vector3.
+ * When no longer needed, destroy it with wescore_lcm_msgs_Vector3_destroy()
+ */
+wescore_lcm_msgs_Vector3* wescore_lcm_msgs_Vector3_copy(const wescore_lcm_msgs_Vector3* to_copy);
+
+/**
+ * Destroy an instance of wescore_lcm_msgs_Vector3 created by wescore_lcm_msgs_Vector3_copy()
+ */
+void wescore_lcm_msgs_Vector3_destroy(wescore_lcm_msgs_Vector3* to_destroy);
+
+/**
+ * Identifies a single subscription.  This is an opaque data type.
+ */
+typedef struct _wescore_lcm_msgs_Vector3_subscription_t wescore_lcm_msgs_Vector3_subscription_t;
+
+/**
+ * Prototype for a callback function invoked when a message of type
+ * wescore_lcm_msgs_Vector3 is received.
+ */
+typedef void(*wescore_lcm_msgs_Vector3_handler_t)(
+    const lcm_recv_buf_t *rbuf, const char *channel,
+    const wescore_lcm_msgs_Vector3 *msg, void *userdata);
+
+/**
+ * Publish a message of type wescore_lcm_msgs_Vector3 using LCM.
+ *
+ * @param lcm The LCM instance to publish with.
+ * @param channel The channel to publish on.
+ * @param msg The message to publish.
+ * @return 0 on success, <0 on error.  Success means LCM has transferred
+ * responsibility of the message data to the OS.
+ */
+int wescore_lcm_msgs_Vector3_publish(lcm_t *lcm, const char *channel, const wescore_lcm_msgs_Vector3 *msg);
+
+/**
+ * Subscribe to messages of type wescore_lcm_msgs_Vector3 using LCM.
+ *
+ * @param lcm The LCM instance to subscribe with.
+ * @param channel The channel to subscribe to.
+ * @param handler The callback function invoked by LCM when a message is
+ *     received. This function is invoked by LCM during calls to lcm_handle()
+ *     and lcm_handle_timeout().
+ * @param userdata An opaque pointer passed to @p handler when it is invoked.
+ * @return 0 on success, <0 if an error occured
+ */
+wescore_lcm_msgs_Vector3_subscription_t* wescore_lcm_msgs_Vector3_subscribe(
+    lcm_t *lcm, const char *channel, wescore_lcm_msgs_Vector3_handler_t handler, void *userdata);
+
+/**
+ * Removes and destroys a subscription created by wescore_lcm_msgs_Vector3_subscribe()
+ */
+int wescore_lcm_msgs_Vector3_unsubscribe(lcm_t *lcm, wescore_lcm_msgs_Vector3_subscription_t* hid);
+
+/**
+ * Sets the queue capacity for a subscription.
+ * Some LCM providers (e.g., the default multicast provider) are implemented
+ * using a background receive thread that constantly revceives messages from
+ * the network.  As these messages are received, they are buffered on
+ * per-subscription queues until dispatched by lcm_handle().  This function
+ * how many messages are queued before dropping messages.
+ *
+ * @param subs the subscription to modify.
+ * @param num_messages The maximum number of messages to queue
+ *  on the subscription.
+ * @return 0 on success, <0 if an error occured
+ */
+int wescore_lcm_msgs_Vector3_subscription_set_queue_capacity(
+    wescore_lcm_msgs_Vector3_subscription_t* subs, int num_messages);
+
+/**
+ * Encode a message of type wescore_lcm_msgs_Vector3 into binary form.
+ *
+ * @param buf The output buffer.
+ * @param offset Encoding starts at this byte offset into @p buf.
+ * @param maxlen Maximum number of bytes to write.  This should generally
+ *               be equal to wescore_lcm_msgs_Vector3_encoded_size().
+ * @param msg The message to encode.
+ * @return The number of bytes encoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_Vector3_encode(void *buf, int offset, int maxlen, const wescore_lcm_msgs_Vector3 *p);
+
+/**
+ * Decode a message of type wescore_lcm_msgs_Vector3 from binary form.
+ * When decoding messages containing strings or variable-length arrays, this
+ * function may allocate memory.  When finished with the decoded message,
+ * release allocated resources with wescore_lcm_msgs_Vector3_decode_cleanup().
+ *
+ * @param buf The buffer containing the encoded message
+ * @param offset The byte offset into @p buf where the encoded message starts.
+ * @param maxlen The maximum number of bytes to read while decoding.
+ * @param msg Output parameter where the decoded message is stored
+ * @return The number of bytes decoded, or <0 if an error occured.
+ */
+int wescore_lcm_msgs_Vector3_decode(const void *buf, int offset, int maxlen, wescore_lcm_msgs_Vector3 *msg);
+
+/**
+ * Release resources allocated by wescore_lcm_msgs_Vector3_decode()
+ * @return 0
+ */
+int wescore_lcm_msgs_Vector3_decode_cleanup(wescore_lcm_msgs_Vector3 *p);
+
+/**
+ * Check how many bytes are required to encode a message of type wescore_lcm_msgs_Vector3
+ */
+int wescore_lcm_msgs_Vector3_encoded_size(const wescore_lcm_msgs_Vector3 *p);
+
+// LCM support functions. Users should not call these
+int64_t __wescore_lcm_msgs_Vector3_get_hash(void);
+uint64_t __wescore_lcm_msgs_Vector3_hash_recursive(const __lcm_hash_ptr *p);
+int __wescore_lcm_msgs_Vector3_encode_array(
+    void *buf, int offset, int maxlen, const wescore_lcm_msgs_Vector3 *p, int elements);
+int __wescore_lcm_msgs_Vector3_decode_array(
+    const void *buf, int offset, int maxlen, wescore_lcm_msgs_Vector3 *p, int elements);
+int __wescore_lcm_msgs_Vector3_decode_array_cleanup(wescore_lcm_msgs_Vector3 *p, int elements);
+int __wescore_lcm_msgs_Vector3_encoded_array_size(const wescore_lcm_msgs_Vector3 *p, int elements);
+int __wescore_lcm_msgs_Vector3_clone_array(const wescore_lcm_msgs_Vector3 *p, wescore_lcm_msgs_Vector3 *q, int elements);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

scout_base/include/scout_base/scout_messenger.hpp

@@ -14,26 +14,28 @@
 
 #include <ros/ros.h>
 #include <nav_msgs/Odometry.h>
-#include <tf/transform_broadcaster.h>
+// #include <tf/transform_broadcaster.h>
+#include <tf2_ros/transform_broadcaster.h>
 
 #include "scout_msgs/ScoutLightCmd.h"
-#include "scout/scout_base.hpp"
+#include "scout_sdk/scout_base.hpp"
 
 namespace wescore
 {
 class ScoutROSMessenger
 {
 public:
-    explicit ScoutROSMessenger(ros::NodeHandle nh);
-    ScoutROSMessenger(ScoutBase *scout, ros::NodeHandle nh);
+    explicit ScoutROSMessenger(ros::NodeHandle *nh);
+    ScoutROSMessenger(ScoutBase *scout, ros::NodeHandle *nh);
 
     std::string odom_frame_;
     std::string base_frame_;
 
-    bool simulated_robot_;
-    int sim_control_rate_;
+    bool simulated_robot_ = false;
+    int sim_control_rate_ = 50;
 
     void SetupSubscription();
+
     void PublishStateToROS();
     void PublishSimStateToROS(double linear, double angular);
 
@@ -41,7 +43,7 @@ public:
 
 private:
     ScoutBase *scout_;
-    ros::NodeHandle nh_;
+    ros::NodeHandle *nh_;
 
     std::mutex twist_mutex_;
     geometry_msgs::Twist current_twist_;
@@ -50,9 +52,8 @@ private:
     ros::Publisher status_publisher_;
     ros::Subscriber motion_cmd_subscriber_;
     ros::Subscriber light_cmd_subscriber_;
-    tf::TransformBroadcaster tf_broadcaster_;
+    tf2_ros::TransformBroadcaster tf_broadcaster_;
 
-private:
     // speed variables
     double linear_speed_ = 0.0;
     double angular_speed_ = 0.0;

scout_base/launch/robot_model.launch

@@ -0,0 +1,17 @@
+<launch>
+    <!--
+    <node name="scout_odom" pkg="scout_base" type="scout_base_node" output="screen">
+        <param name="port_name" type="string" value="can0" />
+
+        <param name="odom_frame" type="string" value="odom" />
+        <param name="base_frame" type="string" value="base_link" />
+
+        <param name="simulated_robot" type="bool" value="false" />
+    </node>
+    -->
+    <param name="robot_description" textfile="$(find scout_base)/urdf/agilex_scout.urdf" />
+
+    <node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" />
+
+    <node name="rviz" pkg="rviz" type="rviz" required="true" args="-d $(find scout_viz)/rviz/scout_model.rviz" />
+</launch>

scout_base/launch/scout_base.launch

@@ -1,9 +1,9 @@
 <launch>
-    <node name="scout_odom" pkg="scout_base" type="scout_base_node" output="screen">
+    <node name="scout_base_node" pkg="scout_base" type="scout_base_node" output="screen">
         <param name="port_name" type="string" value="can0" />
 
         <param name="odom_frame" type="string" value="odom" />
-        <param name="base_frame" type="string" value="base_footprint" />
+        <param name="base_frame" type="string" value="base_link" />
 
         <param name="simulated_robot" type="bool" value="false" />
     </node>

scout_base/launch/scout_base_sim.launch

@@ -1,14 +0,0 @@
-<launch>
-
-    <node name="scout_odom" pkg="scout_vrep_sim" type="scout_base_sim" output="screen">
-        <param name="odom_frame" type="string" value="odom" />
-        <param name="base_frame" type="string" value="base_link" />
-        <param name="simulated_robot" type="bool" value="true" />
-        <param name="sim_control_rate" value="50" />
-    </node>
-
-    <!-- Differential controller parameters and basic localization -->
-    <!--
-    <include file="$(find scout_control)/launch/control.launch" />
-    -->
-</launch>

scout_base/launch/scout_nav_2d.launch

@@ -0,0 +1,52 @@
+<launch>
+    <node name="scout_base_node" pkg="scout_base" type="scout_base_node" output="screen">
+        <param name="port_name" type="string" value="can0" />
+
+        <param name="odom_frame" type="string" value="odom" />
+        <param name="base_frame" type="string" value="base_link" />
+
+        <param name="simulated_robot" type="bool" value="false" />
+    </node>
+
+    <node name="sensor_hub_raw_imu" pkg="scout_base" type="imu_broadcast_node" output="screen"/>
+    <include file="$(find scout_base)/launch/sensor_rslidar16.launch" />
+
+    <!--
+    <include file="$(find scout_base)/launch/sensor_d435i.launch" />
+    -->
+
+    <param name="robot_description" textfile="$(find scout_base)/urdf/agilex_scout.urdf" />
+    <node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" />
+
+    <!--
+    <node pkg="tf2_ros" type="static_transform_publisher" name="lidar3d_tf_broadcaster" args="0.25 0 0.4 0 0 0 1 base_link rslidar" />
+    <node pkg="tf2_ros" type="static_transform_publisher" name="imu_tf_broadcaster" args="0.0 0 0.0 0 0 0 1 base_link imu" />
+    -->
+
+    <node name="pointcloud_to_laserscan" pkg="pointcloud_to_laserscan" type="pointcloud_to_laserscan_node">
+      <remap from="cloud_in" to="/rslidar_points"/>
+      <rosparam>
+        transform_tolerance: 0.01
+        min_height: 0.2
+        max_height: 0.5
+        
+        angle_min: -3.14
+        angle_max: 3.14
+        angle_increment: 0.01256
+        scan_time: 0.1
+        range_min: 0.2
+        range_max: 60.0
+        use_inf: true
+        
+        #concurrency_level affects number of pc queued for processing and the number of threadsused
+        # 0: Detect number of cores
+        # 1: Single threaded
+        # 2: inf : Parallelism level
+        concurrency_level: 1
+      </rosparam>
+    </node>
+
+    <!-- <param name="robot_description" textfile="$(find scout_base)/model/agilex_scout.urdf" /> 
+    <param name="robot_description" command="$(find xacro)/xacro '$(find scout_base)/model/scout.urdf.xacro'" />
+    <node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" /> -->
+</launch>

scout_base/launch/scout_nav_3d.launch

@@ -0,0 +1,20 @@
+<launch>
+    <node name="scout_base_node" pkg="scout_base" type="scout_base_node" output="screen">
+        <param name="port_name" type="string" value="can0" />
+
+        <param name="odom_frame" type="string" value="odom" />
+        <param name="base_frame" type="string" value="base_link" />
+
+        <param name="simulated_robot" type="bool" value="false" />
+    </node>
+
+    <node name="sensor_hub_raw_imu" pkg="scout_base" type="imu_broadcast_node" output="screen"/>
+    <include file="$(find scout_base)/launch/sensor_rslidar16.launch" />
+
+    <!--
+    <include file="$(find scout_base)/launch/sensor_d435i.launch" />
+    -->
+
+    <param name="robot_description" textfile="$(find scout_base)/urdf/agilex_scout.urdf" />
+    <node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" />
+</launch>

scout_base/launch/sensor_d435i.launch

@@ -0,0 +1,103 @@
+<launch>
+  <arg name="serial_no"           default=""/>
+  <arg name="json_file_path"      default=""/>
+  <arg name="camera"              default="camera"/>
+  <arg name="tf_prefix"           default="$(arg camera)"/>
+  <arg name="external_manager"    default="false"/>
+  <arg name="manager"             default="realsense2_camera_manager"/>
+
+  <arg name="fisheye_width"       default="640"/>
+  <arg name="fisheye_height"      default="480"/>
+  <arg name="enable_fisheye"      default="true"/>
+
+  <arg name="depth_width"         default="640"/>
+  <arg name="depth_height"        default="480"/>
+  <arg name="enable_depth"        default="true"/>
+
+  <arg name="infra_width"        default="640"/>
+  <arg name="infra_height"       default="480"/>
+  <arg name="enable_infra1"       default="true"/>
+  <arg name="enable_infra2"       default="true"/>
+
+  <arg name="color_width"         default="640"/>
+  <arg name="color_height"        default="480"/>
+  <arg name="enable_color"        default="true"/>
+
+  <arg name="fisheye_fps"         default="30"/>
+  <arg name="depth_fps"           default="30"/>
+  <arg name="infra_fps"           default="30"/>
+  <arg name="color_fps"           default="30"/>
+  <arg name="gyro_fps"            default="400"/>
+  <arg name="accel_fps"           default="250"/>
+  <arg name="enable_gyro"         default="true"/>
+  <arg name="enable_accel"        default="true"/>
+
+  <arg name="enable_pointcloud"         default="false"/>
+  <arg name="pointcloud_texture_stream" default="RS2_STREAM_COLOR"/>
+  <arg name="pointcloud_texture_index"  default="0"/>
+
+  <arg name="enable_sync"               default="true"/>
+  <arg name="align_depth"               default="false"/>
+
+  <arg name="filters"                   default=""/>
+  <arg name="clip_distance"             default="-2"/>
+  <arg name="linear_accel_cov"          default="0.01"/>
+  <arg name="initial_reset"             default="false"/>
+  <arg name="unite_imu_method"          default="linear_interpolation"/>
+  <arg name="topic_odom_in"             default="odom_in"/>
+  <arg name="calib_odom_file"           default=""/>
+  <arg name="publish_odom_tf"           default="true"/>
+  <arg name="allow_no_texture_points"   default="false"/>
+
+  <group ns="$(arg camera)">
+    <include file="$(find realsense2_camera)/launch/includes/nodelet.launch.xml">
+      <arg name="tf_prefix"                value="$(arg tf_prefix)"/>
+      <arg name="external_manager"         value="$(arg external_manager)"/>
+      <arg name="manager"                  value="$(arg manager)"/>
+      <arg name="serial_no"                value="$(arg serial_no)"/>
+      <arg name="json_file_path"           value="$(arg json_file_path)"/>
+
+      <arg name="enable_pointcloud"        value="$(arg enable_pointcloud)"/>
+      <arg name="pointcloud_texture_stream" value="$(arg pointcloud_texture_stream)"/>
+      <arg name="pointcloud_texture_index"  value="$(arg pointcloud_texture_index)"/>
+      <arg name="enable_sync"              value="$(arg enable_sync)"/>
+      <arg name="align_depth"              value="$(arg align_depth)"/>
+
+      <arg name="fisheye_width"            value="$(arg fisheye_width)"/>
+      <arg name="fisheye_height"           value="$(arg fisheye_height)"/>
+      <arg name="enable_fisheye"           value="$(arg enable_fisheye)"/>
+
+      <arg name="depth_width"              value="$(arg depth_width)"/>
+      <arg name="depth_height"             value="$(arg depth_height)"/>
+      <arg name="enable_depth"             value="$(arg enable_depth)"/>
+
+      <arg name="color_width"              value="$(arg color_width)"/>
+      <arg name="color_height"             value="$(arg color_height)"/>
+      <arg name="enable_color"             value="$(arg enable_color)"/>
+
+      <arg name="infra_width"              value="$(arg infra_width)"/>
+      <arg name="infra_height"             value="$(arg infra_height)"/>
+      <arg name="enable_infra1"            value="$(arg enable_infra1)"/>
+      <arg name="enable_infra2"            value="$(arg enable_infra2)"/>
+
+      <arg name="fisheye_fps"              value="$(arg fisheye_fps)"/>
+      <arg name="depth_fps"                value="$(arg depth_fps)"/>
+      <arg name="infra_fps"                value="$(arg infra_fps)"/>
+      <arg name="color_fps"                value="$(arg color_fps)"/>
+      <arg name="gyro_fps"                 value="$(arg gyro_fps)"/>
+      <arg name="accel_fps"                value="$(arg accel_fps)"/>
+      <arg name="enable_gyro"              value="$(arg enable_gyro)"/>
+      <arg name="enable_accel"             value="$(arg enable_accel)"/>
+
+      <arg name="filters"                  value="$(arg filters)"/>
+      <arg name="clip_distance"            value="$(arg clip_distance)"/>
+      <arg name="linear_accel_cov"         value="$(arg linear_accel_cov)"/>
+      <arg name="initial_reset"            value="$(arg initial_reset)"/>
+      <arg name="unite_imu_method"         value="$(arg unite_imu_method)"/>
+      <arg name="topic_odom_in"            value="$(arg topic_odom_in)"/>
+      <arg name="calib_odom_file"          value="$(arg calib_odom_file)"/>
+      <arg name="publish_odom_tf"          value="$(arg publish_odom_tf)"/>
+      <arg name="allow_no_texture_points"  value="$(arg allow_no_texture_points)"/>
+    </include>
+  </group>
+</launch>

scout_base/launch/sensor_rs16_filter.launch

@@ -0,0 +1,31 @@
+<!--
+  Copyright 2016 The Cartographer Authors
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<launch>
+  <node pkg="nodelet" type="nodelet" name="pcl_manager" args="manager" output="screen" />
+
+  <!-- Run a passthrough filter on the z axis -->
+  <node pkg="nodelet" type="nodelet" name="passthrough_z" args="load pcl/PassThrough pcl_manager" output="screen">
+    <remap from="~input" to="/rslidar_points" />
+    <remap from="~output" to="/points2" />
+    <rosparam>
+      filter_field_name: z
+      filter_limit_min: -0.8
+      filter_limit_max: 1.0
+      filter_limit_negative: False
+    </rosparam>
+  </node>
+</launch>

scout_base/launch/sensor_rslidar16.launch

@@ -0,0 +1,40 @@
+<launch>
+  <arg name="model" default="RS16" />
+  <!--
+  <arg name="device_ip" default="192.168.1.200" />
+  -->
+  <arg name="device_ip" default="10.7.5.103" />
+  <arg name="msop_port" default="6699" />
+  <arg name="difop_port" default="7788" />
+  <arg name="rpm" default="1200" />
+  <arg name="cut_angle" default="0" doc="If set at [0, 360), cut at specific angle feature activated, otherwise use the fixed packets number mode."/>
+  <arg name="lidar_param_path" default="$(find rslidar_pointcloud)/data/rs_lidar_16/"/>
+
+  <node  name="rslidar_node" pkg="rslidar_driver" type="rslidar_node" output="screen" >
+    <param name="model" value="$(arg model)"/>
+    <param name="device_ip" value="$(arg device_ip)" />
+    <param name="msop_port" value="$(arg msop_port)" />
+    <param name="difop_port" value="$(arg difop_port)"/>
+    <param name="cut_angle" value="$(arg cut_angle)"/>
+    <param name="rpm" value="$(arg rpm)"/>
+    <!--param name="pcap" value="path_to_pcap"/-->
+  </node>
+
+  <node  name="cloud_node" pkg="rslidar_pointcloud" type="cloud_node" output="screen" >
+    <param name="model" value="$(arg model)"/>
+    <param name="curves_path" value="$(arg lidar_param_path)/curves.csv" />
+    <param name="angle_path" value="$(arg lidar_param_path)/angle.csv" />
+    <param name="channel_path" value="$(arg lidar_param_path)/ChannelNum.csv" />
+    <param name="max_distance" value="200"/>
+    <param name="min_distance" value="0.4"/>
+    <param name="resolution_type" value="0.5cm"/>
+    <param name="intensity_mode" value="1"/>
+    <!-- remap from="rslidar_points" to="points2" /--> 
+  </node>
+
+  <include file="$(find scout_base)/launch/sensor_rs16_filter.launch" />
+
+  <!--
+  <node name="rviz" pkg="rviz" type="rviz"  args="-d $(find rslidar_pointcloud)/rviz_cfg/rslidar.rviz" />
+  -->
+</launch>

scout_base/package.xml

@@ -14,24 +14,18 @@
   <url type="repository">TODO</url>
 
   <buildtool_depend>catkin</buildtool_depend>
-  <build_depend>controller_manager</build_depend>
-  <build_depend>hardware_interface</build_depend>
   <build_depend>scout_msgs</build_depend>
   <build_depend>roscpp</build_depend>
   <build_depend>roslaunch</build_depend>
   <build_depend>roslint</build_depend>
   <build_depend>sensor_msgs</build_depend>
-
+  <build_depend>scout_sdk</build_depend>
   <run_depend>controller_manager</run_depend>
-  <run_depend>diff_drive_controller</run_depend>
   <run_depend>geometry_msgs</run_depend>
-  <run_depend>hardware_interface</run_depend>
-  <run_depend>scout_control</run_depend>
   <run_depend>scout_msgs</run_depend>
-  <run_depend>scout_description</run_depend>
   <run_depend>roscpp</run_depend>
   <run_depend>sensor_msgs</run_depend>
   <run_depend>topic_tools</run_depend>
-
+  <run_depend>scout_sdk</run_depend>
   <export></export>
 </package>

scout_base/src/imu_broadcast_node.cpp

@@ -0,0 +1,72 @@
+/* 
+ * imu_broadcast_node.cpp
+ * 
+ * Created on: Oct 02, 2019 19:09
+ * Description: 
+ * 
+ * Copyright (c) 2019 Ruixiang Du (rdu)
+ */
+
+#include <string>
+
+#include <lcm/lcm-cpp.hpp>
+#include "lcmtypes/wescore.hpp"
+
+#include <ros/ros.h>
+#include <sensor_msgs/Imu.h>
+
+ros::Publisher imu_pub;
+
+struct MessageBroadcaster
+{
+    void IMULCMCallback(const lcm::ReceiveBuffer *rbuf, const std::string &chan, const wescore_lcm_msgs::IMU *msg)
+    {
+        static uint64_t count = 0;
+        // std::cout << "imu msg received" << std::endl;
+        sensor_msgs::Imu imu_msg;
+        imu_msg.header.frame_id = "imu_link";
+        imu_msg.header.stamp = ros::Time::now();
+        imu_msg.header.seq = count++;
+
+        imu_msg.angular_velocity.x = msg->angular_velocity.x;
+        imu_msg.angular_velocity.y = msg->angular_velocity.y;
+        imu_msg.angular_velocity.z = msg->angular_velocity.z;
+
+        imu_msg.linear_acceleration.x = msg->linear_acceleration.x;
+        imu_msg.linear_acceleration.y = msg->linear_acceleration.y;
+        imu_msg.linear_acceleration.z = msg->linear_acceleration.z;
+
+        for (int i = 0; i < 9; ++i)
+        {
+            imu_msg.orientation_covariance[i] = msg->orientation_covariance[i];
+            imu_msg.angular_velocity_covariance[i] = msg->angular_velocity_covariance[i];
+            imu_msg.linear_acceleration_covariance[i] = msg->linear_acceleration_covariance[i];
+        }
+
+        imu_pub.publish(imu_msg);
+    }
+};
+
+int main(int argc, char **argv)
+{
+    // setup LCM
+    lcm::LCM lcm;
+
+    if (!lcm.good())
+        return 1;
+    MessageBroadcaster mb;
+    lcm.subscribe("sensor_hub_raw_imu", &MessageBroadcaster::IMULCMCallback, &mb);
+
+    // setup ROS node
+    ros::init(argc, argv, "imu_broadcast_node");
+    ros::NodeHandle nh;
+    imu_pub = nh.advertise<sensor_msgs::Imu>("imu", 1000);
+
+    ROS_INFO("Started broadcasting");
+    while (ros::ok())
+    {
+        lcm.handleTimeout(5);
+    }
+
+    return 0;
+}

scout_base/src/scout_base_node.cpp

@@ -1,12 +1,11 @@
 #include <string>
-#include <boost/thread.hpp>
 
 #include <ros/ros.h>
 #include <sensor_msgs/JointState.h>
 #include <tf/transform_broadcaster.h>
 #include <nav_msgs/Odometry.h>
 
-#include "scout/scout_base.hpp"
+#include "scout_sdk/scout_base.hpp"
 #include "scout_base/scout_messenger.hpp"
 
 using namespace wescore;
@@ -15,30 +14,29 @@ int main(int argc, char **argv)
 {
     // setup ROS node
     ros::init(argc, argv, "scout_odom");
-    ros::NodeHandle node("scout_robot"), private_node("~");
+    ros::NodeHandle node(""), private_node("~");
 
     // instantiate a robot
     ScoutBase robot;
-    ScoutROSMessenger messenger(&robot, node);
+    ScoutROSMessenger messenger(&robot, &node);
 
     std::string scout_can_port;
-    private_node.param<std::string>("port_name", scout_can_port, std::string("can1"));
+    private_node.param<std::string>("port_name", scout_can_port, std::string("can0"));
     private_node.param<std::string>("odom_frame", messenger.odom_frame_, std::string("odom"));
-    private_node.param<std::string>("base_frame", messenger.base_frame_, std::string("base_footprint"));
+    private_node.param<std::string>("base_frame", messenger.base_frame_, std::string("base_link"));
     private_node.param<bool>("simulated_robot", messenger.simulated_robot_, false);
 
     // connect to scout and setup ROS subscription
-    robot.ConnectCANBus(scout_can_port);
-    robot.StartCmdThread(10);
+    robot.Connect(scout_can_port);
     messenger.SetupSubscription();
 
     // publish robot state at 20Hz while listening to twist commands
-    ros::Rate rt(20); // 20Hz
+    ros::Rate rate_20hz(20); // 20Hz
     while (true)
     {
         messenger.PublishStateToROS();
         ros::spinOnce();
-        rt.sleep();
+        rate_20hz.sleep();
     }
 
     return 0;

scout_base/src/scout_messenger.cpp

@@ -9,27 +9,29 @@
 
 #include "scout_base/scout_messenger.hpp"
 
+#include <tf/transform_broadcaster.h>
+
 #include "scout_msgs/ScoutStatus.h"
 
 namespace wescore
 {
-ScoutROSMessenger::ScoutROSMessenger(ros::NodeHandle nh) : scout_(nullptr), nh_(nh)
+ScoutROSMessenger::ScoutROSMessenger(ros::NodeHandle *nh) : scout_(nullptr), nh_(nh)
 {
 }
 
-ScoutROSMessenger::ScoutROSMessenger(ScoutBase *scout, ros::NodeHandle nh) : scout_(scout), nh_(nh)
+ScoutROSMessenger::ScoutROSMessenger(ScoutBase *scout, ros::NodeHandle *nh) : scout_(scout), nh_(nh)
 {
 }
 
 void ScoutROSMessenger::SetupSubscription()
 {
     // odometry publisher
-    odom_publisher_ = nh_.advertise<nav_msgs::Odometry>(odom_frame_, 50);
-    status_publisher_ = nh_.advertise<scout_msgs::ScoutStatus>("/scout_status", 10);
+    odom_publisher_ = nh_->advertise<nav_msgs::Odometry>(odom_frame_, 50);
+    status_publisher_ = nh_->advertise<scout_msgs::ScoutStatus>("/scout_status", 10);
 
     // cmd subscriber
-    motion_cmd_subscriber_ = nh_.subscribe<geometry_msgs::Twist>("/cmd_vel", 5, &ScoutROSMessenger::TwistCmdCallback, this); //不启用平滑包则订阅“cmd_vel”
-    light_cmd_subscriber_ = nh_.subscribe<scout_msgs::ScoutLightCmd>("/scout_light_control", 5, &ScoutROSMessenger::LightCmdCallback, this);
+    motion_cmd_subscriber_ = nh_->subscribe<geometry_msgs::Twist>("/cmd_vel", 5, &ScoutROSMessenger::TwistCmdCallback, this); //不启用平滑包则订阅“cmd_vel”
+    light_cmd_subscriber_ = nh_->subscribe<scout_msgs::ScoutLightCmd>("/scout_light_control", 5, &ScoutROSMessenger::LightCmdCallback, this);
 }
 
 void ScoutROSMessenger::TwistCmdCallback(const geometry_msgs::Twist::ConstPtr &msg)
@@ -37,13 +39,13 @@ void ScoutROSMessenger::TwistCmdCallback(const geometry_msgs::Twist::ConstPtr &m
     if (!simulated_robot_)
     {
         scout_->SetMotionCommand(msg->linear.x, msg->angular.z);
-        // ROS_INFO("cmd received:%f, %f", msg->linear.x, msg->angular.z);
     }
     else
     {
         std::lock_guard<std::mutex> guard(twist_mutex_);
         current_twist_ = *msg.get();
     }
+    // ROS_INFO("cmd received:%f, %f", msg->linear.x, msg->angular.z);
 }
 
 void ScoutROSMessenger::GetCurrentMotionCmdForSim(double &linear, double &angular)

scout_base/src/scout_sdk/CHANGELOG.md

@@ -1,15 +0,0 @@
-# Changelog for scout_sdk
-
-## 0.2 (2019-06-14)
-------------------
-* Deprecated initial serial interface support (new one under development)
-* Added full CAN support
-* Improved multi-threading implementation
-* Contributors: Ruixiang Du
-  
-## 0.1 (2019-05-07)
-------------------
-
-* Added basic serial communication support 
-* Provided C++ interface, ROS/LCM demo
-* Contributors: Ruixiang Du

scout_base/src/scout_sdk/CMakeLists.txt

@@ -1,50 +0,0 @@
-cmake_minimum_required(VERSION 3.1.0)
-project(scout_sdk)
-
-# generate symbols for IDE indexer
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-set(RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/devel)
-
-## Set compiler to use c++ 11 features
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-## Put all binary files into /bin and libraries into /lib
-set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
-set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
-set(ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
-
-## Use GNUInstallDirs to install libraries into correct
-# locations on all platforms.
-include(GNUInstallDirs)
-
-## Chosse build type
-set(CMAKE_BUILD_TYPE Release)
-# set(CMAKE_BUILD_TYPE Debug)
-
-set(default_build_type "Release")
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-  message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
-  set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE
-      STRING "Choose the type of build." FORCE)
-  # Set the possible values of build type for cmake-gui
-  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
-    "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
-endif()
-
-## Optionally built modules: ON/OFF
-set(BUILD_TESTS OFF)
-set(BUILD_MONITOR ON)
-
-# Disable monitor if ncurses library is not found
-set(CURSES_NEED_NCURSES TRUE)
-find_package(Curses QUIET)
-
-if(BUILD_MONITOR AND NOT CURSES_FOUND)
-    set(BUILD_MONITOR OFF)
-    message(STATUS "Monitor app will not be built due to missing ncurses library, try: sudo apt install libncurses5-dev")
-endif()
-
-## Add source directories
-add_subdirectory(src)

scout_base/src/scout_sdk/README.md

@@ -1,103 +0,0 @@
-# SDK for AgileX Scout Mobile Base
-
-Copyright (c) 2019 [WestonRobot](https://www.westonrobot.com/)
-
-## Introduction
-
-This software packages provides a C++ interface to communicate with the Scout mobile base, for sending commands to the robot and acquiring latest robot state.
-
-Generally, you only need to instantiate an object of "class ScoutBase", then use the object to programmatically control the robot. Internally, class ScoutBase manages two background threads, one to process CAN messages of the robot state and accordingly update state variables in the ScoutState data structre, and the other to maintain a 50Hz loop and send latest command to the robot base. User can iteratively perform tasks in the main thread and check the robot state or set control commands. 
-
-Refer to "src/demo/demo_scout_can.cpp" for an example.
-
-## Package Structure
-
-* demo: demo to illustrate how to use the SDK
-* monitor: a TUI application to monitor states of Scout
-* sdk_core/scout_base: interface to send command to robot and receive robot state
-* sdk_core/async_io: manages raw data communication with robot
-* third_party
-    - asio: asynchronous IO management (serial and CAN)
-    - googletest: for unit tests only (not required otherwise)
-
-## Hardware Interface
-
-* CAN: full support
-* RS-232: under development
-
-A easy and low-cost option to use the CAN interface would be using a Raspberry Pi or Beaglebone board with CAN Hat/Cape. The SDK can compile on both x86 and ARM platforms. Then you can use whatever interface you prefer (serial, USB, Ethernet etc.) for the communication between the single-board computer and your main PC.
-
-* Setup CAN-To-USB adapter 
- 
-The intructions work for stm32f0-based adapter with [candleLight](https://github.com/HubertD/candleLight_fw) firmware on a host computer running Linux. (Refer to limitations listed at the bottom for more details.)
-
-1. Enable gs_usb kernel module
-    ```
-    $ sudo modprobe gs_usb
-    ```
-2. Bringup can device
-   ```
-   $ sudo ip link set can0 up type can bitrate 500000
-   ```
-3. If no error occured during the previous steps, you should be able to see the can device now by using command
-   ```
-   $ ifconfig -a
-   ```
-4. Install and use can-utils to test the hardware
-    ```
-    $ sudo apt install can-utils
-    ```
-5. Testing command
-    ```
-    # receiving data from can0
-    $ candump can0
-    # send data to can0
-    $ cansend can0 001#1122334455667788
-    ```
-
-## Build SDK
-
-Install compile tools
-
-```
-$ sudo apt install build-essential cmake
-```
-
-If you want to build the monitor, install libncurses
-
-```
-$ sudo apt install libncurses5-dev
-```
-
-Configure and build
-
-```
-$ cd scout_sdk 
-$ mkdir build
-$ cd build
-$ cmake ..
-$ make
-```
-
-## Known Limitations
-
-1. The CAN interface requires the hardware to appear as a CAN device in the system. You can use the command "ifconfig" to check the interface status. For example, you may see something like
-
-    ```
-    can1: flags=193<UP,RUNNING,NOARP>  mtu 16
-            unspec 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00  txqueuelen 10  (UNSPEC)
-            RX packets 4751634  bytes 38013072 (36.2 MiB)
-            RX errors 0  dropped 0  overruns 0  frame 0
-            TX packets 126269  bytes 1010152 (986.4 KiB)
-            TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
-            device interrupt 43
-    ```
-    
-    If you use a CAN-to-USB adapter, make sure it supports slcan or can be brought up as a native CAN device (for example, CANable https://www.canable.io/). Some adapters may use a custom-defined protocol and appear as a serial device in Linux. In such case, you will have to translate the byte stream between CAN and UART by yourself. It would be difficult for us to provide support for them since not all manufactures define this protocol in the same way.
-
-2. Release v0.1 of this SDK provided a serial interface to talk with the robot. Front/rear light on the robot cannot be controlled and only a small subset of all robot states can be acquired through that interface. Full support of the serial interface is still under development and requires additional work on both the SDK and firmware sides.
-
-## Reference
-
-* [Candlelight firmware](https://wiki.linklayer.com/index.php/CandleLightFirmware)
-* [CAN command reference in Linux](https://wiki.rdu.im/_pages/Notes/Embedded-System/Linux/can-bus-in-linux.html)

scout_base/src/scout_sdk/docs/beaglebone_black_can_cape.md

@@ -1,23 +0,0 @@
-# Setup CAN on Beaglebone Black
-
-CAN/RS485 Cape: https://item.taobao.com/item.htm?spm=a1z09.2.0.0.68b02e8d02l2uT&id=42637485181&_u=a4mg52ma183
-
-* Install latest Debian image from offical site
-* Build and install overlays
-```
-$ sudo apt install device-tree-compiler
-$ git clone https://github.com/beagleboard/bb.org-overlays
-$ cd ./bb.org-overlays/
-$ ./install.sh
-```
-* Edit /boot/uEnv.txt
-```
-# 1. Add the following overlay
-###Custom Cape
-dtb_overlay=/lib/firmware/BB-CAN1-00A0.dtbo
-
-# 2. Disable auto loading of virutal capes (uncomment the two lines)
-disable_uboot_overlay_video=1
-disable_uboot_overlay_audio=1
-```
-* Reboot the system

scout_base/src/scout_sdk/docs/beaglebone_ros_install.md

@@ -1,51 +0,0 @@
-```
-$ sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu stretch main" > /etc/apt/sources.list.d/ros-latest.list'
-$ wget https://raw.githubusercontent.com/ros/rosdistro/master/ros.key  -O - | sudo apt-key add -
-$ sudo apt-get update
-```
-
-```
-$ sudo apt-get install -y python-pip python-setuptools python-yaml python-distribute python-docutils python-dateutil python-six
-$ sudo pip install rosdep rosinstall_generator wstool rosinstall
-$ sudo apt-get install -y \
-     libconsole-bridge-dev liblz4-dev checkinstall cmake \
-     python-empy python-nose libbz2-dev \
-     libboost-test-dev libboost-dev  libboost-program-options-dev \
-     libboost-regex-dev libboost-signals-dev \
-     libtinyxml-dev libboost-filesystem-dev libxml2-dev \
-     libgtest-dev libpoco-dev
-```
-
-```
-$ sudo rosdep init
-$ rosdep update
-```
-
-```
-$ rosinstall_generator ros_comm --rosdistro melodic --deps --tar > melodic-ros_comm.rosinstall
-$ wstool init -j1 src melodic-ros_comm.rosinstall
-```
-
-```
-$ # rosdep install --from-paths src --ignore-src --rosdistro melodic -y
-$ sudo ./src/catkin/bin/catkin_make_isolated --install --install-space /opt/ros/melodic -DCMAKE_BUILD_TYPE=Release
-```
-
-```
-$ source /opt/ros/melodic/setup.bash
-```
-
-Additional runtime dependencies:
-
-```
-$ sudo apt install -y python-defusedxml python-netifaces
-```
-
-```
-$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys F42ED6FBAB17C654
-```
-
-Reference:
-
-* [1] https://machinekoder.com/ros-with-debian-stretch-on-the-beaglebone-black-green-blue/
-* [2] http://wiki.ros.org/melodic/Installation/Source

scout_base/src/scout_sdk/docs/check_endianness.md

@@ -1,36 +0,0 @@
-On a Big Endian-System (Solaris on SPARC)
-
-```
-$ echo -n I | od -to2 | head -n1 | cut -f2 -d" " | cut -c6 
-0
-```
-On a little endian system (Linux on x86)
-```
-$ echo -n I | od -to2 | head -n1 | cut -f2 -d" " | cut -c6 
-1
-```
-The solution above is clever and works great for Linux *86 and Solaris Sparc.
-
-I needed a shell-only (no Perl) solution that also worked on AIX/Power and HPUX/Itanium. Unfortunately the last two don't play nice: AIX reports "6" and HPUX gives an empty line.
-
-Using your solution, I was able to craft something that worked on all these Unix systems:
-```
-$ echo I | tr -d [:space:] | od -to2 | head -n1 | awk '{print $2}' | cut -c6
-```
-Regarding the Python solution someone posted, it does not work in Jython because the JVM treats everything as Big. If anyone can get it to work in Jython, please post!
-
-Also, I found this, which explains the endianness of various platforms. Some hardware can operate in either mode depending on what the O/S selects: http://labs.hoffmanlabs.com/node/544
-
-If you're going to use awk this line can be simplified to:
-```
-echo -n I | od -to2 | awk '{ print substr($2,6,1); exit}'
-```
-For small Linux boxes that don't have 'od' (say OpenWrt) then try 'hexdump':
-```
-echo -n I | hexdump -o | awk '{ print substr($2,6,1); exit}'
-```
-
-Reference: 
-
-* [1] https://serverfault.com/questions/163487/how-to-tell-if-a-linux-system-is-big-endian-or-little-endian
-* [2] https://wiki.rdu.im/_pages/Knowledge-Base/Computing/Computing.html

scout_base/src/scout_sdk/docs/commands.md

@@ -1,55 +0,0 @@
-# Commands
-
-## Create gif animation using "imagemagick"
-
-```
-$ convert -delay 120 -loop 0 *.png animated.gif
-```
-
-## Get statistics of the code base
-
-```
-$ sudo apt install cloc
-$ cd ~/Workspace/librav/src
-$ cloc --exclude-dir=cmake,lcmtypes,third_party .
-```
-
-## Create a pair of VSP’s
-
-```
-$ socat -d -d pty,raw,echo=0 pty,raw,echo=0
-```
-
-```
-$ cat nmea_test.txt > /dev/pts/6
-```
-
-## git subtree
-
-Adding the sub-project as a remote
-```
-$ git remote add -f [remote-name] [remote-url]
-$ git subtree add --prefix [sub-project-name] [remote-name] [branch-name] --squash
-```
-
-Update the sub-project
-```
-$ git fetch [remote-name] [branch-name] 
-$ git subtree pull --prefix [sub-project-name] [remote-name] [branch-name] --squash
-```
-
-Push to remote
-```
-$ git subtree push --prefix=[sub-project-name] [remote-name] [branch-name] 
-```
-
-Firmware branch update
-```
-$ git fetch fw_origin pios_pixcar
-$ git subtree pull --prefix firmware fw_origin pios_pixcar --squash
-```
-
-## Reference
-
-* [Git subtree: the alternative to Git submodule](https://www.atlassian.com/blog/git/alternatives-to-git-submodule-git-subtree)
-* [Virtual serial port: socat](https://justcheckingonall.wordpress.com/2009/06/09/howto-vsp-socat/)

scout_base/src/scout_sdk/docs/jetson_tx2_can.md

@@ -1,12 +0,0 @@
-# Enable CAN on Jetson TX2
-
-```
-$ sudo modprobe can
-$ sudo modprobe mttcan
-$ sudo ip link set can0 type can bitrate 500000
-$ sudo ip link set up can0
-```
-
-Reference:
-
-* https://devtalk.nvidia.com/default/topic/1006762/jetson-tx2/how-can-i-use-can-bus-in-tx2-/post/5166583/#5166583

scout_base/src/scout_sdk/docs/release_checklist.md

@@ -1 +0,0 @@
-* Disable tests to keep minimal dependency by default

scout_base/src/scout_sdk/docs/test_can_msg.txt

@@ -1,7 +0,0 @@
-  can1  131   [8]  00 00 00 00 00 00 E4 1E
-  can1  141   [8]  00 00 00 02 0E 00 E3 3D
-  can1  151   [8]  01 00 00 EF 00 3C E5 6B
-  can1  200   [8]  00 00 00 00 00 00 EA F4
-  can1  201   [8]  00 00 00 00 00 00 EA F5
-  can1  202   [8]  00 00 00 00 00 00 EA F6
-  can1  203   [8]  00 00 00 00 00 00 EA F7

scout_base/src/scout_sdk/scripts/remote_ws/beaglebone_black.code-workspace

@@ -1,6 +0,0 @@
-{
-    "folders": [{
-        "uri": "sftp://rdu:rdu3317*@192.168.7.2/home/rdu/Workspace/scout_sdk",
-        "name": "Scout SDK Workspace"
-    }]
-}

scout_base/src/scout_sdk/src/CMakeLists.txt

@@ -1,8 +0,0 @@
-# Add source directories
-add_subdirectory(demo)
-add_subdirectory(sdk_core)
-add_subdirectory(third_party)
-
-if(BUILD_MONITOR)
-add_subdirectory(monitor)
-endif()

scout_base/src/scout_sdk/src/demo/CMakeLists.txt

@@ -1,6 +0,0 @@
-# Dependency libraries
-#find_package(LIBRARY_NAME REQUIRED)
-
-# tests
-add_executable(demo_scout_can demo_scout_can.cpp)
-target_link_libraries(demo_scout_can scoutbase)

scout_base/src/scout_sdk/src/demo/demo_scout_can.cpp

@@ -1,42 +0,0 @@
-/* 
- * demo_scout_can.cpp
- * 
- * Created on: Jun 12, 2019 05:03
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */ 
-
-#include "scout/scout_base.hpp"
-
-using namespace wescore;
-
-int main(int argc, char **argv)
-{
-    ScoutBase scout;
-    scout.ConnectCANBus("can0");
-    scout.StartCmdThread(10);
-
-    scout.SetLightCommand({ScoutLightCmd::LightMode::CONST_ON, 0, ScoutLightCmd::LightMode::CONST_ON, 0});
-
-    int count = 0;
-    while (true)
-    {
-        scout.SetMotionCommand(0.5, 0.2);
-
-        if (count == 10)
-            scout.SetLightCommand({ScoutLightCmd::LightMode::CONST_OFF, 0, ScoutLightCmd::LightMode::CONST_OFF, 0});
-
-        auto state = scout.GetScoutState();
-        std::cout << "-------------------------------" << std::endl;
-        std::cout << "control mode: " << static_cast<int>(state.control_mode) << " , base state: " << static_cast<int>(state.base_state) << std::endl;
-        std::cout << "battery voltage: " << state.battery_voltage << std::endl;
-        std::cout << "velocity (linear, angular): " << state.linear_velocity << ", " << state.angular_velocity << std::endl;
-        std::cout << "-------------------------------" << std::endl;
-
-        sleep(1);
-        ++count;
-    }
-
-    return 0;
-}

scout_base/src/scout_sdk/src/monitor/CMakeLists.txt

@@ -1,24 +0,0 @@
-# Dependency libraries
-set(CURSES_NEED_NCURSES TRUE)
-find_package(Curses REQUIRED)
-
-# Add libraries
-set(SCOUT_MONITOR_SRC
-    src/nshapes.cpp
-    src/ncolors.cpp
-    src/scout_monitor.cpp
-)
-add_library(monitor STATIC ${SCOUT_MONITOR_SRC})
-target_link_libraries(monitor scoutbase ${CURSES_LIBRARIES})
-target_include_directories(monitor PUBLIC
-	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-    $<BUILD_INTERFACE:${CURSES_INCLUDE_DIR}>
-	$<INSTALL_INTERFACE:include>
-	PRIVATE src)
-
-add_subdirectory(app)
-
-# Add executables
-if(BUILD_TESTS)
-	add_subdirectory(tests)
-endif()

scout_base/src/scout_sdk/src/monitor/app/CMakeLists.txt

@@ -1,3 +0,0 @@
-# Add executables
-add_executable(scout_monitor app_scout_monitor.cpp)
-target_link_libraries(scout_monitor monitor)

scout_base/src/scout_sdk/src/monitor/app/app_scout_monitor.cpp

@@ -1,31 +0,0 @@
-#include <signal.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <iostream>
-
-#include "monitor/scout_monitor.hpp"
-
-using namespace wescore;
-
-int main(int argc, char **argv)
-{
-    std::string device_name;
-
-    if (argc == 2)
-    {
-        device_name = {argv[1]};
-        std::cout << "Specified device: " << device_name << std::endl;
-    }
-    else
-    {
-        std::cout << "Usage: app_scout_monitor <interface>" << std::endl
-                  << "Example: ./app_scout_monitor can1" << std::endl;
-        return -1;
-    }
-
-    ScoutMonitor monitor;
-    monitor.Run(device_name);
-
-    return 0;
-}

scout_base/src/scout_sdk/src/monitor/include/monitor/ncolors.hpp

@@ -1,67 +0,0 @@
-/* 
- * ncolors.hpp
- * 
- * Created on: Jun 20, 2019 06:22
- * Description: 
- * 
- * Original source: https://www.linuxjournal.com/content/about-ncurses-colors-0
- * This copy is based on the original implementation, modified and 
- *  maintained by Ruixiang.
- * 
- * Copyright (c) 2018 Jim Hall
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef NCOLORS_HPP
-#define NCOLORS_HPP
-
-#include <ncurses.h>
-
-namespace wescore
-{
-struct NColors
-{
-    enum BackgroundColor
-    {
-        BLACK = 0,
-        BLUE,
-        GREEN,
-        CYAN,
-        RED,
-        MAGENTA,
-        YELLOW,
-        WHITE
-    };
-
-    enum ForegroundColor
-    {
-        /*
-        BLACK = 0,
-        BLUE,
-        GREEN,
-        CYAN,
-        RED,
-        MAGENTA,
-        YELLOW,
-        WHITE,*/
-        BRIGHT_BLACK = 8,
-        BRIGHT_BLUE,
-        BRIGHT_GREEN,
-        BRIGHT_CYAN,
-        BRIGHT_RED,
-        BRIGHT_MAGENTA,
-        BRIGHT_YELLOW,
-        BRIGHT_WHITE
-    };
-
-    static void InitColors();
-
-    static void SetColor(int fg, int bg = BLACK);
-    static void UnsetColor(int fg, int bg = BLACK);
-    
-    static void WSetColor(WINDOW *win, int fg, int bg = BLACK);
-    static void WUnsetColor(WINDOW *win, int fg, int bg = BLACK);
-};
-} // namespace wescore
-
-#endif /* NCOLORS_HPP */

scout_base/src/scout_sdk/src/monitor/include/monitor/nshapes.hpp

@@ -1,24 +0,0 @@
-/* 
- * nshapes.hpp
- * 
- * Created on: Jun 20, 2019 06:21
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef NSHAPES_HPP
-#define NSHAPES_HPP
-
-#include <ncurses.h>
-
-namespace wescore
-{
-struct NShapes
-{
-    static void DrawRectangle(int tl_y, int tl_x, int br_y, int br_x);
-    static void WDrawRectangle(WINDOW *win, int tl_y, int tl_x, int br_y, int br_x);
-};
-} // namespace wescore
-
-#endif /* NSHAPES_HPP */

scout_base/src/scout_sdk/src/monitor/include/monitor/scout_monitor.hpp

@@ -1,79 +0,0 @@
-/* 
- * scout_monitor.hpp
- * 
- * Created on: Jun 12, 2019 01:19
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef SCOUT_MONITOR_HPP
-#define SCOUT_MONITOR_HPP
-
-#include "scout/scout_base.hpp"
-#include "scout/scout_state.hpp"
-
-#include <ncurses.h>
-
-namespace wescore
-{
-class ScoutMonitor
-{
-public:
-    ScoutMonitor();
-    ~ScoutMonitor();
-
-    void Run(std::string device_name = "");
-    void Terminate() { keep_running_ = false; }
-
-private:
-    bool keep_running_ = true;
-    bool test_mode_ = true;
-
-    int term_sx_ = -1;
-    int term_sy_ = -1;
-
-    WINDOW *body_info_win_;
-    int bi_win_sx_;
-    int bi_win_sy_;
-    int bi_origin_x_;
-    int bi_origin_y_;
-
-    WINDOW *system_info_win_;
-    int si_win_sx_;
-    int si_win_sy_;
-    int si_origin_x_;
-    int si_origin_y_;
-
-    WINDOW *scout_cmd_win_;
-
-    ScoutBase scout_base_;
-    ScoutState scout_state_;
-
-    const int linear_axis_length_ = 5;
-    const int angular_axis_length_ = 5;
-
-    const int vehicle_fp_offset_x_ = 9;
-    const int vehicle_fp_offset_y_ = 9;
-
-    bool resizing_detected_;
-
-    void UpdateAll();
-    void ClearAll();
-
-    void CalcDimensions();
-    void HandleResizing();
-
-    void SetTestStateData();
-    void ShowVehicleState(int y, int x);
-    void ShowStatusItemName(int y, int x, std::string name);
-    void ShowFault(int y, int x, bool no_fault);
-    void ShowMotorInfo(int y, int x, double cur, int rpm, int temp, bool is_right);
-
-    void UpdateScoutBodyInfo();
-    void UpdateScoutSystemInfo();
-    void UpdateScoutCmdWindow();
-};
-} // namespace wescore
-
-#endif /* SCOUT_MONITOR_HPP */

scout_base/src/scout_sdk/src/monitor/src/ncolors.cpp

@@ -1,114 +0,0 @@
-/* 
- * ncolors.cpp
- * 
- * Created on: Jun 20, 2019 06:22
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#include "monitor/ncolors.hpp"
-
-#include <iostream>
-
-namespace
-{
-int IsBold(int fg)
-{
-    /* return the intensity bit */
-
-    int i;
-
-    i = 1 << 3;
-    return (i & fg);
-}
-
-int ColorNum(int fg, int bg)
-{
-    int B, bbb, ffff;
-
-    B = 1 << 7;
-    bbb = (7 & bg) << 4;
-    ffff = 7 & fg;
-
-    return (B | bbb | ffff);
-}
-
-short CursorColor(int fg)
-{
-    switch (7 & fg)
-    {       /* RGB */
-    case 0: /* 000 */
-        return (COLOR_BLACK);
-    case 1: /* 001 */
-        return (COLOR_BLUE);
-    case 2: /* 010 */
-        return (COLOR_GREEN);
-    case 3: /* 011 */
-        return (COLOR_CYAN);
-    case 4: /* 100 */
-        return (COLOR_RED);
-    case 5: /* 101 */
-        return (COLOR_MAGENTA);
-    case 6: /* 110 */
-        return (COLOR_YELLOW);
-    case 7: /* 111 */
-        return (COLOR_WHITE);
-    }
-}
-} // namespace
-
-namespace wescore
-{
-void NColors::InitColors()
-{
-    if (has_colors() != FALSE)
-        start_color();
-    else
-        std::cerr << "Your terminal does not support color" << std::endl;
-
-    int fg, bg;
-    int colorpair;
-
-    for (bg = 0; bg <= 7; bg++)
-    {
-        for (fg = 0; fg <= 7; fg++)
-        {
-            colorpair = ColorNum(fg, bg);
-            init_pair(colorpair, CursorColor(fg), CursorColor(bg));
-        }
-    }
-}
-
-void NColors::SetColor(int fg, int bg)
-{
-    // set the color pair (ColorNum) and bold/bright (A_BOLD)
-    attron(COLOR_PAIR(ColorNum(fg, bg)));
-    if (IsBold(fg))
-        attron(A_BOLD);
-}
-
-void NColors::UnsetColor(int fg, int bg)
-{
-    // unset the color pair (ColorNum) and bold/bright (A_BOLD)
-    attroff(COLOR_PAIR(ColorNum(fg, bg)));
-    if (IsBold(fg))
-        attroff(A_BOLD);
-}
-
-void NColors::WSetColor(WINDOW *win, int fg, int bg)
-{
-    // set the color pair (ColorNum) and bold/bright (A_BOLD)
-    wattron(win, COLOR_PAIR(ColorNum(fg, bg)));
-    if (IsBold(fg))
-        wattron(win, A_BOLD);
-}
-
-void NColors::WUnsetColor(WINDOW *win, int fg, int bg)
-{
-    // unset the color pair (ColorNum) and bold/bright (A_BOLD)
-    wattroff(win, COLOR_PAIR(ColorNum(fg, bg)));
-    if (IsBold(fg))
-        wattroff(win, A_BOLD);
-}
-} // namespace wescore

scout_base/src/scout_sdk/src/monitor/src/nshapes.cpp

@@ -1,41 +0,0 @@
-/* 
- * nshapers.cpp
- * 
- * Created on: Jun 20, 2019 06:21
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#include "monitor/nshapes.hpp"
-
-namespace wescore
-{
-void NShapes::DrawRectangle(int tl_y, int tl_x, int br_y, int br_x)
-{
-    for (int i = tl_y; i <= br_y; ++i)
-    {
-        mvprintw(i, tl_x, "|");
-        mvprintw(i, br_x, "|");
-    }
-    for (int i = tl_x; i <= br_x; ++i)
-    {
-        mvprintw(tl_y, i, "-");
-        mvprintw(br_y, i, "-");
-    }
-}
-
-void NShapes::WDrawRectangle(WINDOW *win, int tl_y, int tl_x, int br_y, int br_x)
-{
-    for (int i = tl_y; i <= br_y; ++i)
-    {
-        mvwprintw(win, i, tl_x, "|");
-        mvwprintw(win, i, br_x, "|");
-    }
-    for (int i = tl_x; i <= br_x; ++i)
-    {
-        mvwprintw(win, tl_y, i, "-");
-        mvwprintw(win, br_y, i, "-");
-    }
-}
-} // namespace wescore

scout_base/src/scout_sdk/src/monitor/src/scout_monitor.cpp

@@ -1,654 +0,0 @@
-/* 
- * scout_monitor.cpp
- * 
- * Created on: Jun 12, 2019 01:19
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-/*
- * Coordinate System:
- *
- *		o --------------------> x
- *		|
- *		|
- *		|
- *		|
- *		|
- *		|
- *		v
- *		y
- */
-
-#include "monitor/scout_monitor.hpp"
-
-#include <cmath>
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-
-#include <algorithm>
-#include <array>
-#include <chrono>
-#include <cstdint>
-#include <ratio>
-#include <thread>
-
-#include "scout/scout_can_protocol.h"
-#include "scout/scout_command.hpp"
-#include "monitor/nshapes.hpp"
-#include "monitor/ncolors.hpp"
-
-namespace
-{
-// reference: https://thispointer.com/c-convert-double-to-string-and-manage-precision-scientific-notation/
-std::string ConvertFloatToString(double vel, int digit_num = 3)
-{
-    std::ostringstream streamObj;
-    streamObj << std::fixed;
-    streamObj << std::setprecision(digit_num);
-    streamObj << vel;
-    return streamObj.str();
-}
-
-// source: https://github.com/rxdu/stopwatch
-struct StopWatch
-{
-    using Clock = std::chrono::high_resolution_clock;
-    using time_point = typename Clock::time_point;
-    using duration = typename Clock::duration;
-
-    StopWatch() { tic_point = Clock::now(); };
-
-    time_point tic_point;
-
-    void tic()
-    {
-        tic_point = Clock::now();
-    };
-
-    double toc()
-    {
-        return std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - tic_point).count() / 1000000.0;
-    };
-
-    // for different precisions
-    double stoc()
-    {
-        return std::chrono::duration_cast<std::chrono::seconds>(Clock::now() - tic_point).count();
-    };
-
-    double mtoc()
-    {
-        return std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - tic_point).count();
-    };
-
-    double utoc()
-    {
-        return std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - tic_point).count();
-    };
-
-    double ntoc()
-    {
-        return std::chrono::duration_cast<std::chrono::nanoseconds>(Clock::now() - tic_point).count();
-    };
-
-    // you have to call tic() before calling this function
-    void sleep_until_ms(int64_t period_ms)
-    {
-        int64_t duration = period_ms - std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - tic_point).count();
-
-        if (duration > 0)
-            std::this_thread::sleep_for(std::chrono::milliseconds(duration));
-    };
-
-    void sleep_until_us(int64_t period_us)
-    {
-        int64_t duration = period_us - std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - tic_point).count();
-
-        if (duration > 0)
-            std::this_thread::sleep_for(std::chrono::microseconds(duration));
-    };
-};
-} // namespace
-
-namespace wescore
-{
-ScoutMonitor::ScoutMonitor()
-{
-    // init ncurses
-    initscr();
-    // raw();
-    cbreak();
-    noecho();
-    nonl();
-    curs_set(FALSE);
-    intrflush(stdscr, FALSE);
-    keypad(stdscr, TRUE);
-
-    CalcDimensions();
-
-    // setup sub-windows
-    body_info_win_ = newwin(bi_win_sy_, bi_win_sx_, bi_origin_y_, bi_origin_x_);
-    system_info_win_ = newwin(si_win_sy_, si_win_sx_, si_origin_y_, si_origin_x_);
-
-    NColors::InitColors();
-}
-
-ScoutMonitor::~ScoutMonitor()
-{
-    delwin(body_info_win_);
-    delwin(system_info_win_);
-    endwin();
-}
-
-void ScoutMonitor::UpdateAll()
-{
-    ClearAll();
-
-    CalcDimensions();
-    if (resizing_detected_)
-        HandleResizing();
-
-    UpdateScoutBodyInfo();
-    UpdateScoutSystemInfo();
-}
-
-void ScoutMonitor::SetTestStateData()
-{
-    scout_state_.base_state = BASE_NORMAL;
-    scout_state_.battery_voltage = 28.5;
-
-    scout_state_.linear_velocity = 1.234;
-    scout_state_.angular_velocity = -0.6853;
-
-    // scout_state_.fault_code |= MOTOR_DRV_OVERHEAT_W;
-    // scout_state_.fault_code |= MOTOR_OVERCURRENT_W;
-    // scout_state_.fault_code |= MOTOR_DRV_OVERHEAT_F;
-    // scout_state_.fault_code |= MOTOR_OVERCURRENT_F;
-    // scout_state_.fault_code |= BAT_UNDER_VOL_W;
-    // scout_state_.fault_code |= BAT_UNDER_VOL_F;
-    scout_state_.fault_code = 0x0000;
-    // scout_state_.fault_code = 0xffff;
-
-    // scout_state_.front_light_state.mode = CONST_ON;
-    scout_state_.front_light_state.mode = CUSTOM;
-    scout_state_.front_light_state.custom_value = 50;
-
-    scout_state_.rear_light_state.mode = CONST_ON;
-
-    scout_state_.motor_states[0].current = 10.1;
-    scout_state_.motor_states[0].rpm = 2000;
-    scout_state_.motor_states[0].temperature = 35;
-
-    scout_state_.motor_states[1].current = 10.1;
-    scout_state_.motor_states[1].rpm = 2000;
-    scout_state_.motor_states[1].temperature = 35;
-
-    scout_state_.motor_states[2].current = 10.1;
-    scout_state_.motor_states[2].rpm = 2000;
-    scout_state_.motor_states[2].temperature = 35;
-
-    scout_state_.motor_states[3].current = 10.1;
-    scout_state_.motor_states[3].rpm = 2000;
-    scout_state_.motor_states[3].temperature = 35;
-}
-
-void ScoutMonitor::Run(std::string device_name)
-{
-    if (device_name != "")
-        test_mode_ = false;
-
-    if (test_mode_)
-        SetTestStateData();
-    else
-        scout_base_.ConnectCANBus(device_name);
-
-    StopWatch sw;
-    while (keep_running_)
-    {
-        // label starting point of iteration
-        sw.tic();
-
-        // query for latest robot state
-        if (!test_mode_)
-            scout_state_ = scout_base_.GetScoutState();
-
-        // update window contents
-        UpdateAll();
-
-        // manage window refresh rate
-        sw.sleep_until_ms(100);
-    }
-}
-
-void ScoutMonitor::CalcDimensions()
-{
-    int sy, sx;
-    getmaxyx(stdscr, sy, sx);
-
-    if (sy != term_sy_ || sx != term_sx_)
-    {
-        resizing_detected_ = true;
-
-        term_sy_ = sy;
-        term_sx_ = sx;
-
-        bi_win_sy_ = term_sy_;
-        bi_win_sx_ = term_sx_ * 15 / 24;
-        bi_origin_y_ = 0;
-        bi_origin_x_ = 0;
-
-        si_win_sy_ = term_sy_;
-        si_win_sx_ = term_sx_ * 9 / 24;
-        si_origin_y_ = 0;
-        si_origin_x_ = bi_win_sx_;
-    }
-}
-
-void ScoutMonitor::HandleResizing()
-{
-    delwin(body_info_win_);
-    delwin(system_info_win_);
-
-    body_info_win_ = newwin(bi_win_sy_, bi_win_sx_, bi_origin_y_, bi_origin_x_);
-    system_info_win_ = newwin(si_win_sy_, si_win_sx_, si_origin_y_, si_origin_x_);
-
-    resizing_detected_ = false;
-}
-
-void ScoutMonitor::ClearAll()
-{
-    wclear(body_info_win_);
-    wclear(system_info_win_);
-}
-
-void ScoutMonitor::ShowVehicleState(int y, int x)
-{
-    // show linear velocity
-    const int linear_axis_x = x + vehicle_fp_offset_x_;
-    const int linear_axis_tip_y = y + 2;
-    const int linear_axis_origin_y = linear_axis_tip_y + linear_axis_length_;
-    const int linear_axis_negative_y = linear_axis_origin_y + linear_axis_length_ + 1;
-    mvwprintw(body_info_win_, linear_axis_tip_y - 1, linear_axis_x, "^");
-    for (int i = linear_axis_tip_y; i < linear_axis_origin_y; ++i)
-        mvwprintw(body_info_win_, i, linear_axis_x, "-");
-    mvwprintw(body_info_win_, linear_axis_origin_y, linear_axis_x, "x");
-    for (int i = linear_axis_origin_y + 1; i < linear_axis_negative_y; ++i)
-        mvwprintw(body_info_win_, i, linear_axis_x, "-");
-    mvwprintw(body_info_win_, linear_axis_negative_y, linear_axis_x, "v");
-    double linear_percentage = scout_state_.linear_velocity / ScoutMotionCmd::max_linear_velocity;
-    int linear_bars = std::abs(static_cast<int>(linear_percentage * 5)) + 1;
-    if (std::abs(scout_state_.linear_velocity) < 0.001)
-        linear_bars = 0;
-    if (linear_bars > 5)
-        linear_bars = 5;
-    if (scout_state_.linear_velocity > 0)
-    {
-        for (int i = linear_axis_origin_y - linear_bars; i < linear_axis_origin_y; ++i)
-        {
-            NColors::WSetColor(body_info_win_, NColors::BLACK, NColors::CYAN);
-            mvwprintw(body_info_win_, i, linear_axis_x, "-");
-            NColors::WUnsetColor(body_info_win_, NColors::BLACK, NColors::CYAN);
-        }
-    }
-    else if (scout_state_.linear_velocity < 0)
-    {
-        for (int i = linear_axis_origin_y + linear_bars; i > linear_axis_origin_y; --i)
-        {
-            NColors::WSetColor(body_info_win_, NColors::BLACK, NColors::CYAN);
-            mvwprintw(body_info_win_, i, linear_axis_x, "-");
-            NColors::WUnsetColor(body_info_win_, NColors::BLACK, NColors::CYAN);
-        }
-    }
-
-    // show angular velocity
-    const int angular_axis_y = linear_axis_origin_y;
-    const int angular_axis_origin_x = linear_axis_x;
-    const int angular_axis_positive_x = angular_axis_origin_x + angular_axis_length_ + 1;
-    const int angular_axis_negative_x = angular_axis_origin_x - angular_axis_length_;
-    mvwprintw(body_info_win_, angular_axis_y, angular_axis_negative_x - 1, "<");
-    for (int i = angular_axis_negative_x; i < angular_axis_origin_x; ++i)
-        mvwprintw(body_info_win_, angular_axis_y, i, "-");
-    mvwprintw(body_info_win_, linear_axis_origin_y, linear_axis_x, "x");
-    for (int i = angular_axis_origin_x + 1; i < angular_axis_positive_x; ++i)
-        mvwprintw(body_info_win_, angular_axis_y, i, "-");
-    mvwprintw(body_info_win_, angular_axis_y, angular_axis_positive_x, ">");
-
-    double angular_percentage = scout_state_.angular_velocity / ScoutMotionCmd::max_angular_velocity;
-    int angular_bars = std::abs(static_cast<int>(angular_percentage * 5)) + 1;
-    if (std::abs(scout_state_.angular_velocity) < 0.001)
-        angular_bars = 0;
-    if (angular_bars > 5)
-        angular_bars = 5;
-    if (scout_state_.angular_velocity < 0)
-    {
-        for (int i = angular_axis_origin_x + angular_bars; i > angular_axis_origin_x; --i)
-        {
-            NColors::WSetColor(body_info_win_, NColors::BLACK, NColors::MAGENTA);
-            mvwprintw(body_info_win_, angular_axis_y, i, "-");
-            NColors::WUnsetColor(body_info_win_, NColors::BLACK, NColors::MAGENTA);
-        }
-    }
-    else if (scout_state_.angular_velocity > 0)
-    {
-        for (int i = angular_axis_origin_x - angular_bars; i < angular_axis_origin_x; ++i)
-        {
-            NColors::WSetColor(body_info_win_, NColors::BLACK, NColors::MAGENTA);
-            mvwprintw(body_info_win_, angular_axis_y, i, "-");
-            NColors::WUnsetColor(body_info_win_, NColors::BLACK, NColors::MAGENTA);
-        }
-    }
-
-    // show velocity values
-    std::string linear_vel_str = "linear : " + ConvertFloatToString(scout_state_.linear_velocity);
-    mvwprintw(body_info_win_, linear_axis_negative_y + 2, angular_axis_negative_x - 2, linear_vel_str.c_str());
-
-    std::string angular_vel_str = "angular: " + ConvertFloatToString(scout_state_.angular_velocity);
-    mvwprintw(body_info_win_, linear_axis_negative_y + 3, angular_axis_negative_x - 2, angular_vel_str.c_str());
-
-    // show vehicle base
-    NShapes::WDrawRectangle(body_info_win_, linear_axis_tip_y - 2, angular_axis_negative_x - 4,
-                           linear_axis_negative_y + 4, angular_axis_positive_x + 3);
-
-    // show vehicle wheels
-    NShapes::WDrawRectangle(body_info_win_, linear_axis_tip_y - 1, angular_axis_negative_x - 9,
-                           linear_axis_tip_y + 4, angular_axis_negative_x - 5);
-    NShapes::WDrawRectangle(body_info_win_, linear_axis_negative_y - 2, angular_axis_negative_x - 9,
-                           linear_axis_negative_y + 3, angular_axis_negative_x - 5);
-    NShapes::WDrawRectangle(body_info_win_, linear_axis_tip_y - 1, angular_axis_positive_x + 4,
-                           linear_axis_tip_y + 4, angular_axis_positive_x + 8);
-    NShapes::WDrawRectangle(body_info_win_, linear_axis_negative_y - 2, angular_axis_positive_x + 4,
-                           linear_axis_negative_y + 3, angular_axis_positive_x + 8);
-
-    // front right motor
-    ShowMotorInfo(linear_axis_tip_y - 1, angular_axis_positive_x + 4, scout_state_.motor_states[0].current,
-                  scout_state_.motor_states[0].rpm, scout_state_.motor_states[0].temperature, true);
-    // front left motor
-    ShowMotorInfo(linear_axis_tip_y - 1, angular_axis_negative_x - 9, scout_state_.motor_states[1].current,
-                  scout_state_.motor_states[1].rpm, scout_state_.motor_states[1].temperature, false);
-    // rear left motor
-    ShowMotorInfo(linear_axis_negative_y - 2, angular_axis_negative_x - 9, scout_state_.motor_states[2].current,
-                  scout_state_.motor_states[2].rpm, scout_state_.motor_states[2].temperature, false);
-    // rear right motor
-    ShowMotorInfo(linear_axis_negative_y - 2, angular_axis_positive_x + 4, scout_state_.motor_states[3].current,
-                  scout_state_.motor_states[3].rpm, scout_state_.motor_states[3].temperature, true);
-
-    // show vehicle lights
-    std::string front_mode_str = "Mode: ";
-    if (scout_state_.front_light_state.mode == CONST_ON)
-        front_mode_str += "ON";
-    else if (scout_state_.front_light_state.mode == CONST_OFF)
-        front_mode_str += "OFF";
-    else if (scout_state_.front_light_state.mode == BREATH)
-        front_mode_str += "BREATH";
-    else if (scout_state_.front_light_state.mode == CUSTOM)
-        front_mode_str += "CUSTOM";
-    mvwprintw(body_info_win_, linear_axis_tip_y - 4, angular_axis_origin_x - 13, front_mode_str.c_str());
-    std::string front_custom_str = "Custom: " + ConvertFloatToString(scout_state_.front_light_state.custom_value, 0);
-    mvwprintw(body_info_win_, linear_axis_tip_y - 4, angular_axis_origin_x + 3, front_custom_str.c_str());
-    if (scout_state_.front_light_state.mode != CONST_OFF &&
-        !(scout_state_.front_light_state.mode == CUSTOM && scout_state_.front_light_state.custom_value == 0))
-    {
-        NColors::WSetColor(body_info_win_, NColors::BRIGHT_YELLOW);
-        for (int i = angular_axis_origin_x - 5; i < angular_axis_origin_x - 1; ++i)
-            mvwprintw(body_info_win_, linear_axis_tip_y - 3, i, "v");
-        mvwprintw(body_info_win_, linear_axis_tip_y - 3, angular_axis_origin_x, "v");
-        for (int i = angular_axis_origin_x + 2; i <= angular_axis_origin_x + 5; ++i)
-            mvwprintw(body_info_win_, linear_axis_tip_y - 3, i, "v");
-        NColors::WUnsetColor(body_info_win_, NColors::BRIGHT_YELLOW);
-    }
-
-    std::string rear_mode_str = "Mode: ";
-    if (scout_state_.rear_light_state.mode == CONST_ON)
-        rear_mode_str += "ON";
-    else if (scout_state_.rear_light_state.mode == CONST_OFF)
-        rear_mode_str += "OFF";
-    else if (scout_state_.rear_light_state.mode == BREATH)
-        rear_mode_str += "BREATH";
-    else if (scout_state_.rear_light_state.mode == CUSTOM)
-        rear_mode_str += "CUSTOM";
-    mvwprintw(body_info_win_, linear_axis_negative_y + 6, angular_axis_origin_x - 13, rear_mode_str.c_str());
-    std::string rear_custom_str = "Custom: " + ConvertFloatToString(scout_state_.rear_light_state.custom_value, 0);
-    mvwprintw(body_info_win_, linear_axis_negative_y + 6, angular_axis_origin_x + 3, rear_custom_str.c_str());
-    if (scout_state_.rear_light_state.mode != CONST_OFF &&
-        !(scout_state_.rear_light_state.mode == CUSTOM && scout_state_.rear_light_state.custom_value == 0))
-    {
-        NColors::WSetColor(body_info_win_, NColors::BRIGHT_RED);
-        for (int i = angular_axis_origin_x - 5; i < angular_axis_origin_x - 1; ++i)
-            mvwprintw(body_info_win_, linear_axis_negative_y + 5, i, "^");
-        mvwprintw(body_info_win_, linear_axis_negative_y + 5, angular_axis_origin_x, "^");
-        for (int i = angular_axis_origin_x + 2; i <= angular_axis_origin_x + 5; ++i)
-            mvwprintw(body_info_win_, linear_axis_negative_y + 5, i, "^");
-        NColors::WUnsetColor(body_info_win_, NColors::BRIGHT_RED);
-    }
-}
-
-void ScoutMonitor::UpdateScoutBodyInfo()
-{
-    // for (int i = 0; i < bi_win_sx_; i++)
-    //     mvwprintw(body_info_win_, bi_win_sy_ - 1, i, "-");
-
-    ShowVehicleState(bi_win_sy_ / 2 - vehicle_fp_offset_y_, bi_win_sx_ / 2 - vehicle_fp_offset_x_);
-
-    wrefresh(body_info_win_);
-}
-
-void ScoutMonitor::UpdateScoutSystemInfo()
-{
-    for (int i = 0; i < si_win_sy_; i++)
-        mvwprintw(system_info_win_, i, 0, "|");
-
-    const int state_title_col = (si_win_sx_ - 24) / 2;
-    const int state_value_col = state_title_col + 20;
-    const int state_div_col = state_value_col - 2;
-
-    // system state
-    const int sec1 = static_cast<int>(std::round((si_win_sy_ - 20) / 2.0));
-    ShowStatusItemName(sec1, state_title_col, "System state");
-
-    if (scout_state_.base_state == BASE_NORMAL)
-    {
-        NColors::WSetColor(system_info_win_, NColors::GREEN);
-        mvwprintw(system_info_win_, sec1, state_value_col, "NORMAL");
-        NColors::WUnsetColor(system_info_win_, NColors::GREEN);
-    }
-    else if (scout_state_.base_state == BASE_ESTOP)
-    {
-        NColors::WSetColor(system_info_win_, NColors::YELLOW);
-        mvwprintw(system_info_win_, sec1, state_value_col, "ESTOP");
-        NColors::WUnsetColor(system_info_win_, NColors::YELLOW);
-    }
-    else if (scout_state_.base_state == BASE_EXCEPTION)
-    {
-        NColors::WSetColor(system_info_win_, NColors::RED);
-        mvwprintw(system_info_win_, sec1, state_value_col, "EXCEPT");
-        NColors::WUnsetColor(system_info_win_, NColors::RED);
-    }
-
-    // control mode
-    ShowStatusItemName(sec1 + 1, state_title_col, "Control mode");
-    if (scout_state_.control_mode == REMOTE_MODE)
-        mvwprintw(system_info_win_, sec1 + 1, state_value_col, "REMOTE");
-    else if (scout_state_.control_mode == CMD_CAN_MODE)
-        mvwprintw(system_info_win_, sec1 + 1, state_value_col, "CAN");
-    else if (scout_state_.control_mode == CMD_UART_MODE)
-        mvwprintw(system_info_win_, sec1 + 1, state_value_col, "UART");
-    // mvwprintw(system_info_win_, sec1 + 1, state_value_col, std::to_string(scout_state_.control_mode).c_str());
-
-    // battery voltage
-    ShowStatusItemName(sec1 + 2, state_title_col, "Battery voltage");
-    std::string bat_vol_str = ConvertFloatToString(scout_state_.battery_voltage, 1) + " v";
-    mvwprintw(system_info_win_, sec1 + 2, state_value_col, bat_vol_str.c_str());
-
-    const int fault_col_1 = state_value_col;
-    const int fault_col_2 = fault_col_1 + 2;
-    const int fault_col_3 = fault_col_2 + 2;
-
-    const int sec2 = sec1 + 4;
-    mvwprintw(system_info_win_, sec2, state_title_col, "System faults");
-
-    // motor driver over heat;
-    ShowStatusItemName(sec2 + 1, state_title_col, "-Drv over-heat");
-    if ((scout_state_.fault_code & MOTOR_DRV_OVERHEAT_W) == 0 &&
-        (scout_state_.fault_code & MOTOR_DRV_OVERHEAT_F) == 0)
-    {
-        NColors::WSetColor(system_info_win_, NColors::GREEN);
-        mvwprintw(system_info_win_, sec2 + 1, fault_col_1, "N");
-        NColors::WUnsetColor(system_info_win_, NColors::GREEN);
-    }
-    else
-    {
-        if (scout_state_.fault_code & MOTOR_DRV_OVERHEAT_W)
-        {
-            NColors::WSetColor(system_info_win_, NColors::YELLOW);
-            mvwprintw(system_info_win_, sec2 + 1, fault_col_2, "W");
-            NColors::WUnsetColor(system_info_win_, NColors::YELLOW);
-        }
-        if (scout_state_.fault_code & MOTOR_DRV_OVERHEAT_F)
-        {
-            NColors::WSetColor(system_info_win_, NColors::RED);
-            mvwprintw(system_info_win_, sec2 + 1, fault_col_3, "P");
-            NColors::WUnsetColor(system_info_win_, NColors::RED);
-        }
-    }
-
-    // motor driver over current
-    ShowStatusItemName(sec2 + 2, state_title_col, "-Mt over-current");
-    if ((scout_state_.fault_code & MOTOR_OVERCURRENT_W) == 0 &&
-        (scout_state_.fault_code & MOTOR_OVERCURRENT_F) == 0)
-    {
-        NColors::WSetColor(system_info_win_, NColors::GREEN);
-        mvwprintw(system_info_win_, sec2 + 2, fault_col_1, "N");
-        NColors::WUnsetColor(system_info_win_, NColors::GREEN);
-    }
-    else
-    {
-        if (scout_state_.fault_code & MOTOR_OVERCURRENT_W)
-        {
-            NColors::WSetColor(system_info_win_, NColors::YELLOW);
-            mvwprintw(system_info_win_, sec2 + 2, fault_col_2, "W");
-            NColors::WUnsetColor(system_info_win_, NColors::YELLOW);
-        }
-        if (scout_state_.fault_code & MOTOR_OVERCURRENT_F)
-        {
-            NColors::WSetColor(system_info_win_, NColors::RED);
-            mvwprintw(system_info_win_, sec2 + 2, fault_col_3, "P");
-            NColors::WUnsetColor(system_info_win_, NColors::RED);
-        }
-    }
-
-    // battery under voltage
-    ShowStatusItemName(sec2 + 3, state_title_col, "-Bat under volt");
-    if ((scout_state_.fault_code & BAT_UNDER_VOL_W) == 0 &&
-        (scout_state_.fault_code & BAT_UNDER_VOL_F) == 0)
-    {
-        NColors::WSetColor(system_info_win_, NColors::GREEN);
-        mvwprintw(system_info_win_, sec2 + 3, fault_col_1, "N");
-        NColors::WUnsetColor(system_info_win_, NColors::GREEN);
-    }
-    else
-    {
-        if (scout_state_.fault_code & BAT_UNDER_VOL_W)
-        {
-            NColors::WSetColor(system_info_win_, NColors::YELLOW);
-            mvwprintw(system_info_win_, sec2 + 3, fault_col_2, "W");
-            NColors::WUnsetColor(system_info_win_, NColors::YELLOW);
-        }
-        if (scout_state_.fault_code & BAT_UNDER_VOL_F)
-        {
-            NColors::WSetColor(system_info_win_, NColors::RED);
-            mvwprintw(system_info_win_, sec2 + 3, fault_col_3, "F");
-            NColors::WUnsetColor(system_info_win_, NColors::RED);
-        }
-    }
-
-    // battery over voltage
-    ShowStatusItemName(sec2 + 4, state_title_col, "-Bat over volt");
-    ShowFault(sec2 + 4, fault_col_1, (scout_state_.fault_code & BAT_OVER_VOL_F) == 0);
-
-    const int sec3 = sec2 + 6;
-    mvwprintw(system_info_win_, sec3, state_title_col, "Comm faults");
-
-    // CAN cmd checksum
-    ShowStatusItemName(sec3 + 1, state_title_col, "-CAN cmd checksum");
-    ShowFault(sec3 + 1, fault_col_1, (scout_state_.fault_code & CAN_CHECKSUM_ERROR) == 0);
-
-    // motor comm
-    ShowStatusItemName(sec3 + 2, state_title_col, "-Motor 1 comm");
-    ShowFault(sec3 + 2, fault_col_1, (scout_state_.fault_code & MOTOR1_COMM_F) == 0);
-
-    ShowStatusItemName(sec3 + 3, state_title_col, "-Motor 2 comm");
-    ShowFault(sec3 + 3, fault_col_1, (scout_state_.fault_code & MOTOR2_COMM_F) == 0);
-
-    ShowStatusItemName(sec3 + 4, state_title_col, "-Motor 3 comm");
-    ShowFault(sec3 + 4, fault_col_1, (scout_state_.fault_code & MOTOR3_COMM_F) == 0);
-
-    ShowStatusItemName(sec3 + 5, state_title_col, "-Motor 4 comm");
-    ShowFault(sec3 + 5, fault_col_1, (scout_state_.fault_code & MOTOR4_COMM_F) == 0);
-
-    const int sec4 = sec3 + 8;
-    NColors::WSetColor(system_info_win_, NColors::GREEN);
-    mvwprintw(system_info_win_, sec4, state_title_col + 1, "N: normal");
-    NColors::WUnsetColor(system_info_win_, NColors::GREEN);
-
-    NColors::WSetColor(system_info_win_, NColors::YELLOW);
-    mvwprintw(system_info_win_, sec4, state_title_col + 12, "W: warning");
-    NColors::WUnsetColor(system_info_win_, NColors::YELLOW);
-
-    NColors::WSetColor(system_info_win_, NColors::RED);
-    mvwprintw(system_info_win_, sec4 + 1, state_title_col + 1, "F: fault   P: protection");
-    NColors::WUnsetColor(system_info_win_, NColors::RED);
-
-    wrefresh(system_info_win_);
-}
-
-void ScoutMonitor::ShowStatusItemName(int y, int x, std::string name)
-{
-    const int state_value_col = x + 20;
-    const int state_div_col = state_value_col - 2;
-
-    mvwprintw(system_info_win_, y, x, name.c_str());
-    mvwprintw(system_info_win_, y, state_div_col, ":");
-}
-
-void ScoutMonitor::ShowFault(int y, int x, bool no_fault)
-{
-    const int fault_col_1 = x;
-    const int fault_col_2 = x + 2;
-    const int fault_col_3 = fault_col_2 + 2;
-
-    if (no_fault)
-    {
-        NColors::WSetColor(system_info_win_, NColors::GREEN);
-        mvwprintw(system_info_win_, y, fault_col_1, "N");
-        NColors::WUnsetColor(system_info_win_, NColors::GREEN);
-    }
-    else
-    {
-        NColors::WSetColor(system_info_win_, NColors::RED);
-        mvwprintw(system_info_win_, y, fault_col_3, "F");
-        NColors::WUnsetColor(system_info_win_, NColors::RED);
-    }
-}
-
-// (y,x): position of the top left point of corresponding wheel
-void ScoutMonitor::ShowMotorInfo(int y, int x, double cur, int rpm, int temp, bool is_right)
-{
-    int col_title = x;
-    if (is_right)
-        col_title += 6;
-    else
-        col_title -= 9;
-
-    std::string cur_str = "CUR:" + ConvertFloatToString(cur, 1);
-    mvwprintw(body_info_win_, y + 1, col_title, cur_str.c_str());
-
-    std::string rpm_str = "RPM:" + ConvertFloatToString(rpm, 0);
-    mvwprintw(body_info_win_, y + 2, col_title, rpm_str.c_str());
-
-    std::string temp_str = "TMP:" + ConvertFloatToString(temp, 0);
-    mvwprintw(body_info_win_, y + 3, col_title, temp_str.c_str());
-}
-} // namespace wescore

scout_base/src/scout_sdk/src/monitor/tests/CMakeLists.txt

@@ -1,15 +0,0 @@
-# Add executables
-add_executable(test_scout_monitor test_scout_monitor.cpp)
-target_link_libraries(test_scout_monitor monitor)
-
-add_executable(test_scout_monitor_virtual test_scout_monitor_virtual.cpp)
-target_link_libraries(test_scout_monitor_virtual monitor)
-
-# add_executable(test_ncurses test_ncurses.cpp)
-# target_link_libraries(test_ncurses monitor)
-
-add_executable(test_ncolor test_ncolor.c)
-target_link_libraries(test_ncolor monitor)
-
-add_executable(test_ncolor2 test_ncolor2.cpp)
-target_link_libraries(test_ncolor2 monitor)

scout_base/src/scout_sdk/src/monitor/tests/test_ncolor.c

@@ -1,158 +0,0 @@
-/* color-demo.c */
-// source: https://www.linuxjournal.com/content/about-ncurses-colors-0
-
-#include <curses.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-int is_bold(int fg);
-void init_colorpairs(void);
-short curs_color(int fg);
-int colornum(int fg, int bg);
-void setcolor(int fg, int bg);
-void unsetcolor(int fg, int bg);
-
-void init_colorpairs(void)
-{
-    int fg, bg;
-    int colorpair;
-
-    for (bg = 0; bg <= 7; bg++)
-    {
-        for (fg = 0; fg <= 7; fg++)
-        {
-            colorpair = colornum(fg, bg);
-            init_pair(colorpair, curs_color(fg), curs_color(bg));
-        }
-    }
-}
-
-short curs_color(int fg)
-{
-    switch (7 & fg)
-    {       /* RGB */
-    case 0: /* 000 */
-        return (COLOR_BLACK);
-    case 1: /* 001 */
-        return (COLOR_BLUE);
-    case 2: /* 010 */
-        return (COLOR_GREEN);
-    case 3: /* 011 */
-        return (COLOR_CYAN);
-    case 4: /* 100 */
-        return (COLOR_RED);
-    case 5: /* 101 */
-        return (COLOR_MAGENTA);
-    case 6: /* 110 */
-        return (COLOR_YELLOW);
-    case 7: /* 111 */
-        return (COLOR_WHITE);
-    }
-}
-
-int colornum(int fg, int bg)
-{
-    int B, bbb, ffff;
-
-    B = 1 << 7;
-    bbb = (7 & bg) << 4;
-    ffff = 7 & fg;
-
-    return (B | bbb | ffff);
-}
-
-void setcolor(int fg, int bg)
-{
-    /* set the color pair (colornum) and bold/bright (A_BOLD) */
-
-    attron(COLOR_PAIR(colornum(fg, bg)));
-    if (is_bold(fg))
-    {
-        attron(A_BOLD);
-    }
-}
-
-void unsetcolor(int fg, int bg)
-{
-    /* unset the color pair (colornum) and
-       bold/bright (A_BOLD) */
-
-    attroff(COLOR_PAIR(colornum(fg, bg)));
-    if (is_bold(fg))
-    {
-        attroff(A_BOLD);
-    }
-}
-
-int is_bold(int fg)
-{
-    /* return the intensity bit */
-
-    int i;
-
-    i = 1 << 3;
-    return (i & fg);
-}
-
-int main(void)
-{
-    int fg, bg;
-
-    /* initialize curses */
-
-    initscr();
-    keypad(stdscr, TRUE);
-    cbreak();
-    noecho();
-
-    /* initialize colors */
-
-    if (has_colors() == FALSE)
-    {
-        endwin();
-        puts("Your terminal does not support color");
-        exit(1);
-    }
-
-    start_color();
-    init_colorpairs();
-
-    /* draw test pattern */
-
-    if ((LINES < 24) || (COLS < 80))
-    {
-        endwin();
-        puts("Your terminal needs to be at least 80x24");
-        exit(2);
-    }
-
-    mvaddstr(0, 35, "COLOR DEMO");
-    mvaddstr(2, 0, "low intensity text colors (0-7)");
-    mvaddstr(12, 0, "high intensity text colors (8-15)");
-
-    for (bg = 0; bg <= 7; bg++)
-    {
-        for (fg = 0; fg <= 7; fg++)
-        {
-            setcolor(fg, bg);
-            mvaddstr(fg + 3, bg * 10, "...test...");
-            unsetcolor(fg, bg);
-        }
-
-        for (fg = 8; fg <= 15; fg++)
-        {
-            setcolor(fg, bg);
-            mvaddstr(fg + 5, bg * 10, "...test...");
-            unsetcolor(fg, bg);
-        }
-    }
-
-    mvaddstr(LINES - 1, 0, "press any key to quit");
-
-    refresh();
-
-    getch();
-    endwin();
-
-    exit(0);
-}

scout_base/src/scout_sdk/src/monitor/tests/test_ncolor2.cpp

@@ -1,65 +0,0 @@
-#include "monitor/ncolors.hpp"
-
-using namespace wescore;
-
-int main(void)
-{
-    int fg, bg;
-
-    /* initialize curses */
-
-    initscr();
-    keypad(stdscr, TRUE);
-    cbreak();
-    noecho();
-
-    /* initialize colors */
-
-    if (has_colors() == FALSE)
-    {
-        endwin();
-        puts("Your terminal does not support color");
-        return 1;
-    }
-
-    NColors::InitColors();
-
-    /* draw test pattern */
-
-    if ((LINES < 24) || (COLS < 80))
-    {
-        endwin();
-        puts("Your terminal needs to be at least 80x24");
-        return 2;
-    }
-
-    mvaddstr(0, 35, "COLOR DEMO");
-    mvaddstr(2, 0, "low intensity text colors (0-7)");
-    mvaddstr(12, 0, "high intensity text colors (8-15)");
-
-    for (bg = 0; bg <= 7; bg++)
-    {
-        for (fg = 0; fg <= 7; fg++)
-        {
-            NColors::SetColor(fg, bg);
-            mvaddstr(fg + 3, bg * 10, "...test...");
-            NColors::UnsetColor(fg, bg);
-        }
-
-        for (fg = 8; fg <= 15; fg++)
-        {
-            NColors::SetColor(fg, bg);
-            mvaddstr(fg + 5, bg * 10, "...test...");
-            NColors::UnsetColor(fg, bg);
-        }
-    }
-
-    mvaddstr(LINES - 1, 0, "press any key to quit");
-
-    refresh();
-
-    getch();
-    endwin();
-
-    return 0;
-}

scout_base/src/scout_sdk/src/monitor/tests/test_ncurses.cpp

@@ -1,118 +0,0 @@
-#include <panel.h>
-#include <string.h>
-
-#define NLINES 10
-#define NCOLS 40
-
-void init_wins(WINDOW **wins, int n);
-void win_show(WINDOW *win, char *label, int label_color);
-void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string, chtype color);
-
-int main()
-{	WINDOW *my_wins[3];
-	PANEL  *my_panels[3];
-	PANEL  *top;
-	int ch;
-
-	/* Initialize curses */
-	initscr();
-	start_color();
-	cbreak();
-	noecho();
-	keypad(stdscr, TRUE);
-
-	/* Initialize all the colors */
-	init_pair(1, COLOR_RED, COLOR_BLACK);
-	init_pair(2, COLOR_GREEN, COLOR_BLACK);
-	init_pair(3, COLOR_BLUE, COLOR_BLACK);
-	init_pair(4, COLOR_CYAN, COLOR_BLACK);
-
-	init_wins(my_wins, 3);
-	
-	/* Attach a panel to each window */ 	/* Order is bottom up */
-	my_panels[0] = new_panel(my_wins[0]); 	/* Push 0, order: stdscr-0 */
-	my_panels[1] = new_panel(my_wins[1]); 	/* Push 1, order: stdscr-0-1 */
-	my_panels[2] = new_panel(my_wins[2]); 	/* Push 2, order: stdscr-0-1-2 */
-
-	/* Set up the user pointers to the next panel */
-	set_panel_userptr(my_panels[0], my_panels[1]);
-	set_panel_userptr(my_panels[1], my_panels[2]);
-	set_panel_userptr(my_panels[2], my_panels[0]);
-
-	/* Update the stacking order. 2nd panel will be on top */
-	update_panels();
-
-	/* Show it on the screen */
-	attron(COLOR_PAIR(4));
-	mvprintw(LINES - 2, 0, "Use tab to browse through the windows (F1 to Exit)");
-	attroff(COLOR_PAIR(4));
-	doupdate();
-
-	top = my_panels[2];
-	while((ch = getch()) != KEY_F(1))
-	{	switch(ch)
-		{	case 9:
-				top = (PANEL *)panel_userptr(top);
-				top_panel(top);
-				break;
-		}
-		update_panels();
-		doupdate();
-	}
-	endwin();
-	return 0;
-}
-
-/* Put all the windows */
-void init_wins(WINDOW **wins, int n)
-{	int x, y, i;
-	char label[80];
-
-	y = 2;
-	x = 10;
-	for(i = 0; i < n; ++i)
-	{	wins[i] = newwin(NLINES, NCOLS, y, x);
-		sprintf(label, "Window Number %d", i + 1);
-		win_show(wins[i], label, i + 1);
-		y += 3;
-		x += 7;
-	}
-}
-
-/* Show the window with a border and a label */
-void win_show(WINDOW *win, char *label, int label_color)
-{	int startx, starty, height, width;
-
-	getbegyx(win, starty, startx);
-	getmaxyx(win, height, width);
-
-	box(win, 0, 0);
-	mvwaddch(win, 2, 0, ACS_LTEE); 
-	mvwhline(win, 2, 1, ACS_HLINE, width - 2); 
-	mvwaddch(win, 2, width - 1, ACS_RTEE); 
-	
-	print_in_middle(win, 1, 0, width, label, COLOR_PAIR(label_color));
-}
-
-void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string, chtype color)
-{	int length, x, y;
-	float temp;
-
-	if(win == NULL)
-		win = stdscr;
-	getyx(win, y, x);
-	if(startx != 0)
-		x = startx;
-	if(starty != 0)
-		y = starty;
-	if(width == 0)
-		width = 80;
-
-	length = strlen(string);
-	temp = (width - length)/ 2;
-	x = startx + (int)temp;
-	wattron(win, color);
-	mvwprintw(win, y, x, "%s", string);
-	wattroff(win, color);
-	refresh();
-}

scout_base/src/scout_sdk/src/monitor/tests/test_scout_monitor.cpp

@@ -1,33 +0,0 @@
-#include <signal.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-
-#include <iostream>
-
-#include "monitor/scout_monitor.hpp"
-
-using namespace wescore;
-
-ScoutMonitor monitor;
-
-void SignalHandler(int s)
-{
-    printf("Caught signal %d\n", s);
-    monitor.Terminate();
-    exit(1);
-}
-
-int main(int argc, char **argv)
-{
-    struct sigaction sigIntHandler;
-    sigIntHandler.sa_handler = SignalHandler;
-    sigemptyset(&sigIntHandler.sa_mask);
-    sigIntHandler.sa_flags = 0;
-    sigaction(SIGINT, &sigIntHandler, NULL);
-
-    std::cout << "scout monitor started" << std::endl;
-    monitor.Run("can1");
-
-    return 0;
-}

scout_base/src/scout_sdk/src/monitor/tests/test_scout_monitor_virtual.cpp

@@ -1,33 +0,0 @@
-#include <signal.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-
-#include <iostream>
-
-#include "monitor/scout_monitor.hpp"
-
-using namespace wescore;
-
-ScoutMonitor monitor;
-
-void SignalHandler(int s)
-{
-    printf("Caught signal %d\n", s);
-    monitor.Terminate();
-    exit(1);
-}
-
-int main(int argc, char **argv)
-{
-    struct sigaction sigIntHandler;
-    sigIntHandler.sa_handler = SignalHandler;
-    sigemptyset(&sigIntHandler.sa_mask);
-    sigIntHandler.sa_flags = 0;
-    sigaction(SIGINT, &sigIntHandler, NULL);
-
-    std::cout << "scout monitor started" << std::endl;
-    monitor.Run();
-
-    return 0;
-}

scout_base/src/scout_sdk/src/sdk_core/CMakeLists.txt

@@ -1,7 +0,0 @@
-# Add source directories
-add_subdirectory(async_io)
-add_subdirectory(scout_base)
-
-if(BUILD_TESTS)
-    add_subdirectory(unit_tests)
-endif()

scout_base/src/scout_sdk/src/sdk_core/async_io/CMakeLists.txt

@@ -1,36 +0,0 @@
-# Dependency libraries
-# find_package(LIB_NAME REQUIRED)
-
-# Add libraries
-set(ASYNC_IO_LIB_SRC
-    src/async_serial.cpp
-    src/async_can.cpp
-)
-add_library(asyncio STATIC ${ASYNC_IO_LIB_SRC})
-set_target_properties(asyncio PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_compile_definitions(asyncio PUBLIC "-DASIO_ENABLE_OLD_SERVICES -DASIO_HAS_POSIX_STREAM_DESCRIPTOR")
-target_link_libraries(asyncio asio pthread)
-target_include_directories(asyncio PUBLIC
-	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-	$<INSTALL_INTERFACE:include>
-	PRIVATE src)
-
-# Add executables
-if(BUILD_TESTS)
-	add_subdirectory(tests)
-endif()
-
-# # 'make install' to the correct locations (provided by GNUInstallDirs).
-# install(TARGETS lib EXPORT MyLibraryConfig
-# ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
-# LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
-# RUNTIME  DESTINATION ${CMAKE_INSTALL_BINDIR})  # This is for Windows
-# install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-# # This makes the project importable from the install directory
-# # Put config file in per-project dir (name MUST match), can also
-# # just go into 'cmake'.
-# install(EXPORT MyLibraryConfig DESTINATION share/MyLibrary/cmake)
-
-# # This makes the project importable from the build directory
-# export(TARGETS lib FILE MyLibraryConfig.cmake)

scout_base/src/scout_sdk/src/sdk_core/async_io/include/async_io/async_can.hpp

@@ -1,130 +0,0 @@
-/* 
- * async_can.hpp
- * 
- * Created on: Jun 10, 2019 02:16
- * Description: code based on uavcan and libmavconn
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-/*
- * Copyright (c) 2016 UAVCAN Team
- *
- * Distributed under the MIT License, available in the file LICENSE.
- *
- */
-
-/*
- * libmavconn
- * Copyright 2013,2014,2015,2016 Vladimir Ermakov, All rights reserved.
- *
- * This file is part of the mavros package and subject to the license terms
- * in the top-level LICENSE file of the mavros repository.
- * https://github.com/mavlink/mavros/tree/master/LICENSE.md
- */
-
-#ifndef ASYNC_CAN_HPP
-#define ASYNC_CAN_HPP
-
-#include <linux/can.h>
-
-#include <atomic>
-#include <chrono>
-#include <thread>
-#include <mutex>
-#include <deque>
-#include <functional>
-#include <iostream>
-
-#include "asio.hpp"
-#include "asio/posix/basic_stream_descriptor.hpp"
-
-// #include "async_io/device_error.hpp"
-// #include "async_io/msg_buffer.hpp"
-
-namespace wescore
-{
-using steady_clock = std::chrono::steady_clock;
-using lock_guard = std::lock_guard<std::recursive_mutex>;
-
-class ASyncCAN : public std::enable_shared_from_this<ASyncCAN>
-{
-public:
-    static constexpr auto DEFAULT_DEVICE = "can1";
-    static constexpr std::size_t MAX_TXQ_SIZE = 1000;
-
-    using ReceiveCallback = std::function<void(can_frame *rx_frame)>;
-    using ClosedCallback = std::function<void(void)>;
-
-    using Ptr = std::shared_ptr<ASyncCAN>;
-    using ConstPtr = std::shared_ptr<ASyncCAN const>;
-    using WeakPtr = std::weak_ptr<ASyncCAN>;
-
-    struct IOStat
-    {
-        std::size_t tx_total_frames; // total bytes transferred
-        std::size_t rx_total_frames; // total bytes received
-        float tx_speed;              // current transfer speed [Frames/s]
-        float rx_speed;              // current receive speed [Frames/s]
-    };
-
-public:
-    ASyncCAN(std::string device = DEFAULT_DEVICE);
-    ~ASyncCAN();
-
-    // do not allow copy
-    ASyncCAN(const ASyncCAN &other) = delete;
-    ASyncCAN &operator=(const ASyncCAN &other) = delete;
-
-    std::size_t conn_id;
-    int can_fd_;
-
-    static Ptr open_url(std::string url);
-    void open(std::string device);
-    void close();
-
-    void set_receive_callback(ReceiveCallback cb) { receive_cb = cb; }
-    void set_closed_callback(ClosedCallback cb) { port_closed_cb = cb; }
-
-    inline bool is_open() { return true; }
-    IOStat get_iostat();
-
-    void send_frame(const can_frame &tx_frame);
-
-private:
-    // monotonic counter (increment only)
-    bool can_interface_opened_ = false;
-    static std::atomic<std::size_t> conn_id_counter;
-
-    struct can_frame rcv_frame;
-
-    // port statistics
-    std::atomic<std::size_t> tx_total_frames;
-    std::atomic<std::size_t> rx_total_frames;
-    std::size_t last_tx_total_frames;
-    std::size_t last_rx_total_frames;
-    std::chrono::time_point<steady_clock> last_iostat;
-    std::recursive_mutex iostat_mutex;
-
-    // io service
-    asio::io_service io_service;
-    asio::posix::basic_stream_descriptor<> stream;
-    std::thread io_thread;
-
-    // callback objects
-    ClosedCallback port_closed_cb;
-    ReceiveCallback receive_cb;
-
-    // internal processing
-    void do_read(struct can_frame &rec_frame, asio::posix::basic_stream_descriptor<> &stream);
-    void do_write(bool check_tx_state);
-
-    void call_receive_callback(can_frame *rx_frame);
-    void default_receive_callback(can_frame *rx_frame);
-
-    void iostat_tx_add(std::size_t bytes);
-    void iostat_rx_add(std::size_t bytes);
-};
-} // namespace wescore
-
-#endif /* ASYNC_CAN_HPP */

scout_base/src/scout_sdk/src/sdk_core/async_io/include/async_io/async_serial.hpp

@@ -1,131 +0,0 @@
-/* 
- * async_serial.hpp
- * 
- * Created on: Nov 23, 2018 22:18
- * Description: asynchronous serial communication using asio
- *              adapted from code in libmavconn
- * 
- * Main changes: 1. Removed dependency on Boost (asio standalone
- *                  and C++ STL only)
- *               2. Removed dependency on console-bridge
- *               3. Removed mavlink related code
- *               4. Removed UDP/TCP related code
- * 
- * Author: Vladimir Ermakov <vooon341@gmail.com>
- *         Ruixiang Du <ruixiang.du@gmail.com>
- * 
- * Additioanl reference:
- *  [1] http://www.webalice.it/fede.tft/serial_port/serial_port.html
- * 
- */
-/*
- * libmavconn
- * Copyright 2013,2014,2015,2016 Vladimir Ermakov, All rights reserved.
- *
- * This file is part of the mavros package and subject to the license terms
- * in the top-level LICENSE file of the mavros repository.
- * https://github.com/mavlink/mavros/tree/master/LICENSE.md
- */
-
-#ifndef ASYNC_SERIAL_HPP
-#define ASYNC_SERIAL_HPP
-
-#include <atomic>
-#include <chrono>
-#include <thread>
-#include <mutex>
-#include <deque>
-#include <functional>
-
-#include "asio.hpp"
-
-#include "async_io/device_error.hpp"
-#include "async_io/msg_buffer.hpp"
-
-namespace wescore
-{
-using steady_clock = std::chrono::steady_clock;
-using lock_guard = std::lock_guard<std::recursive_mutex>;
-
-class ASyncSerial : public std::enable_shared_from_this<ASyncSerial>
-{
-  public:
-    static constexpr auto DEFAULT_DEVICE = "/dev/ttyUSB0";
-    static constexpr auto DEFAULT_BAUDRATE = 115200;
-    static constexpr std::size_t MAX_TXQ_SIZE = 1000;
-
-    using ReceiveCallback = std::function<void(uint8_t *buf, const size_t bufsize, size_t bytes_received)>;
-    using ClosedCallback = std::function<void(void)>;
-
-    using Ptr = std::shared_ptr<ASyncSerial>;
-    using ConstPtr = std::shared_ptr<ASyncSerial const>;
-    using WeakPtr = std::weak_ptr<ASyncSerial>;
-
-    struct IOStat
-    {
-        std::size_t tx_total_bytes; //!< total bytes transferred
-        std::size_t rx_total_bytes; //!< total bytes received
-        float tx_speed;             //!< current transfer speed [B/s]
-        float rx_speed;             //!< current receive speed [B/s]
-    };
-
-  public:
-    ASyncSerial(std::string device = DEFAULT_DEVICE, unsigned baudrate = DEFAULT_BAUDRATE, bool hwflow = false);
-    ~ASyncSerial();
-
-    // do not allow copy
-    ASyncSerial(const ASyncSerial &other) = delete;
-    ASyncSerial &operator=(const ASyncSerial &other) = delete;
-
-    std::size_t conn_id;
-
-    static Ptr open_url(std::string url);
-    void open(std::string device, unsigned baudrate, bool hwflow);
-    void close();
-
-    void send_bytes(const uint8_t *bytes, size_t length);
-    void set_receive_callback(ReceiveCallback cb) { receive_cb = cb; }
-    void set_closed_callback(ClosedCallback cb) { port_closed_cb = cb; }
-
-    inline bool is_open() { return serial_dev.is_open(); }
-    IOStat get_iostat();
-
-  private:
-    // monotonic counter (increment only)
-    static std::atomic<std::size_t> conn_id_counter;
-
-    // port statistics
-    std::atomic<std::size_t> tx_total_bytes;
-    std::atomic<std::size_t> rx_total_bytes;
-    std::size_t last_tx_total_bytes;
-    std::size_t last_rx_total_bytes;
-    std::chrono::time_point<steady_clock> last_iostat;
-    std::recursive_mutex iostat_mutex;
-
-    // io service
-    asio::io_service io_service;
-    std::thread io_thread;
-    asio::serial_port serial_dev;
-
-    std::atomic<bool> tx_in_progress;
-    std::deque<MsgBuffer> tx_q;
-    std::array<uint8_t, MsgBuffer::MAX_SIZE> rx_buf;
-    std::recursive_mutex mutex;
-
-    // callback objects
-    ClosedCallback port_closed_cb;
-    ReceiveCallback receive_cb;
-
-    // internal processing
-    void do_read();
-    void do_write(bool check_tx_state);
-
-    void call_receive_callback(uint8_t *buf, const std::size_t bufsize, std::size_t bytes_received);
-    void default_receive_callback(uint8_t *buf, const std::size_t bufsize, std::size_t bytes_received);
-
-    void iostat_tx_add(std::size_t bytes);
-    void iostat_rx_add(std::size_t bytes);
-};
-} // namespace wescore
-
-#endif /* ASYNC_SERIAL_HPP */

scout_base/src/scout_sdk/src/sdk_core/async_io/include/async_io/device_error.hpp

@@ -1,57 +0,0 @@
-/**
- * @brief MAVConn device error class
- * @file device_error.hpp
- * @author Vladimir Ermakov <vooon341@gmail.com>
- */
-/*
- * libmavconn
- * Copyright 2013,2014,2015,2016 Vladimir Ermakov, All rights reserved.
- *
- * This file is part of the mavros package and subject to the license terms
- * in the top-level LICENSE file of the mavros repository.
- * https://github.com/mavlink/mavros/tree/master/LICENSE.md
- */
-
-#ifndef DEVICE_ERROR_HPP
-#define DEVICE_ERROR_HPP
-
-#include <string>
-#include <cstring>
-#include <stdexcept>
-
-namespace wescore
-{
-class DeviceError : public std::runtime_error
-{
-  public:
-    template <typename T>
-    DeviceError(const char *module, T msg) : std::runtime_error(make_message(module, msg))
-    {
-    }
-
-    template <typename T>
-    static std::string make_message(const char *module, T msg)
-    {
-        std::ostringstream ss;
-        ss << "DeviceError:" << module << ":" << msg_to_string(msg);
-        return ss.str();
-    }
-
-    static std::string msg_to_string(const char *description)
-    {
-        return description;
-    }
-
-    static std::string msg_to_string(int errnum)
-    {
-        return std::strerror(errnum);
-    }
-
-    static std::string msg_to_string(std::system_error &err)
-    {
-        return err.what();
-    }
-};
-} // namespace mavconn
-
-#endif /* DEVICE_ERROR_HPP */

scout_base/src/scout_sdk/src/sdk_core/async_io/include/async_io/msg_buffer.hpp

@@ -1,69 +0,0 @@
-/**
- * @brief MAVConn message buffer class (internal)
- * @file msgbuffer.hpp
- * @author Vladimir Ermakov <vooon341@gmail.com>
- */
-/*
- * libmavconn
- * Copyright 2014,2015,2016 Vladimir Ermakov, All rights reserved.
- *
- * This file is part of the mavros package and subject to the license terms
- * in the top-level LICENSE file of the mavros repository.
- * https://github.com/mavlink/mavros/tree/master/LICENSE.md
- */
-
-#pragma once
-
-#include <sys/types.h>
-#include <cstdint>
-#include <cstring>
-#include <cassert>
-
-namespace wescore
-{
-
-/**
- * @brief Message buffer for internal use in libmavconn
- */
-struct MsgBuffer
-{
-    //! Maximum buffer size with padding for CRC bytes (280 + padding)
-    static constexpr ssize_t MAX_PACKET_LEN = 255;
-    static constexpr ssize_t MAX_SIZE = MAX_PACKET_LEN + 16;
-    uint8_t data[MAX_SIZE];
-    ssize_t len;
-    ssize_t pos;
-
-    MsgBuffer() : pos(0),
-                  len(0)
-    {
-    }
-    
-    /**
-	 * @brief Buffer constructor for send_bytes()
-	 * @param[in] nbytes should be less than MAX_SIZE
-	 */
-    MsgBuffer(const uint8_t *bytes, ssize_t nbytes) : pos(0),
-                                                      len(nbytes)
-    {
-        assert(0 < nbytes && nbytes < MAX_SIZE);
-        std::memcpy(data, bytes, nbytes);
-    }
-
-    virtual ~MsgBuffer()
-    {
-        pos = 0;
-        len = 0;
-    }
-
-    uint8_t *dpos()
-    {
-        return data + pos;
-    }
-
-    ssize_t nbytes()
-    {
-        return len - pos;
-    }
-};
-} // namespace wescore

scout_base/src/scout_sdk/src/sdk_core/async_io/src/async_can.cpp

@@ -1,202 +0,0 @@
-/* 
- * async_can.cpp
- * 
- * Created on: Jun 10, 2019 02:25
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- * Copyright (c) 2016 UAVCAN Team
- */
-
-// This is needed to enable necessary declarations in sys/
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include "async_io/async_can.hpp"
-
-#include <net/if.h>
-#include <poll.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/ioctl.h>
-
-#include <cassert>
-#include <iostream>
-
-#include "asyncio_utils.hpp"
-
-using namespace wescore;
-
-using asio::buffer;
-using asio::io_service;
-using std::error_code;
-
-std::atomic<size_t> ASyncCAN::conn_id_counter{0};
-
-ASyncCAN::ASyncCAN(std::string device) : tx_total_frames(0),
-                                         rx_total_frames(0),
-                                         last_tx_total_frames(0),
-                                         last_rx_total_frames(0),
-                                         last_iostat(steady_clock::now()),
-                                         io_service(),
-                                         stream(io_service)
-{
-    conn_id = conn_id_counter.fetch_add(1);
-    open(device);
-}
-
-ASyncCAN::~ASyncCAN()
-{
-    close();
-}
-
-void ASyncCAN::open(std::string device)
-{
-    const size_t iface_name_size = strlen(device.c_str()) + 1;
-    if (iface_name_size > IFNAMSIZ)
-        return;
-
-    can_fd_ = socket(PF_CAN, SOCK_RAW | SOCK_NONBLOCK, CAN_RAW);
-    if (can_fd_ < 0)
-        return;
-
-    struct ifreq ifr;
-    memset(&ifr, 0, sizeof(ifr));
-    memcpy(ifr.ifr_name, device.c_str(), iface_name_size);
-
-    const int ioctl_result = ioctl(can_fd_, SIOCGIFINDEX, &ifr);
-    if (ioctl_result < 0)
-        close();
-
-    struct sockaddr_can addr;
-    memset(&addr, 0, sizeof(addr));
-    addr.can_family = AF_CAN;
-    addr.can_ifindex = ifr.ifr_ifindex;
-
-    const int bind_result = bind(can_fd_, (struct sockaddr *)&addr, sizeof(addr));
-    if (bind_result < 0)
-        close();
-    ;
-
-    can_interface_opened_ = true;
-
-    // NOTE: shared_from_this() should not be used in constructors
-
-    // give some work to io_service before start
-    stream.assign(can_fd_);
-    io_service.post(std::bind(&ASyncCAN::do_read, this, std::ref(rcv_frame), std::ref(stream)));
-
-    // run io_service for async io
-    io_thread = std::thread([this]() {
-        set_this_thread_name("mcan%zu", conn_id);
-        io_service.run();
-    });
-}
-
-void ASyncCAN::close()
-{
-    // lock_guard lock(mutex);
-    // if (!is_open())
-    //     return;
-
-    const int close_result = ::close(can_fd_);
-    can_fd_ = -1;
-
-    io_service.stop();
-
-    if (io_thread.joinable())
-        io_thread.join();
-
-    io_service.reset();
-
-    can_interface_opened_ = false;
-
-    if (port_closed_cb)
-        port_closed_cb();
-}
-
-ASyncCAN::IOStat ASyncCAN::get_iostat()
-{
-    std::lock_guard<std::recursive_mutex> lock(iostat_mutex);
-    IOStat stat;
-
-    stat.tx_total_frames = tx_total_frames;
-    stat.rx_total_frames = rx_total_frames;
-
-    auto d_tx = stat.tx_total_frames - last_tx_total_frames;
-    auto d_rx = stat.rx_total_frames - last_rx_total_frames;
-    last_tx_total_frames = stat.tx_total_frames;
-    last_rx_total_frames = stat.rx_total_frames;
-
-    auto now = steady_clock::now();
-    auto dt = now - last_iostat;
-    last_iostat = now;
-
-    float dt_s = std::chrono::duration_cast<std::chrono::seconds>(dt).count();
-
-    stat.tx_speed = d_tx / dt_s;
-    stat.rx_speed = d_rx / dt_s;
-
-    return stat;
-}
-
-void ASyncCAN::iostat_tx_add(size_t frame)
-{
-    tx_total_frames += frame;
-}
-
-void ASyncCAN::iostat_rx_add(size_t frame)
-{
-    rx_total_frames += frame;
-}
-
-void ASyncCAN::send_frame(const can_frame &tx_frame)
-{
-    iostat_tx_add(1);
-    stream.async_write_some(asio::buffer(&tx_frame, sizeof(tx_frame)),
-                            [](error_code error, size_t bytes_transferred) {
-                                // std::cout << "frame sent" << std::endl;
-                            });
-}
-
-void ASyncCAN::call_receive_callback(can_frame *rx_frame)
-{
-    // keep track of statistics
-    iostat_rx_add(1);
-
-    // call the actual parser
-    if (receive_cb)
-        receive_cb(rx_frame);
-    else
-        default_receive_callback(rx_frame);
-}
-
-void ASyncCAN::default_receive_callback(can_frame *rx_frame)
-{
-    // do nothing
-    // std::cerr << "no callback function set" << std::endl;
-    std::cout << std::hex << rx_frame->can_id << "  ";
-    for (int i = 0; i < rx_frame->can_dlc; i++)
-        std::cout << std::hex << int(rx_frame->data[i]) << " ";
-    std::cout << std::dec << std::endl;
-}
-
-void ASyncCAN::do_read(struct can_frame &rec_frame, asio::posix::basic_stream_descriptor<> &stream)
-{
-    auto sthis = shared_from_this();
-    stream.async_read_some(
-        asio::buffer(&rcv_frame, sizeof(rcv_frame)),
-        [sthis](error_code error, size_t bytes_transferred) {
-            if (error)
-            {
-                std::cerr << "read error in connection " << sthis->conn_id << " : "
-                          << error.message().c_str() << std::endl;
-                sthis->close();
-                return;
-            }
-
-            sthis->call_receive_callback(&sthis->rcv_frame);
-            sthis->do_read(std::ref(sthis->rcv_frame), std::ref(sthis->stream));
-        });
-}

scout_base/src/scout_sdk/src/sdk_core/async_io/src/async_serial.cpp

@@ -1,340 +0,0 @@
-/* 
- * async_serial.cpp
- * 
- * Created on: Nov 23, 2018 22:24
- * Description: asynchronous serial communication using asio
- *              adapted from code in libmavconn
- * 
- * Main changes: 1. Removed dependency on Boost (asio standalone
- *                  and C++ STL only)
- *               2. Removed dependency on console-bridge
- *               3. Removed mavlink related code
- *               4. Removed UDP/TCP related code
- * 
- * Author: Vladimir Ermakov <vooon341@gmail.com>
- *         Ruixiang Du <ruixiang.du@gmail.com>
- */
-/*
- * libmavconn
- * Copyright 2013,2014,2015,2016 Vladimir Ermakov, All rights reserved.
- *
- * This file is part of the mavros package and subject to the license terms
- * in the top-level LICENSE file of the mavros repository.
- * https://github.com/mavlink/mavros/tree/master/LICENSE.md
- */
-
-#include <cassert>
-#include <iostream>
-
-#include "async_io/async_serial.hpp"
-#include "asyncio_utils.hpp"
-
-#if defined(__linux__)
-#include <linux/serial.h>
-#endif
-
-using namespace wescore;
-
-using asio::buffer;
-using asio::io_service;
-using std::error_code;
-
-std::atomic<size_t> ASyncSerial::conn_id_counter{0};
-
-ASyncSerial::ASyncSerial(std::string device, unsigned baudrate, bool hwflow) : tx_total_bytes(0),
-                                                                               rx_total_bytes(0),
-                                                                               last_tx_total_bytes(0),
-                                                                               last_rx_total_bytes(0),
-                                                                               last_iostat(steady_clock::now()),
-                                                                               tx_in_progress(false),
-                                                                               tx_q{},
-                                                                               rx_buf{},
-                                                                               io_service(),
-                                                                               serial_dev(io_service)
-{
-    conn_id = conn_id_counter.fetch_add(1);
-    open(device, baudrate, hwflow);
-}
-
-ASyncSerial::~ASyncSerial()
-{
-    close();
-}
-
-void ASyncSerial::open(std::string device, unsigned baudrate, bool hwflow)
-{
-    using SPB = asio::serial_port_base;
-
-    std::cout << "connection: " << conn_id << " , device: " << device.c_str() << " @ " << baudrate << "bps" << std::endl;
-
-    try
-    {
-        serial_dev.open(device);
-
-        // Set baudrate and 8N1 mode
-        serial_dev.set_option(SPB::baud_rate(baudrate));
-        serial_dev.set_option(SPB::character_size(8));
-        serial_dev.set_option(SPB::parity(SPB::parity::none));
-        serial_dev.set_option(SPB::stop_bits(SPB::stop_bits::one));
-        serial_dev.set_option(SPB::flow_control((hwflow) ? SPB::flow_control::hardware : SPB::flow_control::none));
-
-#if defined(__linux__)
-        // Enable low latency mode on Linux
-        {
-            int fd = serial_dev.native_handle();
-
-            struct serial_struct ser_info;
-            ioctl(fd, TIOCGSERIAL, &ser_info);
-
-            ser_info.flags |= ASYNC_LOW_LATENCY;
-
-            ioctl(fd, TIOCSSERIAL, &ser_info);
-        }
-#endif
-    }
-    catch (std::system_error &err)
-    {
-        throw DeviceError("serial", err);
-    }
-
-    // NOTE: shared_from_this() should not be used in constructors
-
-    // give some work to io_service before start
-    io_service.post(std::bind(&ASyncSerial::do_read, this));
-
-    // run io_service for async io
-    io_thread = std::thread([this]() {
-        set_this_thread_name("mserial%zu", conn_id);
-        io_service.run();
-    });
-}
-
-void ASyncSerial::close()
-{
-    lock_guard lock(mutex);
-    if (!is_open())
-        return;
-
-    serial_dev.cancel();
-    serial_dev.close();
-
-    io_service.stop();
-
-    if (io_thread.joinable())
-        io_thread.join();
-
-    io_service.reset();
-
-    if (port_closed_cb)
-        port_closed_cb();
-}
-
-ASyncSerial::IOStat ASyncSerial::get_iostat()
-{
-    std::lock_guard<std::recursive_mutex> lock(iostat_mutex);
-    IOStat stat;
-
-    stat.tx_total_bytes = tx_total_bytes;
-    stat.rx_total_bytes = rx_total_bytes;
-
-    auto d_tx = stat.tx_total_bytes - last_tx_total_bytes;
-    auto d_rx = stat.rx_total_bytes - last_rx_total_bytes;
-    last_tx_total_bytes = stat.tx_total_bytes;
-    last_rx_total_bytes = stat.rx_total_bytes;
-
-    auto now = steady_clock::now();
-    auto dt = now - last_iostat;
-    last_iostat = now;
-
-    float dt_s = std::chrono::duration_cast<std::chrono::seconds>(dt).count();
-
-    stat.tx_speed = d_tx / dt_s;
-    stat.rx_speed = d_rx / dt_s;
-
-    return stat;
-}
-
-void ASyncSerial::iostat_tx_add(size_t bytes)
-{
-    tx_total_bytes += bytes;
-}
-
-void ASyncSerial::iostat_rx_add(size_t bytes)
-{
-    rx_total_bytes += bytes;
-}
-
-void ASyncSerial::send_bytes(const uint8_t *bytes, size_t length)
-{
-    if (!is_open())
-    {
-        std::cerr << "send: channel closed!"
-                  << " connection id: " << conn_id << std::endl;
-        return;
-    }
-
-    {
-        lock_guard lock(mutex);
-
-        if (tx_q.size() >= MAX_TXQ_SIZE)
-            throw std::length_error("ASyncSerial::send_bytes: TX queue overflow");
-
-        tx_q.emplace_back(bytes, length);
-    }
-    io_service.post(std::bind(&ASyncSerial::do_write, shared_from_this(), true));
-}
-
-void ASyncSerial::call_receive_callback(uint8_t *buf, const std::size_t bufsize, std::size_t bytes_received)
-{
-    assert(bufsize >= bytes_received);
-
-    // keep track of statistics
-    iostat_rx_add(bytes_received);
-
-    // call the actual parser
-    if (receive_cb)
-        receive_cb(buf, bufsize, bytes_received);
-    else
-        default_receive_callback(buf, bufsize, bytes_received);
-}
-
-void ASyncSerial::default_receive_callback(uint8_t *buf, const size_t bufsize, size_t bytes_received)
-{
-    // do nothing
-    std::cerr << "no callback function set" << std::endl;
-}
-
-void ASyncSerial::do_read(void)
-{
-    auto sthis = shared_from_this();
-    serial_dev.async_read_some(
-        buffer(rx_buf),
-        [sthis](error_code error, size_t bytes_transferred) {
-            if (error)
-            {
-                std::cerr << "read error in connection " << sthis->conn_id << " : "
-                          << error.message().c_str() << std::endl;
-                sthis->close();
-                return;
-            }
-
-            sthis->call_receive_callback(sthis->rx_buf.data(), sthis->rx_buf.size(), bytes_transferred);
-            sthis->do_read();
-        });
-
-    // std::cout << rx_buf.data() << std::endl;
-}
-
-void ASyncSerial::do_write(bool check_tx_state)
-{
-    if (check_tx_state && tx_in_progress)
-        return;
-
-    lock_guard lock(mutex);
-    if (tx_q.empty())
-        return;
-
-    tx_in_progress = true;
-    auto sthis = shared_from_this();
-    auto &buf_ref = tx_q.front();
-    serial_dev.async_write_some(
-        buffer(buf_ref.dpos(), buf_ref.nbytes()),
-        [sthis, &buf_ref](error_code error, size_t bytes_transferred) {
-            assert(bytes_transferred <= buf_ref.len);
-
-            if (error)
-            {
-                std::cerr << "write error in connection " << sthis->conn_id << " : "
-                          << error.message().c_str() << std::endl;
-                sthis->close();
-                return;
-            }
-
-            sthis->iostat_tx_add(bytes_transferred);
-            lock_guard lock(sthis->mutex);
-
-            if (sthis->tx_q.empty())
-            {
-                sthis->tx_in_progress = false;
-                return;
-            }
-
-            buf_ref.pos += bytes_transferred;
-            if (buf_ref.nbytes() == 0)
-            {
-                sthis->tx_q.pop_front();
-            }
-
-            if (!sthis->tx_q.empty())
-                sthis->do_write(false);
-            else
-                sthis->tx_in_progress = false;
-        });
-}
-
-//---------------------------------------------------------------------------------------//
-
-namespace
-{
-ASyncSerial::Ptr url_parse_serial(
-    std::string path, std::string query, bool hwflow)
-{
-    std::string file_path;
-    int baudrate;
-
-    url_parse_host(path, file_path, baudrate, ASyncSerial::DEFAULT_DEVICE, ASyncSerial::DEFAULT_BAUDRATE);
-    url_parse_query(query);
-
-    return std::make_shared<ASyncSerial>(file_path, baudrate, hwflow);
-}
-} // namespace
-
-ASyncSerial::Ptr ASyncSerial::open_url(std::string url)
-{
-    /* Based on code found here:
-	 * http://stackoverflow.com/questions/2616011/easy-way-to-parse-a-url-in-c-cross-platform
-	 */
-
-    const std::string proto_end("://");
-    std::string proto;
-    std::string host;
-    std::string path;
-    std::string query;
-
-    auto proto_it = std::search(
-        url.begin(), url.end(),
-        proto_end.begin(), proto_end.end());
-    if (proto_it == url.end())
-    {
-        // looks like file path
-        std::cout << "URL: " << url.c_str() << " looks like file path" << std::endl;
-        return url_parse_serial(url, "", false);
-    }
-
-    // copy protocol
-    proto.reserve(std::distance(url.begin(), proto_it));
-    std::transform(url.begin(), proto_it,
-                   std::back_inserter(proto),
-                   std::ref(tolower));
-
-    // copy host
-    std::advance(proto_it, proto_end.length());
-    auto path_it = std::find(proto_it, url.end(), '/');
-    std::transform(proto_it, path_it,
-                   std::back_inserter(host),
-                   std::ref(tolower));
-
-    // copy path, and query if exists
-    auto query_it = std::find(path_it, url.end(), '?');
-    path.assign(path_it, query_it);
-    if (query_it != url.end())
-        ++query_it;
-    query.assign(query_it, url.end());
-
-    if (proto == "serial")
-        return url_parse_serial(path, query, false);
-    else if (proto == "serial-hwfc")
-        return url_parse_serial(path, query, true);
-    else
-        throw DeviceError("url", "Unknown URL type");
-}

scout_base/src/scout_sdk/src/sdk_core/async_io/src/asyncio_utils.hpp

@@ -1,123 +0,0 @@
-/**
- * @brief MAVConn async serial utility class
- * @file async_utils.hpp
- * @author Vladimir Ermakov <vooon341@gmail.com>
- */
-/*
- * libmavconn
- * Copyright 2013,2014,2015,2016 Vladimir Ermakov, All rights reserved.
- *
- * This file is part of the mavros package and subject to the license terms
- * in the top-level LICENSE file of the mavros repository.
- * https://github.com/mavlink/mavros/tree/master/LICENSE.md
- */
-
-#ifndef ASYNCIO_UTILS_HPP
-#define ASYNCIO_UTILS_HPP
-
-#include <string>
-#include <algorithm>
-#include <iostream>
-
-namespace wescore
-{
-template <typename... Args>
-std::string format(const std::string &fmt, Args... args)
-{
-    // C++11 specify that string store elements continously
-    std::string ret;
-
-    auto sz = std::snprintf(nullptr, 0, fmt.c_str(), args...);
-    ret.reserve(sz + 1);
-    ret.resize(sz); // to be sure there have room for \0
-    std::snprintf(&ret.front(), ret.capacity() + 1, fmt.c_str(), args...);
-    return ret;
-}
-
-template <typename... Args>
-bool set_this_thread_name(const std::string &name, Args &&... args)
-{
-    auto new_name = format(name, std::forward<Args>(args)...);
-
-#ifdef __APPLE__
-    return pthread_setname_np(new_name.c_str()) == 0;
-#else
-    pthread_t pth = pthread_self();
-    return pthread_setname_np(pth, new_name.c_str()) == 0;
-#endif
-}
-
-/**
- * Parse host:port pairs
- */
-void url_parse_host(std::string host,
-                    std::string &host_out, int &port_out,
-                    const std::string def_host, const int def_port)
-{
-    std::string port;
-
-    auto sep_it = std::find(host.begin(), host.end(), ':');
-    if (sep_it == host.end())
-    {
-        // host
-        if (!host.empty())
-        {
-            host_out = host;
-            port_out = def_port;
-        }
-        else
-        {
-            host_out = def_host;
-            port_out = def_port;
-        }
-        return;
-    }
-
-    if (sep_it == host.begin())
-    {
-        // :port
-        host_out = def_host;
-    }
-    else
-    {
-        // host:port
-        host_out.assign(host.begin(), sep_it);
-    }
-
-    port.assign(sep_it + 1, host.end());
-    port_out = std::stoi(port);
-}
-
-/**
- * Parse ?ids=sid,cid
- */
-void url_parse_query(std::string query)
-{
-    const std::string ids_end("ids=");
-    std::string sys, comp;
-
-    if (query.empty())
-        return;
-
-    auto ids_it = std::search(query.begin(), query.end(),
-                              ids_end.begin(), ids_end.end());
-    if (ids_it == query.end())
-    {
-        std::cerr << "URL: unknown query arguments" << std::endl;
-        return;
-    }
-
-    std::advance(ids_it, ids_end.length());
-    auto comma_it = std::find(ids_it, query.end(), ',');
-    if (comma_it == query.end())
-    {
-        std::cerr << "URL: no comma in ids= query" << std::endl;
-        return;
-    }
-
-    sys.assign(ids_it, comma_it);
-    comp.assign(comma_it + 1, query.end());
-}
-} // namespace wescore
-
-#endif /* ASYNCIO_UTILS_HPP */

scout_base/src/scout_sdk/src/sdk_core/async_io/tests/CMakeLists.txt

@@ -1,9 +0,0 @@
-# Add executables
-add_executable(test_aserial test_aserial.cpp)
-target_link_libraries(test_aserial asyncio)
-
-add_executable(test_asio_can test_asio_can.cpp)
-target_link_libraries(test_asio_can asio pthread)
-
-add_executable(test_acan test_acan.cpp)
-target_link_libraries(test_acan asyncio)

scout_base/src/scout_sdk/src/sdk_core/async_io/tests/test_acan.cpp

@@ -1,60 +0,0 @@
-#include <iostream>
-#include "async_io/async_can.hpp"
-
-using namespace wescore;
-
-void parse_buffer(uint8_t *buf, const size_t bufsize, size_t bytes_received)
-{
-    std::cout << "parser called" << std::endl;
-
-    // mavlink::mavlink_status_t status;
-    // mavlink::mavlink_message_t message;
-
-    for (; bytes_received > 0; bytes_received--)
-    {
-        auto c = *buf++;
-
-        // 	// based on mavlink_parse_char()
-        // 	auto msg_received = static_cast<Framing>(mavlink::mavlink_frame_char_buffer(&m_buffer, &m_status, c, &message, &status));
-        // 	if (msg_received == Framing::bad_crc || msg_received == Framing::bad_signature) {
-        // 		mavlink::_mav_parse_error(&m_status);
-        // 		m_status.msg_received = mavlink::MAVLINK_FRAMING_INCOMPLETE;
-        // 		m_status.parse_state = mavlink::MAVLINK_PARSE_STATE_IDLE;
-        // 		if (c == MAVLINK_STX) {
-        // 			m_status.parse_state = mavlink::MAVLINK_PARSE_STATE_GOT_STX;
-        // 			m_buffer.len = 0;
-        // 			mavlink::mavlink_start_checksum(&m_buffer);
-        // 		}
-        // 	}
-
-        // 	if (msg_received != Framing::incomplete) {
-        // 		log_recv(pfx, message, msg_received);
-
-        // 		if (message_received_cb)
-        // 			message_received_cb(&message, msg_received);
-        // 	}
-    }
-}
-
-int main(int argc, char *argv[])
-{
-    std::shared_ptr<ASyncCAN> canbus = std::make_shared<ASyncCAN>("can1");
-
-    // canbus->set_receive_callback(parse_buffer);
-
-    // if (canbus->is_open())
-    //     std::cout << "can bus connected" << std::endl;
-
-    struct can_frame frame;
-    frame.can_id = 0x123;
-    frame.can_dlc = 2;
-    frame.data[0] = 0x11;
-    frame.data[1] = 0x23;
-
-    while (1)
-    {
-        // canbus->send_bytes(data, 3);
-        canbus->send_frame(frame);
-        sleep(1);
-    }
-}

scout_base/src/scout_sdk/src/sdk_core/async_io/tests/test_aserial.cpp

@@ -1,64 +0,0 @@
-/*
- * test_interface.cpp
- *
- *  Created on: Dec 25, 2016
- *      Author: rdu
- */
-
-#include <iostream>
-
-#include "async_io/async_serial.hpp"
-
-using namespace wescore;
-
-void parse_buffer(uint8_t *buf, const size_t bufsize, size_t bytes_received)
-{
-    std::cout << "parser called" << std::endl;
-
-    // mavlink::mavlink_status_t status;
-    // mavlink::mavlink_message_t message;
-
-    for (; bytes_received > 0; bytes_received--)
-    {
-        auto c = *buf++;
-
-        // 	// based on mavlink_parse_char()
-        // 	auto msg_received = static_cast<Framing>(mavlink::mavlink_frame_char_buffer(&m_buffer, &m_status, c, &message, &status));
-        // 	if (msg_received == Framing::bad_crc || msg_received == Framing::bad_signature) {
-        // 		mavlink::_mav_parse_error(&m_status);
-        // 		m_status.msg_received = mavlink::MAVLINK_FRAMING_INCOMPLETE;
-        // 		m_status.parse_state = mavlink::MAVLINK_PARSE_STATE_IDLE;
-        // 		if (c == MAVLINK_STX) {
-        // 			m_status.parse_state = mavlink::MAVLINK_PARSE_STATE_GOT_STX;
-        // 			m_buffer.len = 0;
-        // 			mavlink::mavlink_start_checksum(&m_buffer);
-        // 		}
-        // 	}
-
-        // 	if (msg_received != Framing::incomplete) {
-        // 		log_recv(pfx, message, msg_received);
-
-        // 		if (message_received_cb)
-        // 			message_received_cb(&message, msg_received);
-        // 	}
-    }
-}
-
-int main(int argc, char *argv[])
-{
-    // ASyncSerial::Ptr serial = ASyncSerial::open_url("/dev/ttyUSB0:115200");
-    std::shared_ptr<ASyncSerial> serial = std::make_shared<ASyncSerial>("/dev/pts/6", 115200);
-
-    serial->set_receive_callback(parse_buffer);
-
-    if (serial->is_open())
-        std::cout << "serial port opened" << std::endl;
-
-    uint8_t data[8] = {'a','b','c'};
-
-    while (1)
-    {
-        serial->send_bytes(data, 3);
-        sleep(1);
-    }
-}

scout_base/src/scout_sdk/src/sdk_core/async_io/tests/test_asio_can.cpp

@@ -1,79 +0,0 @@
-// source: https://stackoverflow.com/questions/10467178/boostasio-over-socketcan
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <iostream>
-
-#include <net/if.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-
-#include <linux/can.h>
-#include <linux/can/raw.h>
-
-#define ASIO_ENABLE_OLD_SERVICES
-#define ASIO_HAS_POSIX_STREAM_DESCRIPTOR
-
-#include "asio.hpp"
-#include <functional>
-
-#include "asio/posix/basic_stream_descriptor.hpp"
-
-void data_send(void)
-{
-    std::cout << "omg sent" << std::endl;
-}
-
-void data_rec(struct can_frame &rec_frame,
-              asio::posix::basic_stream_descriptor<> &stream)
-{
-    std::cout << std::hex << rec_frame.can_id << "  ";
-    for (int i = 0; i < rec_frame.can_dlc; i++)
-    {
-        std::cout << std::hex << int(rec_frame.data[i]) << " ";
-    }
-    std::cout << std::dec << std::endl;
-    stream.async_read_some(
-        asio::buffer(&rec_frame, sizeof(rec_frame)),
-        std::bind(data_rec, std::ref(rec_frame), std::ref(stream)));
-}
-
-int main(void)
-{
-    struct sockaddr_can addr;
-    struct can_frame frame;
-    struct can_frame rec_frame;
-    struct ifreq ifr;
-
-    int natsock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
-
-    strcpy(ifr.ifr_name, "can1");
-    ioctl(natsock, SIOCGIFINDEX, &ifr);
-
-    addr.can_family = AF_CAN;
-    addr.can_ifindex = ifr.ifr_ifindex;
-    if (bind(natsock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
-    {
-        perror("Error in socket bind");
-        return -2;
-    }
-
-    frame.can_id = 0x123;
-    frame.can_dlc = 2;
-    frame.data[0] = 0x11;
-    frame.data[1] = 0x23;
-
-    asio::io_service ios;
-    asio::posix::basic_stream_descriptor<> stream(ios);
-    stream.assign(natsock);
-
-    stream.async_write_some(asio::buffer(&frame, sizeof(frame)),
-                            std::bind(data_send));
-    stream.async_read_some(
-        asio::buffer(&rec_frame, sizeof(rec_frame)),
-        std::bind(data_rec, std::ref(rec_frame), std::ref(stream)));
-    ios.run();
-}

scout_base/src/scout_sdk/src/sdk_core/scout_base/CMakeLists.txt

@@ -1,18 +0,0 @@
-## Add libraries
-set(SCOUT_BASE_SRC 
-    src/scout_base.cpp
-    # src/scout_serial.cpp
-)
-add_library(scoutbase STATIC ${SCOUT_BASE_SRC})
-set_target_properties(scoutbase PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(scoutbase asyncio)
-target_include_directories(scoutbase PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-    $<BUILD_INTERFACE:${Boost_INCLUDE_DIRS}>
-	$<INSTALL_INTERFACE:include>	
-    PRIVATE src)
-
- ## Add executables
-if(BUILD_TESTS)
-    add_subdirectory(tests)
-endif()

scout_base/src/scout_sdk/src/sdk_core/scout_base/include/scout/scout_base.hpp

@@ -1,76 +0,0 @@
-/* 
- * scout_base.hpp
- * 
- * Created on: Jun 04, 2019 01:22
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef SCOUT_BASE_HPP
-#define SCOUT_BASE_HPP
-
-#include <string>
-#include <cstdint>
-#include <thread>
-#include <mutex>
-#include <functional>
-
-#include "async_io/async_can.hpp"
-
-#include "scout/scout_state.hpp"
-#include "scout/scout_command.hpp"
-
-namespace wescore
-{
-class ScoutBase
-{
-public:
-    ScoutBase() = default;
-    ~ScoutBase();
-
-    // do not allow copy
-    ScoutBase(const ScoutBase &scout) = delete;
-    ScoutBase &operator=(const ScoutBase &scout) = delete;
-
-public:
-    void ConnectCANBus(const std::string &can_if_name = "can1");
-    void StartCmdThread(int32_t period_ms);
-
-    // motion control
-    void SetMotionCommand(double linear_vel, double angular_vel,
-                          ScoutMotionCmd::FaultClearFlag fault_clr_flag = ScoutMotionCmd::FaultClearFlag::NO_FAULT);
-
-    // light control
-    void SetLightCommand(ScoutLightCmd cmd);
-    void DisableLightCmdControl();
-
-    // get robot state
-    ScoutState GetScoutState();
-
-    // TODO internal use only, for testing, will be set private in future release
-    void UpdateScoutState(ScoutState &state, can_frame *rx_frame);
-
-private:
-    std::shared_ptr<ASyncCAN> can_if_;
-
-    std::thread cmd_thread_;
-    std::mutex scout_state_mutex_;
-    std::mutex motion_cmd_mutex_;
-    std::mutex light_cmd_mutex_;
-
-    ScoutState scout_state_;
-    ScoutMotionCmd current_motion_cmd_;
-    ScoutLightCmd current_light_cmd_;
-
-    bool cmd_thread_started_ = false;
-
-    bool light_ctrl_enabled_ = false;
-    bool light_ctrl_requested_ = false;
-
-    void ControlLoop(int32_t period_ms);
-    void ParseCANFrame(can_frame *rx_frame);
-};
-} // namespace wescore
-
-#endif /* SCOUT_BASE_HPP */

scout_base/src/scout_sdk/src/sdk_core/scout_base/include/scout/scout_can_protocol.h

@@ -1,337 +0,0 @@
-/* 
- * scout_can_protocol.h
- * 
- * Created on: Jun 10, 2019 23:23
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef SCOUT_CAN_PROTOCOL_H
-#define SCOUT_CAN_PROTOCOL_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "stdint.h"
-
-enum ScoutCANMsgIDs
-{
-    MSG_MOTION_CONTROL_ID = 0x130,
-    MSG_MOTION_CONTROL_FEEDBACK_ID = 0x131,
-    MSG_LIGHT_CONTROL_ID = 0x140,
-    MSG_LIGHT_CONTROL_FEEDBACK_ID = 0x141,
-    MSG_SYSTEM_STATUS_FEEDBACK_ID = 0x151,
-    MSG_MOTOR1_DRIVER_FEEDBACK_ID = 0x200,
-    MSG_MOTOR2_DRIVER_FEEDBACK_ID = 0x201,
-    MSG_MOTOR3_DRIVER_FEEDBACK_ID = 0x202,
-    MSG_MOTOR4_DRIVER_FEEDBACK_ID = 0x203,
-    MSG_LAST_ID
-};
-
-static uint8_t Agilex_CANMsgChecksum(uint16_t id, uint8_t *data, uint8_t dlc)
-{
-    uint8_t checksum = 0x00;
-    checksum = (uint8_t)(id & 0x00ff) + (uint8_t)(id >> 8) + dlc;
-    for (int i = 0; i < (dlc - 1); ++i)
-        checksum += data[i];
-    return checksum;
-};
-
-/*------------------------- Motion Control Message -------------------------*/
-
-enum ControlMode
-{
-    REMOTE_MODE = 0x00,
-    CMD_CAN_MODE = 0x01,
-    CMD_UART_MODE = 0x02
-};
-
-enum FaultClearFlag
-{
-    NO_FAULT = 0x00,
-    BAT_UNDER_VOL = 0x01,
-    BAT_OVER_VOL = 0x02,
-    MOTOR1_COMM = 0x03,
-    MOTOR2_COMM = 0x04,
-    MOTOR3_COMM = 0x05,
-    MOTOR4_COMM = 0x06,
-    MOTOR_DRV_OVERHEAT = 0x07,
-    MOTOR_OVERCURRENT = 0x08
-};
-
-typedef struct
-{
-    const uint16_t id = MSG_MOTION_CONTROL_ID;
-    const uint8_t dlc = 0x08;
-    union {
-        struct CmdDef
-        {
-            uint8_t control_mode;
-            uint8_t fault_clear_flag;
-            int8_t linear_velocity_cmd;
-            int8_t angular_velocity_cmd;
-            uint8_t reserved0;
-            uint8_t reserved1;
-            uint8_t count;
-            uint8_t checksum;
-        } cmd;
-        uint8_t raw[8];
-    } data;
-} MotionControlMessage;
-
-/*-------------------------- Light Control Message -------------------------*/
-
-enum LightControlFlag
-{
-    DISABLE_LIGHT_CTRL = 0x00,
-    ENABLE_LIGHT_CTRL = 0x01
-};
-
-enum LightMode
-{
-    CONST_OFF = 0x00,
-    CONST_ON = 0x01,
-    BREATH = 0x02,
-    CUSTOM = 0x03
-};
-
-typedef struct
-{
-    const uint16_t id = MSG_LIGHT_CONTROL_ID;
-    const uint8_t dlc = 0x08;
-    union {
-        struct CmdDef
-        {
-            uint8_t light_ctrl_enable;
-            uint8_t front_light_mode;
-            uint8_t front_light_custom;
-            uint8_t rear_light_mode;
-            uint8_t rear_light_custom;
-            uint8_t reserved0;
-            uint8_t count;
-            uint8_t checksum;
-        } cmd;
-        uint8_t raw[8];
-    } data;
-} LightControlMessage;
-
-/*--------------------- Motion Control Feedback Message --------------------*/
-
-typedef struct
-{
-    const uint16_t id = MSG_MOTION_CONTROL_FEEDBACK_ID;
-    const uint8_t dlc = 0x08;
-    union {
-        struct StatusDef
-        {
-            struct {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } linear_velocity;
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } angular_velocity;
-            uint8_t reserved0;
-            uint8_t reserved1;
-            uint8_t count;
-            uint8_t checksum;
-        } status;
-        uint8_t raw[8];
-    } data;
-} MotionStatusMessage;
-
-/*---------------------- Light Control Feedback Message --------------------*/
-
-typedef struct
-{
-    const uint16_t id = MSG_LIGHT_CONTROL_FEEDBACK_ID;
-    const uint8_t dlc = 0x08;
-    union {
-        struct StatusDef
-        {
-            uint8_t light_ctrl_enable;
-            uint8_t front_light_mode;
-            uint8_t front_light_custom;
-            uint8_t rear_light_mode;
-            uint8_t rear_light_custom;
-            uint8_t reserved0;
-            uint8_t count;
-            uint8_t checksum;
-        } status;
-        uint8_t raw[8];
-    } data;
-} LightStatusMessage;
-
-/*---------------------- System Status Feedback Message --------------------*/
-
-enum BaseState
-{
-    BASE_NORMAL,
-    BASE_ESTOP,
-    BASE_EXCEPTION
-};
-
-enum FaultBits
-{
-    CAN_CHECKSUM_ERROR = 0x0100,
-    MOTOR_DRV_OVERHEAT_W = 0x0200,
-    MOTOR_OVERCURRENT_W = 0x0400,
-    BAT_UNDER_VOL_W = 0x0800,
-
-    BAT_UNDER_VOL_F = 0x01,
-    BAT_OVER_VOL_F = 0x02,
-    MOTOR1_COMM_F = 0x04,
-    MOTOR2_COMM_F = 0x08,
-    MOTOR3_COMM_F = 0x10,
-    MOTOR4_COMM_F = 0x20,
-    MOTOR_DRV_OVERHEAT_F = 0x40,
-    MOTOR_OVERCURRENT_F = 0x80
-};
-
-typedef struct
-{
-    const uint16_t id = MSG_SYSTEM_STATUS_FEEDBACK_ID;
-    const uint8_t dlc = 0x08;
-    union {
-        struct StatusDef
-        {
-            uint8_t base_state;
-            uint8_t control_mode;
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } battery_voltage;
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } fault_code;
-            uint8_t count;
-            uint8_t checksum;
-        } status;
-        uint8_t raw[8];
-    } data;
-} SystemStatusMessage;
-
-/*--------------------- Motor 1 Driver Feedback Message --------------------*/
-
-typedef struct
-{
-    const uint16_t id = MSG_MOTOR1_DRIVER_FEEDBACK_ID;
-    const uint8_t dlc = 0x08;
-    union {
-        struct StatusDef
-        {
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } current;
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } rpm;
-            int8_t temperature;
-            uint8_t reserved0;
-            uint8_t count;
-            uint8_t checksum;
-        } status;
-        uint8_t raw[8];
-    } data;
-} Motor1DriverStatusMessage;
-
-/*--------------------- Motor 2 Driver Feedback Message --------------------*/
-
-typedef struct
-{
-    const uint16_t id = MSG_MOTOR2_DRIVER_FEEDBACK_ID;
-    const uint8_t dlc = 0x08;
-    union {
-        struct StatusDef
-        {
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } current;
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } rpm;
-            int8_t temperature;
-            uint8_t reserved0;
-            uint8_t count;
-            uint8_t checksum;
-        } status;
-        uint8_t raw[8];
-    } data;
-} Motor2DriverStatusMessage;
-
-/*--------------------- Motor 3 Driver Feedback Message --------------------*/
-
-typedef struct
-{
-    const uint16_t id = MSG_MOTOR3_DRIVER_FEEDBACK_ID;
-    const uint8_t dlc = 0x08;
-    union {
-        struct StatusDef
-        {
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } current;
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } rpm;
-            int8_t temperature;
-            uint8_t reserved0;
-            uint8_t count;
-            uint8_t checksum;
-        } status;
-        uint8_t raw[8];
-    } data;
-} Motor3DriverStatusMessage;
-
-/*--------------------- Motor 4 Driver Feedback Message --------------------*/
-
-typedef struct
-{
-    const uint16_t id = MSG_MOTOR4_DRIVER_FEEDBACK_ID;
-    const uint8_t dlc = 0x08;
-    union {
-        struct StatusDef
-        {
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } current;
-            struct
-            {
-                uint8_t high_byte;
-                uint8_t low_byte;
-            } rpm;
-            int8_t temperature;
-            uint8_t reserved0;
-            uint8_t count;
-            uint8_t checksum;
-        } status;
-        uint8_t raw[8];
-    } data;
-} Motor4DriverStatusMessage;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SCOUT_CAN_PROTOCOL_H */

scout_base/src/scout_sdk/src/sdk_core/scout_base/include/scout/scout_command.hpp

@@ -1,68 +0,0 @@
-/* 
- * scout_command.hpp
- * 
- * Created on: Jun 11, 2019 10:33
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef SCOUT_COMMAND_HPP
-#define SCOUT_COMMAND_HPP
-
-#include <cstdint>
-
-namespace wescore
-{
-struct ScoutMotionCmd
-{
-    enum class FaultClearFlag
-    {
-        NO_FAULT = 0x00,
-        BAT_UNDER_VOL = 0x01,
-        BAT_OVER_VOL = 0x02,
-        MOTOR1_COMM = 0x03,
-        MOTOR2_COMM = 0x04,
-        MOTOR3_COMM = 0x05,
-        MOTOR4_COMM = 0x06,
-        MOTOR_DRV_OVERHEAT = 0x07,
-        MOTOR_OVERCURRENT = 0x08
-    };
-
-    ScoutMotionCmd(int8_t linear = 0, int8_t angular = 0,
-                   FaultClearFlag fault_clr_flag = FaultClearFlag::NO_FAULT)
-        : linear_velocity(linear), angular_velocity(angular),
-          fault_clear_flag(fault_clr_flag) {}
-
-    int8_t linear_velocity;
-    int8_t angular_velocity;
-    FaultClearFlag fault_clear_flag;
-
-    static constexpr double max_linear_velocity = 1.5;      // 1.5m/s
-    static constexpr double min_linear_velocity = -1.5;     // -1.5m/s
-    static constexpr double max_angular_velocity = 0.7853;  // 0.7853rad/s
-    static constexpr double min_angular_velocity = -0.7853; // -0.7853rad/s
-};
-
-struct ScoutLightCmd
-{
-    enum class LightMode
-    {
-        CONST_OFF = 0x00,
-        CONST_ON = 0x01,
-        BREATH = 0x02,
-        CUSTOM = 0x03
-    };
-
-    ScoutLightCmd() = default;
-    ScoutLightCmd(LightMode f_mode, uint8_t f_value, LightMode r_mode, uint8_t r_value) : front_mode(f_mode), front_custom_value(f_value),
-                                                                                          rear_mode(r_mode), rear_custom_value(r_value) {}
-
-    LightMode front_mode;
-    uint8_t front_custom_value;
-    LightMode rear_mode;
-    uint8_t rear_custom_value;
-};
-} // namespace wescore
-
-#endif /* SCOUT_COMMAND_HPP */

scout_base/src/scout_sdk/src/sdk_core/scout_base/include/scout/scout_io.hpp

@@ -1,21 +0,0 @@
-/* 
- * scout_io.hpp
- * 
- * Created on: May 04, 2019 22:04
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef SCOUT_IO_HPP
-#define SCOUT_IO_HPP
-
-namespace scout
-{
-class ScoutIO
-{
-public:
-};
-} // namespace scout
-
-#endif /* SCOUT_IO_HPP */

scout_base/src/scout_sdk/src/sdk_core/scout_base/include/scout/scout_serial.hpp

@@ -1,66 +0,0 @@
-/* 
- * scout_serial.h
- * 
- * Created on: May 05, 2019 11:35
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef SCOUT_SERIAL_H
-#define SCOUT_SERIAL_H
-
-#include "scout_io/scout_io.h"
-
-namespace scout
-{
-struct Frame_t
-{
-    unsigned short Header;
-    unsigned char Len;
-    unsigned char Typedef;
-    unsigned char Count;
-    unsigned char Time_Out;
-    short Linear;
-    short Angular;
-    unsigned short CheckSum;
-};
-
-struct Cmd_t
-{
-    unsigned short Linear;
-    unsigned short Angular;
-    bool IsUpdata;
-};
-
-typedef enum
-{
-    eHead = 0,
-    eLen = 1,
-    eTypedef = 3,
-    eChecksum = 2
-} state_t;
-
-class ScoutSerial : public ScoutIO
-{
-public:
-    Cmd_t Get_dataOfTransport();
-    void Set_dataOfTransport(Cmd_t *CMD);
-    void Read_DataOfChassis_Loop(void);
-    void Send_SpeedToChassis(short Angular, short Linear, unsigned char Count);
-    void Send_Speed(short Angular, short Linear, unsigned char Count);
-    unsigned short Checksum(unsigned char *data, unsigned short len);
-    void Find_NextHead();
-};
-
-Cmd_t Get_dataOfTransport();
-void Set_dataOfTransport(Cmd_t *CMD);
-void Read_DataOfChassis_Loop(void);
-void Send_SpeedToChassis(short Angular, short Linear, unsigned char Count);
-void Send_Speed(short Angular, short Linear, unsigned char Count);
-unsigned short Checksum(unsigned char *data, unsigned short len);
-void Find_NextHead();
-void Send_SpeedToChassis(short Angular, short Linear, unsigned char Count);
-} // namespace scout
-
-#endif /* SCOUT_SERIAL_H */

scout_base/src/scout_sdk/src/sdk_core/scout_base/include/scout/scout_serial_protocol.h

@@ -1,36 +0,0 @@
-/* 
- * scout_serial_protocol.hpp
- * 
- * Created on: Jun 05, 2019 02:34
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef SCOUT_SERIAL_PROTOCOL_HPP
-#define SCOUT_SERIAL_PROTOCOL_HPP
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct ScoutSerialProtocol
-{
-    struct Frame
-    {
-        unsigned short Header;
-        unsigned char Len;
-        unsigned char Typedef;
-        unsigned char Count;
-        unsigned char Time_Out;
-        short Linear;
-        short Angular;
-        unsigned short CheckSum;
-    };
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SCOUT_SERIAL_PROTOCOL_HPP */

scout_base/src/scout_sdk/src/sdk_core/scout_base/include/scout/scout_state.hpp

@@ -1,61 +0,0 @@
-/* 
- * scout_state.hpp
- * 
- * Created on: Jun 11, 2019 08:48
- * Description: 
- * 
- * Copyright (c) 2019 Ruixiang Du (rdu)
- */
-
-#ifndef SCOUT_STATE_HPP
-#define SCOUT_STATE_HPP
-
-#include <cstdint>
-#include <iostream>
-
-namespace wescore
-{
-struct ScoutState
-{
-    enum MotorID
-    {
-        FRONT_RIGHT = 0,
-        FRONT_LEFT = 1,
-        REAR_LEFT = 2,
-        REAR_RIGHT = 3
-    };
-
-    struct MotorState
-    {
-        double current = 0; // in A
-        double rpm = 0;
-        double temperature = 0;
-    };
-
-    struct LightState
-    {
-        uint8_t mode = 0;
-        uint8_t custom_value = 0;
-    };
-
-    // base state
-    uint8_t base_state = 0;
-    uint8_t control_mode = 0;
-    uint16_t fault_code = 0;
-    double battery_voltage = 0.0;
-
-    // motor state
-    MotorState motor_states[4];
-
-    // light state
-    bool light_control_enabled = false;
-    LightState front_light_state;
-    LightState rear_light_state;
-
-    // motion state
-    double linear_velocity;
-    double angular_velocity;
-};
-} // namespace wescore
-
-#endif /* SCOUT_STATE_HPP */

scout_base/src/scout_sdk/src/sdk_core/scout_base/src/scout_base.cpp

@@ -1,316 +0,0 @@
-#include "scout/scout_base.hpp"
-
-#include <string>
-#include <cstring>
-#include <iostream>
-#include <algorithm>
-#include <array>
-#include <chrono>
-#include <cstdint>
-#include <ratio>
-#include <thread>
-
-#include "scout/scout_can_protocol.h"
-
-namespace
-{
-// source: https://github.com/rxdu/stopwatch
-struct StopWatch
-{
-    using Clock = std::chrono::high_resolution_clock;
-    using time_point = typename Clock::time_point;
-    using duration = typename Clock::duration;
-
-    StopWatch() { tic_point = Clock::now(); };
-
-    time_point tic_point;
-
-    void tic()
-    {
-        tic_point = Clock::now();
-    };
-
-    double toc()
-    {
-        return std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - tic_point).count() / 1000000.0;
-    };
-
-    // for different precisions
-    double stoc()
-    {
-        return std::chrono::duration_cast<std::chrono::seconds>(Clock::now() - tic_point).count();
-    };
-
-    double mtoc()
-    {
-        return std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - tic_point).count();
-    };
-
-    double utoc()
-    {
-        return std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - tic_point).count();
-    };
-
-    double ntoc()
-    {
-        return std::chrono::duration_cast<std::chrono::nanoseconds>(Clock::now() - tic_point).count();
-    };
-
-    // you have to call tic() before calling this function
-    void sleep_until_ms(int64_t period_ms)
-    {
-        int64_t duration = period_ms - std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - tic_point).count();
-
-        if (duration > 0)
-            std::this_thread::sleep_for(std::chrono::milliseconds(duration));
-    };
-
-    void sleep_until_us(int64_t period_us)
-    {
-        int64_t duration = period_us - std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - tic_point).count();
-
-        if (duration > 0)
-            std::this_thread::sleep_for(std::chrono::microseconds(duration));
-    };
-};
-} // namespace
-
-namespace wescore
-{
-ScoutBase::~ScoutBase()
-{
-    if (cmd_thread_.joinable())
-        cmd_thread_.join();
-}
-
-void ScoutBase::ConnectCANBus(const std::string &can_if_name)
-{
-    can_if_ = std::make_shared<ASyncCAN>(can_if_name);
-
-    can_if_->set_receive_callback(std::bind(&ScoutBase::ParseCANFrame, this, std::placeholders::_1));
-}
-
-void ScoutBase::StartCmdThread(int32_t period_ms)
-{
-    cmd_thread_ = std::thread(std::bind(&ScoutBase::ControlLoop, this, period_ms));
-    cmd_thread_started_ = true;
-}
-
-void ScoutBase::ControlLoop(int32_t period_ms)
-{
-    StopWatch ctrl_sw;
-    uint8_t cmd_count = 0;
-    uint8_t light_cmd_count = 0;
-    while (true)
-    {
-        ctrl_sw.tic();
-
-        // motion control message
-        {
-            MotionControlMessage m_msg;
-
-            m_msg.data.cmd.control_mode = CMD_CAN_MODE;
-
-            motion_cmd_mutex_.lock();
-            m_msg.data.cmd.fault_clear_flag = static_cast<uint8_t>(current_motion_cmd_.fault_clear_flag);
-            m_msg.data.cmd.linear_velocity_cmd = current_motion_cmd_.linear_velocity;
-            m_msg.data.cmd.angular_velocity_cmd = current_motion_cmd_.angular_velocity;
-            motion_cmd_mutex_.unlock();
-
-            m_msg.data.cmd.reserved0 = 0;
-            m_msg.data.cmd.reserved1 = 0;
-            m_msg.data.cmd.count = cmd_count++;
-            m_msg.data.cmd.checksum = Agilex_CANMsgChecksum(m_msg.id, m_msg.data.raw, m_msg.dlc);
-
-            // send to can bus
-            can_frame m_frame;
-            m_frame.can_id = m_msg.id;
-            m_frame.can_dlc = m_msg.dlc;
-            std::memcpy(m_frame.data, m_msg.data.raw, m_msg.dlc * sizeof(uint8_t));
-            can_if_->send_frame(m_frame);
-        }
-
-        // check if there is request for light control
-        if (light_ctrl_requested_)
-        {
-            LightControlMessage l_msg;
-
-            light_cmd_mutex_.lock();
-            if (light_ctrl_enabled_)
-            {
-                l_msg.data.cmd.light_ctrl_enable = ENABLE_LIGHT_CTRL;
-
-                l_msg.data.cmd.front_light_mode = static_cast<uint8_t>(current_light_cmd_.front_mode);
-                l_msg.data.cmd.front_light_custom = current_light_cmd_.front_custom_value;
-                l_msg.data.cmd.rear_light_mode = static_cast<uint8_t>(current_light_cmd_.rear_mode);
-                l_msg.data.cmd.rear_light_custom = current_light_cmd_.rear_custom_value;
-            }
-            else
-            {
-                l_msg.data.cmd.light_ctrl_enable = DISABLE_LIGHT_CTRL;
-
-                l_msg.data.cmd.front_light_mode = CONST_OFF;
-                l_msg.data.cmd.front_light_custom = 0;
-                l_msg.data.cmd.rear_light_mode = CONST_OFF;
-                l_msg.data.cmd.rear_light_custom = 0;
-            }
-            light_ctrl_requested_ = false;
-            light_cmd_mutex_.unlock();
-
-            l_msg.data.cmd.reserved0 = 0;
-            l_msg.data.cmd.count = light_cmd_count++;
-            l_msg.data.cmd.checksum = Agilex_CANMsgChecksum(l_msg.id, l_msg.data.raw, l_msg.dlc);
-
-            can_frame l_frame;
-            l_frame.can_id = l_msg.id;
-            l_frame.can_dlc = l_msg.dlc;
-            std::memcpy(l_frame.data, l_msg.data.raw, l_msg.dlc * sizeof(uint8_t));
-            can_if_->send_frame(l_frame);
-        }
-
-        ctrl_sw.sleep_until_ms(period_ms);
-        // std::cout << "control loop update frequency: " << 1.0 / ctrl_sw.toc() << std::endl;
-    }
-}
-
-ScoutState ScoutBase::GetScoutState()
-{
-    std::lock_guard<std::mutex> guard(scout_state_mutex_);
-    return scout_state_;
-}
-
-void ScoutBase::SetMotionCommand(double linear_vel, double angular_vel, ScoutMotionCmd::FaultClearFlag fault_clr_flag)
-{
-    // make sure cmd thread is started before attempting to send commands
-    if (!cmd_thread_started_)
-        StartCmdThread(10);
-
-    if (linear_vel < ScoutMotionCmd::min_linear_velocity)
-        linear_vel = ScoutMotionCmd::min_linear_velocity;
-    if (linear_vel > ScoutMotionCmd::max_linear_velocity)
-        linear_vel = ScoutMotionCmd::max_linear_velocity;
-    if (angular_vel < ScoutMotionCmd::min_angular_velocity)
-        angular_vel = ScoutMotionCmd::min_angular_velocity;
-    if (angular_vel > ScoutMotionCmd::max_angular_velocity)
-        angular_vel = ScoutMotionCmd::max_angular_velocity;
-
-    std::lock_guard<std::mutex> guard(motion_cmd_mutex_);
-    current_motion_cmd_.linear_velocity = static_cast<uint8_t>(linear_vel / ScoutMotionCmd::max_linear_velocity * 100.0);
-    current_motion_cmd_.angular_velocity = static_cast<uint8_t>(angular_vel / ScoutMotionCmd::max_angular_velocity * 100.0);
-    current_motion_cmd_.fault_clear_flag = fault_clr_flag;
-}
-
-void ScoutBase::SetLightCommand(ScoutLightCmd cmd)
-{
-    std::lock_guard<std::mutex> guard(light_cmd_mutex_);
-    current_light_cmd_ = cmd;
-    light_ctrl_enabled_ = true;
-    light_ctrl_requested_ = true;
-}
-
-void ScoutBase::DisableLightCmdControl()
-{
-    std::lock_guard<std::mutex> guard(light_cmd_mutex_);
-    light_ctrl_enabled_ = false;
-    light_ctrl_requested_ = true;
-}
-
-void ScoutBase::ParseCANFrame(can_frame *rx_frame)
-{
-    // validate checksum, discard frame if fails
-    if (!rx_frame->data[7] == Agilex_CANMsgChecksum(rx_frame->can_id, rx_frame->data, rx_frame->can_dlc))
-    {
-        std::cerr << "ERROR: checksum mismatch, discard frame with id " << rx_frame->can_id << std::endl;
-        return;
-    }
-
-    // otherwise, update robot state with new frame
-    std::lock_guard<std::mutex> guard(scout_state_mutex_);
-    UpdateScoutState(scout_state_, rx_frame);
-}
-
-void ScoutBase::UpdateScoutState(ScoutState &state, can_frame *rx_frame)
-{
-    switch (rx_frame->can_id)
-    {
-    case MSG_MOTION_CONTROL_FEEDBACK_ID:
-    {
-        // std::cout << "motion control feedback received" << std::endl;
-        MotionStatusMessage msg;
-        std::memcpy(msg.data.raw, rx_frame->data, rx_frame->can_dlc * sizeof(uint8_t));
-        state.linear_velocity = static_cast<int16_t>(static_cast<uint16_t>(msg.data.status.linear_velocity.low_byte) | static_cast<uint16_t>(msg.data.status.linear_velocity.high_byte) << 8) / 1000.0;
-        state.angular_velocity = static_cast<int16_t>(static_cast<uint16_t>(msg.data.status.angular_velocity.low_byte) | static_cast<uint16_t>(msg.data.status.angular_velocity.high_byte) << 8) / 1000.0;
-        break;
-    }
-    case MSG_LIGHT_CONTROL_FEEDBACK_ID:
-    {
-        // std::cout << "light control feedback received" << std::endl;
-        LightStatusMessage msg;
-        std::memcpy(msg.data.raw, rx_frame->data, rx_frame->can_dlc * sizeof(uint8_t));
-        if (msg.data.status.light_ctrl_enable == DISABLE_LIGHT_CTRL)
-            state.light_control_enabled = false;
-        else
-            state.light_control_enabled = true;
-        state.front_light_state.mode = msg.data.status.front_light_mode;
-        state.front_light_state.custom_value = msg.data.status.front_light_custom;
-        state.rear_light_state.mode = msg.data.status.rear_light_mode;
-        state.rear_light_state.custom_value = msg.data.status.rear_light_custom;
-        break;
-    }
-    case MSG_SYSTEM_STATUS_FEEDBACK_ID:
-    {
-        // std::cout << "system status feedback received" << std::endl;
-        SystemStatusMessage msg;
-        std::memcpy(msg.data.raw, rx_frame->data, rx_frame->can_dlc * sizeof(uint8_t));
-        state.control_mode = msg.data.status.control_mode;
-        state.base_state = msg.data.status.base_state;
-        state.battery_voltage = (static_cast<uint16_t>(msg.data.status.battery_voltage.low_byte) | static_cast<uint16_t>(msg.data.status.battery_voltage.high_byte) << 8) / 10.0;
-        state.fault_code = (static_cast<uint16_t>(msg.data.status.fault_code.low_byte) | static_cast<uint16_t>(msg.data.status.fault_code.high_byte) << 8);
-        break;
-    }
-    case MSG_MOTOR1_DRIVER_FEEDBACK_ID:
-    {
-        // std::cout << "motor 1 driver feedback received" << std::endl;
-        Motor1DriverStatusMessage msg;
-        std::memcpy(msg.data.raw, rx_frame->data, rx_frame->can_dlc * sizeof(uint8_t));
-        state.motor_states[0].current = (static_cast<uint16_t>(msg.data.status.current.low_byte) | static_cast<uint16_t>(msg.data.status.current.high_byte) << 8) / 10.0;
-        state.motor_states[0].rpm = static_cast<int16_t>(static_cast<uint16_t>(msg.data.status.rpm.low_byte) | static_cast<uint16_t>(msg.data.status.rpm.high_byte) << 8);
-        ;
-        state.motor_states[0].temperature = msg.data.status.temperature;
-        break;
-    }
-    case MSG_MOTOR2_DRIVER_FEEDBACK_ID:
-    {
-        // std::cout << "motor 2 driver feedback received" << std::endl;
-        Motor2DriverStatusMessage msg;
-        std::memcpy(msg.data.raw, rx_frame->data, rx_frame->can_dlc * sizeof(uint8_t));
-        state.motor_states[1].current = (static_cast<uint16_t>(msg.data.status.current.low_byte) | static_cast<uint16_t>(msg.data.status.current.high_byte) << 8) / 10.0;
-        state.motor_states[1].rpm = static_cast<int16_t>(static_cast<uint16_t>(msg.data.status.rpm.low_byte) | static_cast<uint16_t>(msg.data.status.rpm.high_byte) << 8);
-        ;
-        state.motor_states[1].temperature = msg.data.status.temperature;
-        break;
-    }
-    case MSG_MOTOR3_DRIVER_FEEDBACK_ID:
-    {
-        // std::cout << "motor 3 driver feedback received" << std::endl;
-        Motor3DriverStatusMessage msg;
-        std::memcpy(msg.data.raw, rx_frame->data, rx_frame->can_dlc * sizeof(uint8_t));
-        state.motor_states[2].current = (static_cast<uint16_t>(msg.data.status.current.low_byte) | static_cast<uint16_t>(msg.data.status.current.high_byte) << 8) / 10.0;
-        state.motor_states[2].rpm = static_cast<int16_t>(static_cast<uint16_t>(msg.data.status.rpm.low_byte) | static_cast<uint16_t>(msg.data.status.rpm.high_byte) << 8);
-        ;
-        state.motor_states[2].temperature = msg.data.status.temperature;
-        break;
-    }
-    case MSG_MOTOR4_DRIVER_FEEDBACK_ID:
-    {
-        // std::cout << "motor 4 driver feedback received" << std::endl;
-        Motor4DriverStatusMessage msg;
-        std::memcpy(msg.data.raw, rx_frame->data, rx_frame->can_dlc * sizeof(uint8_t));
-        state.motor_states[3].current = (static_cast<uint16_t>(msg.data.status.current.low_byte) | static_cast<uint16_t>(msg.data.status.current.high_byte) << 8) / 10.0;
-        state.motor_states[3].rpm = static_cast<int16_t>(static_cast<uint16_t>(msg.data.status.rpm.low_byte) | static_cast<uint16_t>(msg.data.status.rpm.high_byte) << 8);
-        state.motor_states[3].temperature = msg.data.status.temperature;
-        break;
-    }
-    }
-}
-} // namespace wescore

scout_base/src/scout_sdk/src/sdk_core/scout_base/tests/CMakeLists.txt

@@ -1,9 +0,0 @@
-# Dependency libraries
-#find_package(LIBRARY_NAME REQUIRED)
-
-# tests
-add_executable(test_scout_base test_scout_base.cpp)
-target_link_libraries(test_scout_base scoutbase)
-
-add_executable(test_can_msg test_can_msg.cpp)
-target_link_libraries(test_can_msg scoutbase)

scout_base/src/scout_sdk/src/sdk_core/scout_base/tests/test_can_msg.cpp

@@ -1,37 +0,0 @@
-#include <iostream>
-
-#include "scout/scout_can_protocol.h"
-
-void print_msg(uint8_t data[8])
-{
-    for (int i = 0; i < 8; ++i)
-        std::cout << std::hex << static_cast<int>(data[i]) << " ";
-    std::cout << std::dec << std::endl;
-}
-
-int main()
-{
-    MotionControlMessage msg;
-    msg.data.cmd.control_mode = CMD_CAN_MODE;
-    msg.data.cmd.fault_clear_flag = NO_FAULT;
-    msg.data.cmd.linear_velocity_cmd = 10;
-    msg.data.cmd.angular_velocity_cmd = 0;
-    msg.data.cmd.reserved0 = 0;
-    msg.data.cmd.reserved1 = 0;
-    msg.data.cmd.count = 0;
-    msg.data.cmd.checksum = Agilex_CANMsgChecksum(msg.id, msg.data.raw, msg.dlc);
-    print_msg(msg.data.raw);
-
-    LightControlMessage msg2;
-    msg2.data.cmd.light_ctrl_enable = DISABLE_LIGHT_CTRL;
-    msg2.data.cmd.front_light_mode = CONST_ON;
-    msg2.data.cmd.front_light_custom = 0;
-    msg2.data.cmd.rear_light_mode = CONST_ON;
-    msg2.data.cmd.rear_light_custom = 0;
-    msg2.data.cmd.reserved0 = 0;
-    msg2.data.cmd.count = 0;
-    msg2.data.cmd.checksum = Agilex_CANMsgChecksum(msg2.id, msg2.data.raw, msg2.dlc);
-    print_msg(msg2.data.raw);
-
-    return 0;
-}