mirrors/scout_ros
1
0
Fork 0
mirror of https://github.com/westonrobot/scout_ros.git synced 2026-01-12 03:15:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

removed lcm stuff

Browse Source
This commit is contained in:
Ruixiang Du
2019-11-29 12:19:17 +08:00
parent bf4e47dafc
commit 16542b008f
27 changed files with 0 additions and 3969 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
scout_base/CMakeLists.txt
View File

@@ -20,8 +20,6 @@ find_package(catkin REQUIRED COMPONENTS
tf2_ros
)
# find_package(LCM REQUIRED)
# find_package(Boost REQUIRED COMPONENTS chrono)
###################################
@@ -44,7 +42,6 @@ catkin_package(
include_directories(
include
${catkin_INCLUDE_DIRS}
# ${LCM_INCLUDE_DIRS}
)
add_library(scout_messenger STATIC src/scout_messenger.cpp)
@@ -54,9 +51,6 @@ set_property(TARGET scout_messenger PROPERTY POSITION_INDEPENDENT_CODE ON)
add_executable(scout_base_node src/scout_base_node.cpp)
target_link_libraries(scout_base_node scout_messenger ${catkin_LIBRARIES})
# add_executable(imu_broadcast_node src/imu_broadcast_node.cpp)
# target_link_libraries(imu_broadcast_node ${catkin_LIBRARIES} ${LCM_LIBRARIES})
#############
## Install ##
#############
@@ -71,8 +65,5 @@ install(TARGETS scout_messenger scout_base_node
install(DIRECTORY include/${PROJECT_NAME}/
DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION})
# install(DIRECTORY include/lcmtypes
# DESTINATION ${CATKIN_GLOBAL_INCLUDE_DESTINATION})
install(DIRECTORY launch urdf
DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION})

17
scout_base/include/lcmtypes/wescore.h
View File

@@ -1,17 +0,0 @@
#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

17
scout_base/include/lcmtypes/wescore.hpp
View File

@@ -1,17 +0,0 @@
#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

215
scout_base/include/lcmtypes/wescore_lcm_msgs/IMU.hpp
View File

@@ -1,215 +0,0 @@
/** 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

224
scout_base/include/lcmtypes/wescore_lcm_msgs/NavSatFix.hpp
View File

@@ -1,224 +0,0 @@
/** 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

200
scout_base/include/lcmtypes/wescore_lcm_msgs/NavSatStatus.hpp
View File

@@ -1,200 +0,0 @@
/** 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

175
scout_base/include/lcmtypes/wescore_lcm_msgs/Quaternion.hpp
View File

@@ -1,175 +0,0 @@
/** 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

157
scout_base/include/lcmtypes/wescore_lcm_msgs/RawAccel.hpp
View File

@@ -1,157 +0,0 @@
/** 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

158
scout_base/include/lcmtypes/wescore_lcm_msgs/RawGyro.hpp
View File

@@ -1,158 +0,0 @@
/** 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

175
scout_base/include/lcmtypes/wescore_lcm_msgs/RawIMU10DOF.hpp
View File

@@ -1,175 +0,0 @@
/** 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

166
scout_base/include/lcmtypes/wescore_lcm_msgs/RawIMU6DOF.hpp
View File

@@ -1,166 +0,0 @@
/** 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

175
scout_base/include/lcmtypes/wescore_lcm_msgs/RawIMU9DOF.hpp
View File

@@ -1,175 +0,0 @@
/** 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

157
scout_base/include/lcmtypes/wescore_lcm_msgs/RawMag.hpp
View File

@@ -1,157 +0,0 @@
/** 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

157
scout_base/include/lcmtypes/wescore_lcm_msgs/Vector2.hpp
View File

@@ -1,157 +0,0 @@
/** 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

166
scout_base/include/lcmtypes/wescore_lcm_msgs/Vector3.hpp
View File

@@ -1,166 +0,0 @@
/** 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

155
scout_base/include/lcmtypes/wescore_lcm_msgs_IMU.h
View File

@@ -1,155 +0,0 @@
// 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

157
scout_base/include/lcmtypes/wescore_lcm_msgs_NavSatFix.h
View File

@@ -1,157 +0,0 @@
// 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

157
scout_base/include/lcmtypes/wescore_lcm_msgs_NavSatStatus.h
View File

@@ -1,157 +0,0 @@
// 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

149
scout_base/include/lcmtypes/wescore_lcm_msgs_Quaternion.h
View File

@@ -1,149 +0,0 @@
// 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

147
scout_base/include/lcmtypes/wescore_lcm_msgs_RawAccel.h
View File

@@ -1,147 +0,0 @@
// 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

148
scout_base/include/lcmtypes/wescore_lcm_msgs_RawGyro.h
View File

@@ -1,148 +0,0 @@
// 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

149
scout_base/include/lcmtypes/wescore_lcm_msgs_RawIMU10DOF.h
View File

@@ -1,149 +0,0 @@
// 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

148
scout_base/include/lcmtypes/wescore_lcm_msgs_RawIMU6DOF.h
View File

@@ -1,148 +0,0 @@
// 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

149
scout_base/include/lcmtypes/wescore_lcm_msgs_RawIMU9DOF.h
View File

@@ -1,149 +0,0 @@
// 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

147
scout_base/include/lcmtypes/wescore_lcm_msgs_RawMag.h
View File

@@ -1,147 +0,0 @@
// 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

147
scout_base/include/lcmtypes/wescore_lcm_msgs_Vector2.h
View File

@@ -1,147 +0,0 @@
// 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

148
scout_base/include/lcmtypes/wescore_lcm_msgs_Vector3.h
View File

@@ -1,148 +0,0 @@
// 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