updated package structure and more fixes

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;