file_path
stringlengths 21
224
| content
stringlengths 0
80.8M
|
|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/AddDiagnostics.h | #ifndef _ROS_SERVICE_AddDiagnostics_h
#define _ROS_SERVICE_AddDiagnostics_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace diagnostic_msgs
{
static const char ADDDIAGNOSTICS[] = "diagnostic_msgs/AddDiagnostics";
class AddDiagnosticsRequest : public ros::Msg
{
public:
typedef const char* _load_namespace_type;
_load_namespace_type load_namespace;
AddDiagnosticsRequest():
load_namespace("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_load_namespace = strlen(this->load_namespace);
varToArr(outbuffer + offset, length_load_namespace);
offset += 4;
memcpy(outbuffer + offset, this->load_namespace, length_load_namespace);
offset += length_load_namespace;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_load_namespace;
arrToVar(length_load_namespace, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_load_namespace; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_load_namespace-1]=0;
this->load_namespace = (char *)(inbuffer + offset-1);
offset += length_load_namespace;
return offset;
}
const char * getType(){ return ADDDIAGNOSTICS; };
const char * getMD5(){ return "c26cf6e164288fbc6050d74f838bcdf0"; };
};
class AddDiagnosticsResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _message_type;
_message_type message;
AddDiagnosticsResponse():
success(0),
message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
return offset;
}
const char * getType(){ return ADDDIAGNOSTICS; };
const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
};
class AddDiagnostics {
public:
typedef AddDiagnosticsRequest Request;
typedef AddDiagnosticsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/SelfTest.h | #ifndef _ROS_SERVICE_SelfTest_h
#define _ROS_SERVICE_SelfTest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "diagnostic_msgs/DiagnosticStatus.h"
namespace diagnostic_msgs
{
static const char SELFTEST[] = "diagnostic_msgs/SelfTest";
class SelfTestRequest : public ros::Msg
{
public:
SelfTestRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return SELFTEST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SelfTestResponse : public ros::Msg
{
public:
typedef const char* _id_type;
_id_type id;
typedef int8_t _passed_type;
_passed_type passed;
uint32_t status_length;
typedef diagnostic_msgs::DiagnosticStatus _status_type;
_status_type st_status;
_status_type * status;
SelfTestResponse():
id(""),
passed(0),
status_length(0), status(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
union {
int8_t real;
uint8_t base;
} u_passed;
u_passed.real = this->passed;
*(outbuffer + offset + 0) = (u_passed.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->passed);
*(outbuffer + offset + 0) = (this->status_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->status_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->status_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->status_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->status_length);
for( uint32_t i = 0; i < status_length; i++){
offset += this->status[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_id;
arrToVar(length_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_id-1]=0;
this->id = (char *)(inbuffer + offset-1);
offset += length_id;
union {
int8_t real;
uint8_t base;
} u_passed;
u_passed.base = 0;
u_passed.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->passed = u_passed.real;
offset += sizeof(this->passed);
uint32_t status_lengthT = ((uint32_t) (*(inbuffer + offset)));
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->status_length);
if(status_lengthT > status_length)
this->status = (diagnostic_msgs::DiagnosticStatus*)realloc(this->status, status_lengthT * sizeof(diagnostic_msgs::DiagnosticStatus));
status_length = status_lengthT;
for( uint32_t i = 0; i < status_length; i++){
offset += this->st_status.deserialize(inbuffer + offset);
memcpy( &(this->status[i]), &(this->st_status), sizeof(diagnostic_msgs::DiagnosticStatus));
}
return offset;
}
const char * getType(){ return SELFTEST; };
const char * getMD5(){ return "ac21b1bab7ab17546986536c22eb34e9"; };
};
class SelfTest {
public:
typedef SelfTestRequest Request;
typedef SelfTestResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/RequestMessageInfo.h | #ifndef _ROS_SERVICE_RequestMessageInfo_h
#define _ROS_SERVICE_RequestMessageInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
static const char REQUESTMESSAGEINFO[] = "rosserial_msgs/RequestMessageInfo";
class RequestMessageInfoRequest : public ros::Msg
{
public:
typedef const char* _type_type;
_type_type type;
RequestMessageInfoRequest():
type("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_type = strlen(this->type);
varToArr(outbuffer + offset, length_type);
offset += 4;
memcpy(outbuffer + offset, this->type, length_type);
offset += length_type;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_type;
arrToVar(length_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_type-1]=0;
this->type = (char *)(inbuffer + offset-1);
offset += length_type;
return offset;
}
const char * getType(){ return REQUESTMESSAGEINFO; };
const char * getMD5(){ return "dc67331de85cf97091b7d45e5c64ab75"; };
};
class RequestMessageInfoResponse : public ros::Msg
{
public:
typedef const char* _md5_type;
_md5_type md5;
typedef const char* _definition_type;
_definition_type definition;
RequestMessageInfoResponse():
md5(""),
definition("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_md5 = strlen(this->md5);
varToArr(outbuffer + offset, length_md5);
offset += 4;
memcpy(outbuffer + offset, this->md5, length_md5);
offset += length_md5;
uint32_t length_definition = strlen(this->definition);
varToArr(outbuffer + offset, length_definition);
offset += 4;
memcpy(outbuffer + offset, this->definition, length_definition);
offset += length_definition;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_md5;
arrToVar(length_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_md5-1]=0;
this->md5 = (char *)(inbuffer + offset-1);
offset += length_md5;
uint32_t length_definition;
arrToVar(length_definition, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_definition; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_definition-1]=0;
this->definition = (char *)(inbuffer + offset-1);
offset += length_definition;
return offset;
}
const char * getType(){ return REQUESTMESSAGEINFO; };
const char * getMD5(){ return "fe452186a069bed40f09b8628fe5eac8"; };
};
class RequestMessageInfo {
public:
typedef RequestMessageInfoRequest Request;
typedef RequestMessageInfoResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/TopicInfo.h | #ifndef _ROS_rosserial_msgs_TopicInfo_h
#define _ROS_rosserial_msgs_TopicInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
class TopicInfo : public ros::Msg
{
public:
typedef uint16_t _topic_id_type;
_topic_id_type topic_id;
typedef const char* _topic_name_type;
_topic_name_type topic_name;
typedef const char* _message_type_type;
_message_type_type message_type;
typedef const char* _md5sum_type;
_md5sum_type md5sum;
typedef int32_t _buffer_size_type;
_buffer_size_type buffer_size;
enum { ID_PUBLISHER = 0 };
enum { ID_SUBSCRIBER = 1 };
enum { ID_SERVICE_SERVER = 2 };
enum { ID_SERVICE_CLIENT = 4 };
enum { ID_PARAMETER_REQUEST = 6 };
enum { ID_LOG = 7 };
enum { ID_TIME = 10 };
enum { ID_TX_STOP = 11 };
TopicInfo():
topic_id(0),
topic_name(""),
message_type(""),
md5sum(""),
buffer_size(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->topic_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->topic_id >> (8 * 1)) & 0xFF;
offset += sizeof(this->topic_id);
uint32_t length_topic_name = strlen(this->topic_name);
varToArr(outbuffer + offset, length_topic_name);
offset += 4;
memcpy(outbuffer + offset, this->topic_name, length_topic_name);
offset += length_topic_name;
uint32_t length_message_type = strlen(this->message_type);
varToArr(outbuffer + offset, length_message_type);
offset += 4;
memcpy(outbuffer + offset, this->message_type, length_message_type);
offset += length_message_type;
uint32_t length_md5sum = strlen(this->md5sum);
varToArr(outbuffer + offset, length_md5sum);
offset += 4;
memcpy(outbuffer + offset, this->md5sum, length_md5sum);
offset += length_md5sum;
union {
int32_t real;
uint32_t base;
} u_buffer_size;
u_buffer_size.real = this->buffer_size;
*(outbuffer + offset + 0) = (u_buffer_size.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_buffer_size.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_buffer_size.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_buffer_size.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->buffer_size);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->topic_id = ((uint16_t) (*(inbuffer + offset)));
this->topic_id |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->topic_id);
uint32_t length_topic_name;
arrToVar(length_topic_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic_name-1]=0;
this->topic_name = (char *)(inbuffer + offset-1);
offset += length_topic_name;
uint32_t length_message_type;
arrToVar(length_message_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message_type-1]=0;
this->message_type = (char *)(inbuffer + offset-1);
offset += length_message_type;
uint32_t length_md5sum;
arrToVar(length_md5sum, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_md5sum; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_md5sum-1]=0;
this->md5sum = (char *)(inbuffer + offset-1);
offset += length_md5sum;
union {
int32_t real;
uint32_t base;
} u_buffer_size;
u_buffer_size.base = 0;
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->buffer_size = u_buffer_size.real;
offset += sizeof(this->buffer_size);
return offset;
}
const char * getType(){ return "rosserial_msgs/TopicInfo"; };
const char * getMD5(){ return "0ad51f88fc44892f8c10684077646005"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/RequestParam.h | #ifndef _ROS_SERVICE_RequestParam_h
#define _ROS_SERVICE_RequestParam_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
static const char REQUESTPARAM[] = "rosserial_msgs/RequestParam";
class RequestParamRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
RequestParamRequest():
name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
return offset;
}
const char * getType(){ return REQUESTPARAM; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class RequestParamResponse : public ros::Msg
{
public:
uint32_t ints_length;
typedef int32_t _ints_type;
_ints_type st_ints;
_ints_type * ints;
uint32_t floats_length;
typedef float _floats_type;
_floats_type st_floats;
_floats_type * floats;
uint32_t strings_length;
typedef char* _strings_type;
_strings_type st_strings;
_strings_type * strings;
RequestParamResponse():
ints_length(0), ints(NULL),
floats_length(0), floats(NULL),
strings_length(0), strings(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->ints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ints_length);
for( uint32_t i = 0; i < ints_length; i++){
union {
int32_t real;
uint32_t base;
} u_intsi;
u_intsi.real = this->ints[i];
*(outbuffer + offset + 0) = (u_intsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_intsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_intsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_intsi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->ints[i]);
}
*(outbuffer + offset + 0) = (this->floats_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->floats_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->floats_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->floats_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->floats_length);
for( uint32_t i = 0; i < floats_length; i++){
union {
float real;
uint32_t base;
} u_floatsi;
u_floatsi.real = this->floats[i];
*(outbuffer + offset + 0) = (u_floatsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_floatsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_floatsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_floatsi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->floats[i]);
}
*(outbuffer + offset + 0) = (this->strings_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->strings_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->strings_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->strings_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->strings_length);
for( uint32_t i = 0; i < strings_length; i++){
uint32_t length_stringsi = strlen(this->strings[i]);
varToArr(outbuffer + offset, length_stringsi);
offset += 4;
memcpy(outbuffer + offset, this->strings[i], length_stringsi);
offset += length_stringsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t ints_lengthT = ((uint32_t) (*(inbuffer + offset)));
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ints_length);
if(ints_lengthT > ints_length)
this->ints = (int32_t*)realloc(this->ints, ints_lengthT * sizeof(int32_t));
ints_length = ints_lengthT;
for( uint32_t i = 0; i < ints_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_ints;
u_st_ints.base = 0;
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_ints = u_st_ints.real;
offset += sizeof(this->st_ints);
memcpy( &(this->ints[i]), &(this->st_ints), sizeof(int32_t));
}
uint32_t floats_lengthT = ((uint32_t) (*(inbuffer + offset)));
floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->floats_length);
if(floats_lengthT > floats_length)
this->floats = (float*)realloc(this->floats, floats_lengthT * sizeof(float));
floats_length = floats_lengthT;
for( uint32_t i = 0; i < floats_length; i++){
union {
float real;
uint32_t base;
} u_st_floats;
u_st_floats.base = 0;
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_floats = u_st_floats.real;
offset += sizeof(this->st_floats);
memcpy( &(this->floats[i]), &(this->st_floats), sizeof(float));
}
uint32_t strings_lengthT = ((uint32_t) (*(inbuffer + offset)));
strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->strings_length);
if(strings_lengthT > strings_length)
this->strings = (char**)realloc(this->strings, strings_lengthT * sizeof(char*));
strings_length = strings_lengthT;
for( uint32_t i = 0; i < strings_length; i++){
uint32_t length_st_strings;
arrToVar(length_st_strings, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_strings; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_strings-1]=0;
this->st_strings = (char *)(inbuffer + offset-1);
offset += length_st_strings;
memcpy( &(this->strings[i]), &(this->st_strings), sizeof(char*));
}
return offset;
}
const char * getType(){ return REQUESTPARAM; };
const char * getMD5(){ return "9f0e98bda65981986ddf53afa7a40e49"; };
};
class RequestParam {
public:
typedef RequestParamRequest Request;
typedef RequestParamResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/Log.h | #ifndef _ROS_rosserial_msgs_Log_h
#define _ROS_rosserial_msgs_Log_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
class Log : public ros::Msg
{
public:
typedef uint8_t _level_type;
_level_type level;
typedef const char* _msg_type;
_msg_type msg;
enum { ROSDEBUG = 0 };
enum { INFO = 1 };
enum { WARN = 2 };
enum { ERROR = 3 };
enum { FATAL = 4 };
Log():
level(0),
msg("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->level >> (8 * 0)) & 0xFF;
offset += sizeof(this->level);
uint32_t length_msg = strlen(this->msg);
varToArr(outbuffer + offset, length_msg);
offset += 4;
memcpy(outbuffer + offset, this->msg, length_msg);
offset += length_msg;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->level = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->level);
uint32_t length_msg;
arrToVar(length_msg, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_msg; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_msg-1]=0;
this->msg = (char *)(inbuffer + offset-1);
offset += length_msg;
return offset;
}
const char * getType(){ return "rosserial_msgs/Log"; };
const char * getMD5(){ return "11abd731c25933261cd6183bd12d6295"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/RequestServiceInfo.h | #ifndef _ROS_SERVICE_RequestServiceInfo_h
#define _ROS_SERVICE_RequestServiceInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
static const char REQUESTSERVICEINFO[] = "rosserial_msgs/RequestServiceInfo";
class RequestServiceInfoRequest : public ros::Msg
{
public:
typedef const char* _service_type;
_service_type service;
RequestServiceInfoRequest():
service("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_service = strlen(this->service);
varToArr(outbuffer + offset, length_service);
offset += 4;
memcpy(outbuffer + offset, this->service, length_service);
offset += length_service;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_service;
arrToVar(length_service, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_service; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_service-1]=0;
this->service = (char *)(inbuffer + offset-1);
offset += length_service;
return offset;
}
const char * getType(){ return REQUESTSERVICEINFO; };
const char * getMD5(){ return "1cbcfa13b08f6d36710b9af8741e6112"; };
};
class RequestServiceInfoResponse : public ros::Msg
{
public:
typedef const char* _service_md5_type;
_service_md5_type service_md5;
typedef const char* _request_md5_type;
_request_md5_type request_md5;
typedef const char* _response_md5_type;
_response_md5_type response_md5;
RequestServiceInfoResponse():
service_md5(""),
request_md5(""),
response_md5("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_service_md5 = strlen(this->service_md5);
varToArr(outbuffer + offset, length_service_md5);
offset += 4;
memcpy(outbuffer + offset, this->service_md5, length_service_md5);
offset += length_service_md5;
uint32_t length_request_md5 = strlen(this->request_md5);
varToArr(outbuffer + offset, length_request_md5);
offset += 4;
memcpy(outbuffer + offset, this->request_md5, length_request_md5);
offset += length_request_md5;
uint32_t length_response_md5 = strlen(this->response_md5);
varToArr(outbuffer + offset, length_response_md5);
offset += 4;
memcpy(outbuffer + offset, this->response_md5, length_response_md5);
offset += length_response_md5;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_service_md5;
arrToVar(length_service_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_service_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_service_md5-1]=0;
this->service_md5 = (char *)(inbuffer + offset-1);
offset += length_service_md5;
uint32_t length_request_md5;
arrToVar(length_request_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_request_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_request_md5-1]=0;
this->request_md5 = (char *)(inbuffer + offset-1);
offset += length_request_md5;
uint32_t length_response_md5;
arrToVar(length_response_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_response_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_response_md5-1]=0;
this->response_md5 = (char *)(inbuffer + offset-1);
offset += length_response_md5;
return offset;
}
const char * getType(){ return REQUESTSERVICEINFO; };
const char * getMD5(){ return "c3d6dd25b909596479fbbc6559fa6874"; };
};
class RequestServiceInfo {
public:
typedef RequestServiceInfoRequest Request;
typedef RequestServiceInfoResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisGoal_h
#define _ROS_flexbe_msgs_BehaviorSynthesisGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/SynthesisRequest.h"
namespace flexbe_msgs
{
class BehaviorSynthesisGoal : public ros::Msg
{
public:
typedef flexbe_msgs::SynthesisRequest _request_type;
_request_type request;
BehaviorSynthesisGoal():
request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisGoal"; };
const char * getMD5(){ return "64ccf8fdad6091a950ca099bc67e6595"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputActionResult.h | #ifndef _ROS_flexbe_msgs_BehaviorInputActionResult_h
#define _ROS_flexbe_msgs_BehaviorInputActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "flexbe_msgs/BehaviorInputResult.h"
namespace flexbe_msgs
{
class BehaviorInputActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorInputResult _result_type;
_result_type result;
BehaviorInputActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputActionResult"; };
const char * getMD5(){ return "fbfb06b1b74139caf57e6c1834fe58bc"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisFeedback_h
#define _ROS_flexbe_msgs_BehaviorSynthesisFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorSynthesisFeedback : public ros::Msg
{
public:
typedef const char* _status_type;
_status_type status;
typedef float _progress_type;
_progress_type progress;
BehaviorSynthesisFeedback():
status(""),
progress(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_status = strlen(this->status);
varToArr(outbuffer + offset, length_status);
offset += 4;
memcpy(outbuffer + offset, this->status, length_status);
offset += length_status;
union {
float real;
uint32_t base;
} u_progress;
u_progress.real = this->progress;
*(outbuffer + offset + 0) = (u_progress.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_progress.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_progress.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_progress.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->progress);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_status;
arrToVar(length_status, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status-1]=0;
this->status = (char *)(inbuffer + offset-1);
offset += length_status;
union {
float real;
uint32_t base;
} u_progress;
u_progress.base = 0;
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->progress = u_progress.real;
offset += sizeof(this->progress);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisFeedback"; };
const char * getMD5(){ return "ce404b6cabcba81b67a4c8bac81c05d3"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputActionFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorInputActionFeedback_h
#define _ROS_flexbe_msgs_BehaviorInputActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "flexbe_msgs/BehaviorInputFeedback.h"
namespace flexbe_msgs
{
class BehaviorInputActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorInputFeedback _feedback_type;
_feedback_type feedback;
BehaviorInputActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionGoal_h
#define _ROS_flexbe_msgs_BehaviorExecutionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorExecutionGoal : public ros::Msg
{
public:
typedef const char* _behavior_name_type;
_behavior_name_type behavior_name;
uint32_t arg_keys_length;
typedef char* _arg_keys_type;
_arg_keys_type st_arg_keys;
_arg_keys_type * arg_keys;
uint32_t arg_values_length;
typedef char* _arg_values_type;
_arg_values_type st_arg_values;
_arg_values_type * arg_values;
uint32_t input_keys_length;
typedef char* _input_keys_type;
_input_keys_type st_input_keys;
_input_keys_type * input_keys;
uint32_t input_values_length;
typedef char* _input_values_type;
_input_values_type st_input_values;
_input_values_type * input_values;
BehaviorExecutionGoal():
behavior_name(""),
arg_keys_length(0), arg_keys(NULL),
arg_values_length(0), arg_values(NULL),
input_keys_length(0), input_keys(NULL),
input_values_length(0), input_values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_behavior_name = strlen(this->behavior_name);
varToArr(outbuffer + offset, length_behavior_name);
offset += 4;
memcpy(outbuffer + offset, this->behavior_name, length_behavior_name);
offset += length_behavior_name;
*(outbuffer + offset + 0) = (this->arg_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_keys_length);
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_arg_keysi = strlen(this->arg_keys[i]);
varToArr(outbuffer + offset, length_arg_keysi);
offset += 4;
memcpy(outbuffer + offset, this->arg_keys[i], length_arg_keysi);
offset += length_arg_keysi;
}
*(outbuffer + offset + 0) = (this->arg_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_values_length);
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_arg_valuesi = strlen(this->arg_values[i]);
varToArr(outbuffer + offset, length_arg_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->arg_values[i], length_arg_valuesi);
offset += length_arg_valuesi;
}
*(outbuffer + offset + 0) = (this->input_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_keys_length);
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_input_keysi = strlen(this->input_keys[i]);
varToArr(outbuffer + offset, length_input_keysi);
offset += 4;
memcpy(outbuffer + offset, this->input_keys[i], length_input_keysi);
offset += length_input_keysi;
}
*(outbuffer + offset + 0) = (this->input_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_values_length);
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_input_valuesi = strlen(this->input_values[i]);
varToArr(outbuffer + offset, length_input_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->input_values[i], length_input_valuesi);
offset += length_input_valuesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_behavior_name;
arrToVar(length_behavior_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_behavior_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_behavior_name-1]=0;
this->behavior_name = (char *)(inbuffer + offset-1);
offset += length_behavior_name;
uint32_t arg_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_keys_length);
if(arg_keys_lengthT > arg_keys_length)
this->arg_keys = (char**)realloc(this->arg_keys, arg_keys_lengthT * sizeof(char*));
arg_keys_length = arg_keys_lengthT;
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_st_arg_keys;
arrToVar(length_st_arg_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_keys-1]=0;
this->st_arg_keys = (char *)(inbuffer + offset-1);
offset += length_st_arg_keys;
memcpy( &(this->arg_keys[i]), &(this->st_arg_keys), sizeof(char*));
}
uint32_t arg_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_values_length);
if(arg_values_lengthT > arg_values_length)
this->arg_values = (char**)realloc(this->arg_values, arg_values_lengthT * sizeof(char*));
arg_values_length = arg_values_lengthT;
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_st_arg_values;
arrToVar(length_st_arg_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_values-1]=0;
this->st_arg_values = (char *)(inbuffer + offset-1);
offset += length_st_arg_values;
memcpy( &(this->arg_values[i]), &(this->st_arg_values), sizeof(char*));
}
uint32_t input_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_keys_length);
if(input_keys_lengthT > input_keys_length)
this->input_keys = (char**)realloc(this->input_keys, input_keys_lengthT * sizeof(char*));
input_keys_length = input_keys_lengthT;
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_st_input_keys;
arrToVar(length_st_input_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_keys-1]=0;
this->st_input_keys = (char *)(inbuffer + offset-1);
offset += length_st_input_keys;
memcpy( &(this->input_keys[i]), &(this->st_input_keys), sizeof(char*));
}
uint32_t input_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_values_length);
if(input_values_lengthT > input_values_length)
this->input_values = (char**)realloc(this->input_values, input_values_lengthT * sizeof(char*));
input_values_length = input_values_lengthT;
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_st_input_values;
arrToVar(length_st_input_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_values-1]=0;
this->st_input_values = (char *)(inbuffer + offset-1);
offset += length_st_input_values;
memcpy( &(this->input_values[i]), &(this->st_input_values), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionGoal"; };
const char * getMD5(){ return "448c2298fe3c13b6fd73cfc07e865a14"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/SynthesisRequest.h | #ifndef _ROS_flexbe_msgs_SynthesisRequest_h
#define _ROS_flexbe_msgs_SynthesisRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class SynthesisRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _system_type;
_system_type system;
typedef const char* _goal_type;
_goal_type goal;
typedef const char* _initial_condition_type;
_initial_condition_type initial_condition;
uint32_t sm_outcomes_length;
typedef char* _sm_outcomes_type;
_sm_outcomes_type st_sm_outcomes;
_sm_outcomes_type * sm_outcomes;
SynthesisRequest():
name(""),
system(""),
goal(""),
initial_condition(""),
sm_outcomes_length(0), sm_outcomes(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_system = strlen(this->system);
varToArr(outbuffer + offset, length_system);
offset += 4;
memcpy(outbuffer + offset, this->system, length_system);
offset += length_system;
uint32_t length_goal = strlen(this->goal);
varToArr(outbuffer + offset, length_goal);
offset += 4;
memcpy(outbuffer + offset, this->goal, length_goal);
offset += length_goal;
uint32_t length_initial_condition = strlen(this->initial_condition);
varToArr(outbuffer + offset, length_initial_condition);
offset += 4;
memcpy(outbuffer + offset, this->initial_condition, length_initial_condition);
offset += length_initial_condition;
*(outbuffer + offset + 0) = (this->sm_outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sm_outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sm_outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sm_outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->sm_outcomes_length);
for( uint32_t i = 0; i < sm_outcomes_length; i++){
uint32_t length_sm_outcomesi = strlen(this->sm_outcomes[i]);
varToArr(outbuffer + offset, length_sm_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->sm_outcomes[i], length_sm_outcomesi);
offset += length_sm_outcomesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_system;
arrToVar(length_system, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_system; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_system-1]=0;
this->system = (char *)(inbuffer + offset-1);
offset += length_system;
uint32_t length_goal;
arrToVar(length_goal, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_goal; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_goal-1]=0;
this->goal = (char *)(inbuffer + offset-1);
offset += length_goal;
uint32_t length_initial_condition;
arrToVar(length_initial_condition, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_initial_condition; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_initial_condition-1]=0;
this->initial_condition = (char *)(inbuffer + offset-1);
offset += length_initial_condition;
uint32_t sm_outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
sm_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
sm_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
sm_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sm_outcomes_length);
if(sm_outcomes_lengthT > sm_outcomes_length)
this->sm_outcomes = (char**)realloc(this->sm_outcomes, sm_outcomes_lengthT * sizeof(char*));
sm_outcomes_length = sm_outcomes_lengthT;
for( uint32_t i = 0; i < sm_outcomes_length; i++){
uint32_t length_st_sm_outcomes;
arrToVar(length_st_sm_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_sm_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_sm_outcomes-1]=0;
this->st_sm_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_sm_outcomes;
memcpy( &(this->sm_outcomes[i]), &(this->st_sm_outcomes), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/SynthesisRequest"; };
const char * getMD5(){ return "99257dbfe8a196d006a75837dcabf3f6"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/SynthesisErrorCodes.h | #ifndef _ROS_flexbe_msgs_SynthesisErrorCodes_h
#define _ROS_flexbe_msgs_SynthesisErrorCodes_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class SynthesisErrorCodes : public ros::Msg
{
public:
typedef int32_t _value_type;
_value_type value;
enum { SUCCESS = 1 };
SynthesisErrorCodes():
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "flexbe_msgs/SynthesisErrorCodes"; };
const char * getMD5(){ return "64e05da1f86a12ce44b1cca74395bd4e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorInputGoal_h
#define _ROS_flexbe_msgs_BehaviorInputGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorInputGoal : public ros::Msg
{
public:
typedef uint8_t _request_type_type;
_request_type_type request_type;
typedef const char* _msg_type;
_msg_type msg;
BehaviorInputGoal():
request_type(0),
msg("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->request_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->request_type);
uint32_t length_msg = strlen(this->msg);
varToArr(outbuffer + offset, length_msg);
offset += 4;
memcpy(outbuffer + offset, this->msg, length_msg);
offset += length_msg;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->request_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->request_type);
uint32_t length_msg;
arrToVar(length_msg, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_msg; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_msg-1]=0;
this->msg = (char *)(inbuffer + offset-1);
offset += length_msg;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputGoal"; };
const char * getMD5(){ return "724150348fd57a5ebc07765871d3f316"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorModification.h | #ifndef _ROS_flexbe_msgs_BehaviorModification_h
#define _ROS_flexbe_msgs_BehaviorModification_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorModification : public ros::Msg
{
public:
typedef int32_t _index_begin_type;
_index_begin_type index_begin;
typedef int32_t _index_end_type;
_index_end_type index_end;
typedef const char* _new_content_type;
_new_content_type new_content;
BehaviorModification():
index_begin(0),
index_end(0),
new_content("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_index_begin;
u_index_begin.real = this->index_begin;
*(outbuffer + offset + 0) = (u_index_begin.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_index_begin.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_index_begin.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_index_begin.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->index_begin);
union {
int32_t real;
uint32_t base;
} u_index_end;
u_index_end.real = this->index_end;
*(outbuffer + offset + 0) = (u_index_end.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_index_end.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_index_end.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_index_end.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->index_end);
uint32_t length_new_content = strlen(this->new_content);
varToArr(outbuffer + offset, length_new_content);
offset += 4;
memcpy(outbuffer + offset, this->new_content, length_new_content);
offset += length_new_content;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_index_begin;
u_index_begin.base = 0;
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->index_begin = u_index_begin.real;
offset += sizeof(this->index_begin);
union {
int32_t real;
uint32_t base;
} u_index_end;
u_index_end.base = 0;
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->index_end = u_index_end.real;
offset += sizeof(this->index_end);
uint32_t length_new_content;
arrToVar(length_new_content, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_new_content; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_new_content-1]=0;
this->new_content = (char *)(inbuffer + offset-1);
offset += length_new_content;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorModification"; };
const char * getMD5(){ return "ac997193d826b145a432b8e3e528f6b4"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisActionGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisActionGoal_h
#define _ROS_flexbe_msgs_BehaviorSynthesisActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "flexbe_msgs/BehaviorSynthesisGoal.h"
namespace flexbe_msgs
{
class BehaviorSynthesisActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef flexbe_msgs::BehaviorSynthesisGoal _goal_type;
_goal_type goal;
BehaviorSynthesisActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisActionGoal"; };
const char * getMD5(){ return "ef3bccd0f7dc68c4fe76a2cb791126b0"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionActionFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionActionFeedback_h
#define _ROS_flexbe_msgs_BehaviorExecutionActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "flexbe_msgs/BehaviorExecutionFeedback.h"
namespace flexbe_msgs
{
class BehaviorExecutionActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorExecutionFeedback _feedback_type;
_feedback_type feedback;
BehaviorExecutionActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionActionFeedback"; };
const char * getMD5(){ return "b767b030e0462dae1168f66f2dd64853"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/StateInstantiation.h | #ifndef _ROS_flexbe_msgs_StateInstantiation_h
#define _ROS_flexbe_msgs_StateInstantiation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/OutcomeCondition.h"
namespace flexbe_msgs
{
class StateInstantiation : public ros::Msg
{
public:
typedef const char* _state_path_type;
_state_path_type state_path;
typedef const char* _state_class_type;
_state_class_type state_class;
typedef const char* _initial_state_name_type;
_initial_state_name_type initial_state_name;
uint32_t input_keys_length;
typedef char* _input_keys_type;
_input_keys_type st_input_keys;
_input_keys_type * input_keys;
uint32_t output_keys_length;
typedef char* _output_keys_type;
_output_keys_type st_output_keys;
_output_keys_type * output_keys;
uint32_t cond_outcome_length;
typedef char* _cond_outcome_type;
_cond_outcome_type st_cond_outcome;
_cond_outcome_type * cond_outcome;
uint32_t cond_transition_length;
typedef flexbe_msgs::OutcomeCondition _cond_transition_type;
_cond_transition_type st_cond_transition;
_cond_transition_type * cond_transition;
typedef const char* _behavior_class_type;
_behavior_class_type behavior_class;
uint32_t parameter_names_length;
typedef char* _parameter_names_type;
_parameter_names_type st_parameter_names;
_parameter_names_type * parameter_names;
uint32_t parameter_values_length;
typedef char* _parameter_values_type;
_parameter_values_type st_parameter_values;
_parameter_values_type * parameter_values;
float position[2];
uint32_t outcomes_length;
typedef char* _outcomes_type;
_outcomes_type st_outcomes;
_outcomes_type * outcomes;
uint32_t transitions_length;
typedef char* _transitions_type;
_transitions_type st_transitions;
_transitions_type * transitions;
uint32_t autonomy_length;
typedef int8_t _autonomy_type;
_autonomy_type st_autonomy;
_autonomy_type * autonomy;
uint32_t userdata_keys_length;
typedef char* _userdata_keys_type;
_userdata_keys_type st_userdata_keys;
_userdata_keys_type * userdata_keys;
uint32_t userdata_remapping_length;
typedef char* _userdata_remapping_type;
_userdata_remapping_type st_userdata_remapping;
_userdata_remapping_type * userdata_remapping;
enum { CLASS_STATEMACHINE = :STATEMACHINE };
enum { CLASS_CONCURRENCY = :CONCURRENCY };
enum { CLASS_PRIORITY = :PRIORITY };
enum { CLASS_BEHAVIOR = :BEHAVIOR };
StateInstantiation():
state_path(""),
state_class(""),
initial_state_name(""),
input_keys_length(0), input_keys(NULL),
output_keys_length(0), output_keys(NULL),
cond_outcome_length(0), cond_outcome(NULL),
cond_transition_length(0), cond_transition(NULL),
behavior_class(""),
parameter_names_length(0), parameter_names(NULL),
parameter_values_length(0), parameter_values(NULL),
position(),
outcomes_length(0), outcomes(NULL),
transitions_length(0), transitions(NULL),
autonomy_length(0), autonomy(NULL),
userdata_keys_length(0), userdata_keys(NULL),
userdata_remapping_length(0), userdata_remapping(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state_path = strlen(this->state_path);
varToArr(outbuffer + offset, length_state_path);
offset += 4;
memcpy(outbuffer + offset, this->state_path, length_state_path);
offset += length_state_path;
uint32_t length_state_class = strlen(this->state_class);
varToArr(outbuffer + offset, length_state_class);
offset += 4;
memcpy(outbuffer + offset, this->state_class, length_state_class);
offset += length_state_class;
uint32_t length_initial_state_name = strlen(this->initial_state_name);
varToArr(outbuffer + offset, length_initial_state_name);
offset += 4;
memcpy(outbuffer + offset, this->initial_state_name, length_initial_state_name);
offset += length_initial_state_name;
*(outbuffer + offset + 0) = (this->input_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_keys_length);
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_input_keysi = strlen(this->input_keys[i]);
varToArr(outbuffer + offset, length_input_keysi);
offset += 4;
memcpy(outbuffer + offset, this->input_keys[i], length_input_keysi);
offset += length_input_keysi;
}
*(outbuffer + offset + 0) = (this->output_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->output_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->output_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->output_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->output_keys_length);
for( uint32_t i = 0; i < output_keys_length; i++){
uint32_t length_output_keysi = strlen(this->output_keys[i]);
varToArr(outbuffer + offset, length_output_keysi);
offset += 4;
memcpy(outbuffer + offset, this->output_keys[i], length_output_keysi);
offset += length_output_keysi;
}
*(outbuffer + offset + 0) = (this->cond_outcome_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cond_outcome_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cond_outcome_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cond_outcome_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cond_outcome_length);
for( uint32_t i = 0; i < cond_outcome_length; i++){
uint32_t length_cond_outcomei = strlen(this->cond_outcome[i]);
varToArr(outbuffer + offset, length_cond_outcomei);
offset += 4;
memcpy(outbuffer + offset, this->cond_outcome[i], length_cond_outcomei);
offset += length_cond_outcomei;
}
*(outbuffer + offset + 0) = (this->cond_transition_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cond_transition_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cond_transition_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cond_transition_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cond_transition_length);
for( uint32_t i = 0; i < cond_transition_length; i++){
offset += this->cond_transition[i].serialize(outbuffer + offset);
}
uint32_t length_behavior_class = strlen(this->behavior_class);
varToArr(outbuffer + offset, length_behavior_class);
offset += 4;
memcpy(outbuffer + offset, this->behavior_class, length_behavior_class);
offset += length_behavior_class;
*(outbuffer + offset + 0) = (this->parameter_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parameter_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parameter_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parameter_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->parameter_names_length);
for( uint32_t i = 0; i < parameter_names_length; i++){
uint32_t length_parameter_namesi = strlen(this->parameter_names[i]);
varToArr(outbuffer + offset, length_parameter_namesi);
offset += 4;
memcpy(outbuffer + offset, this->parameter_names[i], length_parameter_namesi);
offset += length_parameter_namesi;
}
*(outbuffer + offset + 0) = (this->parameter_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parameter_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parameter_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parameter_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->parameter_values_length);
for( uint32_t i = 0; i < parameter_values_length; i++){
uint32_t length_parameter_valuesi = strlen(this->parameter_values[i]);
varToArr(outbuffer + offset, length_parameter_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->parameter_values[i], length_parameter_valuesi);
offset += length_parameter_valuesi;
}
for( uint32_t i = 0; i < 2; i++){
union {
float real;
uint32_t base;
} u_positioni;
u_positioni.real = this->position[i];
*(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->position[i]);
}
*(outbuffer + offset + 0) = (this->outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_length);
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_outcomesi = strlen(this->outcomes[i]);
varToArr(outbuffer + offset, length_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes[i], length_outcomesi);
offset += length_outcomesi;
}
*(outbuffer + offset + 0) = (this->transitions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transitions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transitions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transitions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transitions_length);
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_transitionsi = strlen(this->transitions[i]);
varToArr(outbuffer + offset, length_transitionsi);
offset += 4;
memcpy(outbuffer + offset, this->transitions[i], length_transitionsi);
offset += length_transitionsi;
}
*(outbuffer + offset + 0) = (this->autonomy_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->autonomy_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->autonomy_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->autonomy_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->autonomy_length);
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_autonomyi;
u_autonomyi.real = this->autonomy[i];
*(outbuffer + offset + 0) = (u_autonomyi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy[i]);
}
*(outbuffer + offset + 0) = (this->userdata_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->userdata_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->userdata_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->userdata_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->userdata_keys_length);
for( uint32_t i = 0; i < userdata_keys_length; i++){
uint32_t length_userdata_keysi = strlen(this->userdata_keys[i]);
varToArr(outbuffer + offset, length_userdata_keysi);
offset += 4;
memcpy(outbuffer + offset, this->userdata_keys[i], length_userdata_keysi);
offset += length_userdata_keysi;
}
*(outbuffer + offset + 0) = (this->userdata_remapping_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->userdata_remapping_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->userdata_remapping_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->userdata_remapping_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->userdata_remapping_length);
for( uint32_t i = 0; i < userdata_remapping_length; i++){
uint32_t length_userdata_remappingi = strlen(this->userdata_remapping[i]);
varToArr(outbuffer + offset, length_userdata_remappingi);
offset += 4;
memcpy(outbuffer + offset, this->userdata_remapping[i], length_userdata_remappingi);
offset += length_userdata_remappingi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state_path;
arrToVar(length_state_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state_path-1]=0;
this->state_path = (char *)(inbuffer + offset-1);
offset += length_state_path;
uint32_t length_state_class;
arrToVar(length_state_class, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state_class; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state_class-1]=0;
this->state_class = (char *)(inbuffer + offset-1);
offset += length_state_class;
uint32_t length_initial_state_name;
arrToVar(length_initial_state_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_initial_state_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_initial_state_name-1]=0;
this->initial_state_name = (char *)(inbuffer + offset-1);
offset += length_initial_state_name;
uint32_t input_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_keys_length);
if(input_keys_lengthT > input_keys_length)
this->input_keys = (char**)realloc(this->input_keys, input_keys_lengthT * sizeof(char*));
input_keys_length = input_keys_lengthT;
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_st_input_keys;
arrToVar(length_st_input_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_keys-1]=0;
this->st_input_keys = (char *)(inbuffer + offset-1);
offset += length_st_input_keys;
memcpy( &(this->input_keys[i]), &(this->st_input_keys), sizeof(char*));
}
uint32_t output_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
output_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
output_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
output_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->output_keys_length);
if(output_keys_lengthT > output_keys_length)
this->output_keys = (char**)realloc(this->output_keys, output_keys_lengthT * sizeof(char*));
output_keys_length = output_keys_lengthT;
for( uint32_t i = 0; i < output_keys_length; i++){
uint32_t length_st_output_keys;
arrToVar(length_st_output_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_output_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_output_keys-1]=0;
this->st_output_keys = (char *)(inbuffer + offset-1);
offset += length_st_output_keys;
memcpy( &(this->output_keys[i]), &(this->st_output_keys), sizeof(char*));
}
uint32_t cond_outcome_lengthT = ((uint32_t) (*(inbuffer + offset)));
cond_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cond_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cond_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cond_outcome_length);
if(cond_outcome_lengthT > cond_outcome_length)
this->cond_outcome = (char**)realloc(this->cond_outcome, cond_outcome_lengthT * sizeof(char*));
cond_outcome_length = cond_outcome_lengthT;
for( uint32_t i = 0; i < cond_outcome_length; i++){
uint32_t length_st_cond_outcome;
arrToVar(length_st_cond_outcome, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_cond_outcome; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_cond_outcome-1]=0;
this->st_cond_outcome = (char *)(inbuffer + offset-1);
offset += length_st_cond_outcome;
memcpy( &(this->cond_outcome[i]), &(this->st_cond_outcome), sizeof(char*));
}
uint32_t cond_transition_lengthT = ((uint32_t) (*(inbuffer + offset)));
cond_transition_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cond_transition_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cond_transition_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cond_transition_length);
if(cond_transition_lengthT > cond_transition_length)
this->cond_transition = (flexbe_msgs::OutcomeCondition*)realloc(this->cond_transition, cond_transition_lengthT * sizeof(flexbe_msgs::OutcomeCondition));
cond_transition_length = cond_transition_lengthT;
for( uint32_t i = 0; i < cond_transition_length; i++){
offset += this->st_cond_transition.deserialize(inbuffer + offset);
memcpy( &(this->cond_transition[i]), &(this->st_cond_transition), sizeof(flexbe_msgs::OutcomeCondition));
}
uint32_t length_behavior_class;
arrToVar(length_behavior_class, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_behavior_class; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_behavior_class-1]=0;
this->behavior_class = (char *)(inbuffer + offset-1);
offset += length_behavior_class;
uint32_t parameter_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
parameter_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
parameter_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
parameter_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parameter_names_length);
if(parameter_names_lengthT > parameter_names_length)
this->parameter_names = (char**)realloc(this->parameter_names, parameter_names_lengthT * sizeof(char*));
parameter_names_length = parameter_names_lengthT;
for( uint32_t i = 0; i < parameter_names_length; i++){
uint32_t length_st_parameter_names;
arrToVar(length_st_parameter_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_parameter_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_parameter_names-1]=0;
this->st_parameter_names = (char *)(inbuffer + offset-1);
offset += length_st_parameter_names;
memcpy( &(this->parameter_names[i]), &(this->st_parameter_names), sizeof(char*));
}
uint32_t parameter_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
parameter_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
parameter_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
parameter_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parameter_values_length);
if(parameter_values_lengthT > parameter_values_length)
this->parameter_values = (char**)realloc(this->parameter_values, parameter_values_lengthT * sizeof(char*));
parameter_values_length = parameter_values_lengthT;
for( uint32_t i = 0; i < parameter_values_length; i++){
uint32_t length_st_parameter_values;
arrToVar(length_st_parameter_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_parameter_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_parameter_values-1]=0;
this->st_parameter_values = (char *)(inbuffer + offset-1);
offset += length_st_parameter_values;
memcpy( &(this->parameter_values[i]), &(this->st_parameter_values), sizeof(char*));
}
for( uint32_t i = 0; i < 2; i++){
union {
float real;
uint32_t base;
} u_positioni;
u_positioni.base = 0;
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->position[i] = u_positioni.real;
offset += sizeof(this->position[i]);
}
uint32_t outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_length);
if(outcomes_lengthT > outcomes_length)
this->outcomes = (char**)realloc(this->outcomes, outcomes_lengthT * sizeof(char*));
outcomes_length = outcomes_lengthT;
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_st_outcomes;
arrToVar(length_st_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes-1]=0;
this->st_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_outcomes;
memcpy( &(this->outcomes[i]), &(this->st_outcomes), sizeof(char*));
}
uint32_t transitions_lengthT = ((uint32_t) (*(inbuffer + offset)));
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transitions_length);
if(transitions_lengthT > transitions_length)
this->transitions = (char**)realloc(this->transitions, transitions_lengthT * sizeof(char*));
transitions_length = transitions_lengthT;
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_st_transitions;
arrToVar(length_st_transitions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_transitions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_transitions-1]=0;
this->st_transitions = (char *)(inbuffer + offset-1);
offset += length_st_transitions;
memcpy( &(this->transitions[i]), &(this->st_transitions), sizeof(char*));
}
uint32_t autonomy_lengthT = ((uint32_t) (*(inbuffer + offset)));
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->autonomy_length);
if(autonomy_lengthT > autonomy_length)
this->autonomy = (int8_t*)realloc(this->autonomy, autonomy_lengthT * sizeof(int8_t));
autonomy_length = autonomy_lengthT;
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_autonomy;
u_st_autonomy.base = 0;
u_st_autonomy.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_autonomy = u_st_autonomy.real;
offset += sizeof(this->st_autonomy);
memcpy( &(this->autonomy[i]), &(this->st_autonomy), sizeof(int8_t));
}
uint32_t userdata_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
userdata_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
userdata_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
userdata_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->userdata_keys_length);
if(userdata_keys_lengthT > userdata_keys_length)
this->userdata_keys = (char**)realloc(this->userdata_keys, userdata_keys_lengthT * sizeof(char*));
userdata_keys_length = userdata_keys_lengthT;
for( uint32_t i = 0; i < userdata_keys_length; i++){
uint32_t length_st_userdata_keys;
arrToVar(length_st_userdata_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_userdata_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_userdata_keys-1]=0;
this->st_userdata_keys = (char *)(inbuffer + offset-1);
offset += length_st_userdata_keys;
memcpy( &(this->userdata_keys[i]), &(this->st_userdata_keys), sizeof(char*));
}
uint32_t userdata_remapping_lengthT = ((uint32_t) (*(inbuffer + offset)));
userdata_remapping_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
userdata_remapping_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
userdata_remapping_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->userdata_remapping_length);
if(userdata_remapping_lengthT > userdata_remapping_length)
this->userdata_remapping = (char**)realloc(this->userdata_remapping, userdata_remapping_lengthT * sizeof(char*));
userdata_remapping_length = userdata_remapping_lengthT;
for( uint32_t i = 0; i < userdata_remapping_length; i++){
uint32_t length_st_userdata_remapping;
arrToVar(length_st_userdata_remapping, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_userdata_remapping; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_userdata_remapping-1]=0;
this->st_userdata_remapping = (char *)(inbuffer + offset-1);
offset += length_st_userdata_remapping;
memcpy( &(this->userdata_remapping[i]), &(this->st_userdata_remapping), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/StateInstantiation"; };
const char * getMD5(){ return "1c6026e288cfff7ab6c8308ee1db66f1"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputResult.h | #ifndef _ROS_flexbe_msgs_BehaviorInputResult_h
#define _ROS_flexbe_msgs_BehaviorInputResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorInputResult : public ros::Msg
{
public:
typedef uint8_t _result_code_type;
_result_code_type result_code;
typedef const char* _data_type;
_data_type data;
enum { RESULT_OK = 0 };
enum { RESULT_FAILED = 1 };
enum { RESULT_ABORTED = 2 };
BehaviorInputResult():
result_code(0),
data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->result_code >> (8 * 0)) & 0xFF;
offset += sizeof(this->result_code);
uint32_t length_data = strlen(this->data);
varToArr(outbuffer + offset, length_data);
offset += 4;
memcpy(outbuffer + offset, this->data, length_data);
offset += length_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->result_code = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->result_code);
uint32_t length_data;
arrToVar(length_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_data-1]=0;
this->data = (char *)(inbuffer + offset-1);
offset += length_data;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputResult"; };
const char * getMD5(){ return "e0509f159e7c7bb2268efbc625f63b3f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisActionResult.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisActionResult_h
#define _ROS_flexbe_msgs_BehaviorSynthesisActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "flexbe_msgs/BehaviorSynthesisResult.h"
namespace flexbe_msgs
{
class BehaviorSynthesisActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorSynthesisResult _result_type;
_result_type result;
BehaviorSynthesisActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisActionResult"; };
const char * getMD5(){ return "d13a1c24e611f3c8aae59d09829d044b"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionFeedback_h
#define _ROS_flexbe_msgs_BehaviorExecutionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorExecutionFeedback : public ros::Msg
{
public:
typedef const char* _current_state_type;
_current_state_type current_state;
BehaviorExecutionFeedback():
current_state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_current_state = strlen(this->current_state);
varToArr(outbuffer + offset, length_current_state);
offset += 4;
memcpy(outbuffer + offset, this->current_state, length_current_state);
offset += length_current_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_current_state;
arrToVar(length_current_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_current_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_current_state-1]=0;
this->current_state = (char *)(inbuffer + offset-1);
offset += length_current_state;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionFeedback"; };
const char * getMD5(){ return "6b3c1b68b57cc9263bf79fc4ad6ec8c7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/Container.h | #ifndef _ROS_flexbe_msgs_Container_h
#define _ROS_flexbe_msgs_Container_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class Container : public ros::Msg
{
public:
typedef const char* _path_type;
_path_type path;
uint32_t children_length;
typedef char* _children_type;
_children_type st_children;
_children_type * children;
uint32_t outcomes_length;
typedef char* _outcomes_type;
_outcomes_type st_outcomes;
_outcomes_type * outcomes;
uint32_t transitions_length;
typedef char* _transitions_type;
_transitions_type st_transitions;
_transitions_type * transitions;
uint32_t autonomy_length;
typedef int8_t _autonomy_type;
_autonomy_type st_autonomy;
_autonomy_type * autonomy;
Container():
path(""),
children_length(0), children(NULL),
outcomes_length(0), outcomes(NULL),
transitions_length(0), transitions(NULL),
autonomy_length(0), autonomy(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_path = strlen(this->path);
varToArr(outbuffer + offset, length_path);
offset += 4;
memcpy(outbuffer + offset, this->path, length_path);
offset += length_path;
*(outbuffer + offset + 0) = (this->children_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->children_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->children_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->children_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->children_length);
for( uint32_t i = 0; i < children_length; i++){
uint32_t length_childreni = strlen(this->children[i]);
varToArr(outbuffer + offset, length_childreni);
offset += 4;
memcpy(outbuffer + offset, this->children[i], length_childreni);
offset += length_childreni;
}
*(outbuffer + offset + 0) = (this->outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_length);
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_outcomesi = strlen(this->outcomes[i]);
varToArr(outbuffer + offset, length_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes[i], length_outcomesi);
offset += length_outcomesi;
}
*(outbuffer + offset + 0) = (this->transitions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transitions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transitions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transitions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transitions_length);
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_transitionsi = strlen(this->transitions[i]);
varToArr(outbuffer + offset, length_transitionsi);
offset += 4;
memcpy(outbuffer + offset, this->transitions[i], length_transitionsi);
offset += length_transitionsi;
}
*(outbuffer + offset + 0) = (this->autonomy_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->autonomy_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->autonomy_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->autonomy_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->autonomy_length);
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_autonomyi;
u_autonomyi.real = this->autonomy[i];
*(outbuffer + offset + 0) = (u_autonomyi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_path;
arrToVar(length_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_path-1]=0;
this->path = (char *)(inbuffer + offset-1);
offset += length_path;
uint32_t children_lengthT = ((uint32_t) (*(inbuffer + offset)));
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->children_length);
if(children_lengthT > children_length)
this->children = (char**)realloc(this->children, children_lengthT * sizeof(char*));
children_length = children_lengthT;
for( uint32_t i = 0; i < children_length; i++){
uint32_t length_st_children;
arrToVar(length_st_children, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_children; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_children-1]=0;
this->st_children = (char *)(inbuffer + offset-1);
offset += length_st_children;
memcpy( &(this->children[i]), &(this->st_children), sizeof(char*));
}
uint32_t outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_length);
if(outcomes_lengthT > outcomes_length)
this->outcomes = (char**)realloc(this->outcomes, outcomes_lengthT * sizeof(char*));
outcomes_length = outcomes_lengthT;
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_st_outcomes;
arrToVar(length_st_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes-1]=0;
this->st_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_outcomes;
memcpy( &(this->outcomes[i]), &(this->st_outcomes), sizeof(char*));
}
uint32_t transitions_lengthT = ((uint32_t) (*(inbuffer + offset)));
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transitions_length);
if(transitions_lengthT > transitions_length)
this->transitions = (char**)realloc(this->transitions, transitions_lengthT * sizeof(char*));
transitions_length = transitions_lengthT;
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_st_transitions;
arrToVar(length_st_transitions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_transitions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_transitions-1]=0;
this->st_transitions = (char *)(inbuffer + offset-1);
offset += length_st_transitions;
memcpy( &(this->transitions[i]), &(this->st_transitions), sizeof(char*));
}
uint32_t autonomy_lengthT = ((uint32_t) (*(inbuffer + offset)));
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->autonomy_length);
if(autonomy_lengthT > autonomy_length)
this->autonomy = (int8_t*)realloc(this->autonomy, autonomy_lengthT * sizeof(int8_t));
autonomy_length = autonomy_lengthT;
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_autonomy;
u_st_autonomy.base = 0;
u_st_autonomy.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_autonomy = u_st_autonomy.real;
offset += sizeof(this->st_autonomy);
memcpy( &(this->autonomy[i]), &(this->st_autonomy), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/Container"; };
const char * getMD5(){ return "627eacc0f462c8ee83d7105e17cf4119"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/OutcomeRequest.h | #ifndef _ROS_flexbe_msgs_OutcomeRequest_h
#define _ROS_flexbe_msgs_OutcomeRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class OutcomeRequest : public ros::Msg
{
public:
typedef uint8_t _outcome_type;
_outcome_type outcome;
typedef const char* _target_type;
_target_type target;
OutcomeRequest():
outcome(0),
target("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->outcome >> (8 * 0)) & 0xFF;
offset += sizeof(this->outcome);
uint32_t length_target = strlen(this->target);
varToArr(outbuffer + offset, length_target);
offset += 4;
memcpy(outbuffer + offset, this->target, length_target);
offset += length_target;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->outcome = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->outcome);
uint32_t length_target;
arrToVar(length_target, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_target; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_target-1]=0;
this->target = (char *)(inbuffer + offset-1);
offset += length_target;
return offset;
}
const char * getType(){ return "flexbe_msgs/OutcomeRequest"; };
const char * getMD5(){ return "b057cf075cb943bf0dbb3443419a61ed"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorRequest.h | #ifndef _ROS_flexbe_msgs_BehaviorRequest_h
#define _ROS_flexbe_msgs_BehaviorRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/Container.h"
namespace flexbe_msgs
{
class BehaviorRequest : public ros::Msg
{
public:
typedef const char* _behavior_name_type;
_behavior_name_type behavior_name;
typedef uint8_t _autonomy_level_type;
_autonomy_level_type autonomy_level;
uint32_t arg_keys_length;
typedef char* _arg_keys_type;
_arg_keys_type st_arg_keys;
_arg_keys_type * arg_keys;
uint32_t arg_values_length;
typedef char* _arg_values_type;
_arg_values_type st_arg_values;
_arg_values_type * arg_values;
uint32_t structure_length;
typedef flexbe_msgs::Container _structure_type;
_structure_type st_structure;
_structure_type * structure;
BehaviorRequest():
behavior_name(""),
autonomy_level(0),
arg_keys_length(0), arg_keys(NULL),
arg_values_length(0), arg_values(NULL),
structure_length(0), structure(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_behavior_name = strlen(this->behavior_name);
varToArr(outbuffer + offset, length_behavior_name);
offset += 4;
memcpy(outbuffer + offset, this->behavior_name, length_behavior_name);
offset += length_behavior_name;
*(outbuffer + offset + 0) = (this->autonomy_level >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy_level);
*(outbuffer + offset + 0) = (this->arg_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_keys_length);
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_arg_keysi = strlen(this->arg_keys[i]);
varToArr(outbuffer + offset, length_arg_keysi);
offset += 4;
memcpy(outbuffer + offset, this->arg_keys[i], length_arg_keysi);
offset += length_arg_keysi;
}
*(outbuffer + offset + 0) = (this->arg_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_values_length);
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_arg_valuesi = strlen(this->arg_values[i]);
varToArr(outbuffer + offset, length_arg_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->arg_values[i], length_arg_valuesi);
offset += length_arg_valuesi;
}
*(outbuffer + offset + 0) = (this->structure_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->structure_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->structure_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->structure_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->structure_length);
for( uint32_t i = 0; i < structure_length; i++){
offset += this->structure[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_behavior_name;
arrToVar(length_behavior_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_behavior_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_behavior_name-1]=0;
this->behavior_name = (char *)(inbuffer + offset-1);
offset += length_behavior_name;
this->autonomy_level = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->autonomy_level);
uint32_t arg_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_keys_length);
if(arg_keys_lengthT > arg_keys_length)
this->arg_keys = (char**)realloc(this->arg_keys, arg_keys_lengthT * sizeof(char*));
arg_keys_length = arg_keys_lengthT;
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_st_arg_keys;
arrToVar(length_st_arg_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_keys-1]=0;
this->st_arg_keys = (char *)(inbuffer + offset-1);
offset += length_st_arg_keys;
memcpy( &(this->arg_keys[i]), &(this->st_arg_keys), sizeof(char*));
}
uint32_t arg_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_values_length);
if(arg_values_lengthT > arg_values_length)
this->arg_values = (char**)realloc(this->arg_values, arg_values_lengthT * sizeof(char*));
arg_values_length = arg_values_lengthT;
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_st_arg_values;
arrToVar(length_st_arg_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_values-1]=0;
this->st_arg_values = (char *)(inbuffer + offset-1);
offset += length_st_arg_values;
memcpy( &(this->arg_values[i]), &(this->st_arg_values), sizeof(char*));
}
uint32_t structure_lengthT = ((uint32_t) (*(inbuffer + offset)));
structure_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
structure_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
structure_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->structure_length);
if(structure_lengthT > structure_length)
this->structure = (flexbe_msgs::Container*)realloc(this->structure, structure_lengthT * sizeof(flexbe_msgs::Container));
structure_length = structure_lengthT;
for( uint32_t i = 0; i < structure_length; i++){
offset += this->st_structure.deserialize(inbuffer + offset);
memcpy( &(this->structure[i]), &(this->st_structure), sizeof(flexbe_msgs::Container));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorRequest"; };
const char * getMD5(){ return "0b55949502d4c602376ee00a64d0d294"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionResult.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionResult_h
#define _ROS_flexbe_msgs_BehaviorExecutionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorExecutionResult : public ros::Msg
{
public:
typedef const char* _outcome_type;
_outcome_type outcome;
BehaviorExecutionResult():
outcome("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_outcome = strlen(this->outcome);
varToArr(outbuffer + offset, length_outcome);
offset += 4;
memcpy(outbuffer + offset, this->outcome, length_outcome);
offset += length_outcome;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_outcome;
arrToVar(length_outcome, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_outcome; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_outcome-1]=0;
this->outcome = (char *)(inbuffer + offset-1);
offset += length_outcome;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionResult"; };
const char * getMD5(){ return "2b95071cca675b3d5b80ad0bdaf20389"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionActionGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionActionGoal_h
#define _ROS_flexbe_msgs_BehaviorExecutionActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "flexbe_msgs/BehaviorExecutionGoal.h"
namespace flexbe_msgs
{
class BehaviorExecutionActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef flexbe_msgs::BehaviorExecutionGoal _goal_type;
_goal_type goal;
BehaviorExecutionActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionActionGoal"; };
const char * getMD5(){ return "60d736806adccc368a03e4e8d2e6f4e7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisResult.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisResult_h
#define _ROS_flexbe_msgs_BehaviorSynthesisResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/SynthesisErrorCodes.h"
#include "flexbe_msgs/StateInstantiation.h"
namespace flexbe_msgs
{
class BehaviorSynthesisResult : public ros::Msg
{
public:
typedef flexbe_msgs::SynthesisErrorCodes _error_code_type;
_error_code_type error_code;
uint32_t states_length;
typedef flexbe_msgs::StateInstantiation _states_type;
_states_type st_states;
_states_type * states;
BehaviorSynthesisResult():
error_code(),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (flexbe_msgs::StateInstantiation*)realloc(this->states, states_lengthT * sizeof(flexbe_msgs::StateInstantiation));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(flexbe_msgs::StateInstantiation));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisResult"; };
const char * getMD5(){ return "088bd6aee1c7ee2902db2babfd6af1c2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/ContainerStructure.h | #ifndef _ROS_flexbe_msgs_ContainerStructure_h
#define _ROS_flexbe_msgs_ContainerStructure_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/Container.h"
namespace flexbe_msgs
{
class ContainerStructure : public ros::Msg
{
public:
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
uint32_t containers_length;
typedef flexbe_msgs::Container _containers_type;
_containers_type st_containers;
_containers_type * containers;
ContainerStructure():
behavior_id(0),
containers_length(0), containers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
*(outbuffer + offset + 0) = (this->containers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->containers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->containers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->containers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->containers_length);
for( uint32_t i = 0; i < containers_length; i++){
offset += this->containers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
uint32_t containers_lengthT = ((uint32_t) (*(inbuffer + offset)));
containers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
containers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
containers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->containers_length);
if(containers_lengthT > containers_length)
this->containers = (flexbe_msgs::Container*)realloc(this->containers, containers_lengthT * sizeof(flexbe_msgs::Container));
containers_length = containers_lengthT;
for( uint32_t i = 0; i < containers_length; i++){
offset += this->st_containers.deserialize(inbuffer + offset);
memcpy( &(this->containers[i]), &(this->st_containers), sizeof(flexbe_msgs::Container));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/ContainerStructure"; };
const char * getMD5(){ return "9cd26d15621063b90279d87117694328"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputAction.h | #ifndef _ROS_flexbe_msgs_BehaviorInputAction_h
#define _ROS_flexbe_msgs_BehaviorInputAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorInputActionGoal.h"
#include "flexbe_msgs/BehaviorInputActionResult.h"
#include "flexbe_msgs/BehaviorInputActionFeedback.h"
namespace flexbe_msgs
{
class BehaviorInputAction : public ros::Msg
{
public:
typedef flexbe_msgs::BehaviorInputActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef flexbe_msgs::BehaviorInputActionResult _action_result_type;
_action_result_type action_result;
typedef flexbe_msgs::BehaviorInputActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
BehaviorInputAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputAction"; };
const char * getMD5(){ return "409aeef36c5fba868c3b1f845c52f119"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionAction.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionAction_h
#define _ROS_flexbe_msgs_BehaviorExecutionAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorExecutionActionGoal.h"
#include "flexbe_msgs/BehaviorExecutionActionResult.h"
#include "flexbe_msgs/BehaviorExecutionActionFeedback.h"
namespace flexbe_msgs
{
class BehaviorExecutionAction : public ros::Msg
{
public:
typedef flexbe_msgs::BehaviorExecutionActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef flexbe_msgs::BehaviorExecutionActionResult _action_result_type;
_action_result_type action_result;
typedef flexbe_msgs::BehaviorExecutionActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
BehaviorExecutionAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionAction"; };
const char * getMD5(){ return "5137e5877c4ee9dbe6ca4796ad090f1a"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/UICommand.h | #ifndef _ROS_flexbe_msgs_UICommand_h
#define _ROS_flexbe_msgs_UICommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class UICommand : public ros::Msg
{
public:
typedef const char* _command_type;
_command_type command;
typedef const char* _key_type;
_key_type key;
UICommand():
command(""),
key("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_command = strlen(this->command);
varToArr(outbuffer + offset, length_command);
offset += 4;
memcpy(outbuffer + offset, this->command, length_command);
offset += length_command;
uint32_t length_key = strlen(this->key);
varToArr(outbuffer + offset, length_key);
offset += 4;
memcpy(outbuffer + offset, this->key, length_key);
offset += length_key;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_command;
arrToVar(length_command, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_command; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_command-1]=0;
this->command = (char *)(inbuffer + offset-1);
offset += length_command;
uint32_t length_key;
arrToVar(length_key, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_key; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_key-1]=0;
this->key = (char *)(inbuffer + offset-1);
offset += length_key;
return offset;
}
const char * getType(){ return "flexbe_msgs/UICommand"; };
const char * getMD5(){ return "88f45469138737816fa9cd59fbf3c084"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSync.h | #ifndef _ROS_flexbe_msgs_BehaviorSync_h
#define _ROS_flexbe_msgs_BehaviorSync_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorSync : public ros::Msg
{
public:
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
typedef int32_t _current_state_checksum_type;
_current_state_checksum_type current_state_checksum;
BehaviorSync():
behavior_id(0),
current_state_checksum(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_current_state_checksum;
u_current_state_checksum.real = this->current_state_checksum;
*(outbuffer + offset + 0) = (u_current_state_checksum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_current_state_checksum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_current_state_checksum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_current_state_checksum.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->current_state_checksum);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_current_state_checksum;
u_current_state_checksum.base = 0;
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->current_state_checksum = u_current_state_checksum.real;
offset += sizeof(this->current_state_checksum);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSync"; };
const char * getMD5(){ return "118d64f48696509906c4cf4a228608b1"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorLog.h | #ifndef _ROS_flexbe_msgs_BehaviorLog_h
#define _ROS_flexbe_msgs_BehaviorLog_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorLog : public ros::Msg
{
public:
typedef const char* _text_type;
_text_type text;
typedef uint8_t _status_code_type;
_status_code_type status_code;
enum { INFO = 0 };
enum { WARN = 1 };
enum { HINT = 2 };
enum { ERROR = 3 };
enum { DEBUG = 10 };
BehaviorLog():
text(""),
status_code(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_text = strlen(this->text);
varToArr(outbuffer + offset, length_text);
offset += 4;
memcpy(outbuffer + offset, this->text, length_text);
offset += length_text;
*(outbuffer + offset + 0) = (this->status_code >> (8 * 0)) & 0xFF;
offset += sizeof(this->status_code);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_text;
arrToVar(length_text, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_text; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_text-1]=0;
this->text = (char *)(inbuffer + offset-1);
offset += length_text;
this->status_code = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->status_code);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorLog"; };
const char * getMD5(){ return "03d7689372c7e2617b8d61fbf552e694"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/OutcomeCondition.h | #ifndef _ROS_flexbe_msgs_OutcomeCondition_h
#define _ROS_flexbe_msgs_OutcomeCondition_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class OutcomeCondition : public ros::Msg
{
public:
uint32_t state_name_length;
typedef char* _state_name_type;
_state_name_type st_state_name;
_state_name_type * state_name;
uint32_t state_outcome_length;
typedef char* _state_outcome_type;
_state_outcome_type st_state_outcome;
_state_outcome_type * state_outcome;
OutcomeCondition():
state_name_length(0), state_name(NULL),
state_outcome_length(0), state_outcome(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->state_name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->state_name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->state_name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->state_name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->state_name_length);
for( uint32_t i = 0; i < state_name_length; i++){
uint32_t length_state_namei = strlen(this->state_name[i]);
varToArr(outbuffer + offset, length_state_namei);
offset += 4;
memcpy(outbuffer + offset, this->state_name[i], length_state_namei);
offset += length_state_namei;
}
*(outbuffer + offset + 0) = (this->state_outcome_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->state_outcome_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->state_outcome_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->state_outcome_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->state_outcome_length);
for( uint32_t i = 0; i < state_outcome_length; i++){
uint32_t length_state_outcomei = strlen(this->state_outcome[i]);
varToArr(outbuffer + offset, length_state_outcomei);
offset += 4;
memcpy(outbuffer + offset, this->state_outcome[i], length_state_outcomei);
offset += length_state_outcomei;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t state_name_lengthT = ((uint32_t) (*(inbuffer + offset)));
state_name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
state_name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
state_name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->state_name_length);
if(state_name_lengthT > state_name_length)
this->state_name = (char**)realloc(this->state_name, state_name_lengthT * sizeof(char*));
state_name_length = state_name_lengthT;
for( uint32_t i = 0; i < state_name_length; i++){
uint32_t length_st_state_name;
arrToVar(length_st_state_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_state_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_state_name-1]=0;
this->st_state_name = (char *)(inbuffer + offset-1);
offset += length_st_state_name;
memcpy( &(this->state_name[i]), &(this->st_state_name), sizeof(char*));
}
uint32_t state_outcome_lengthT = ((uint32_t) (*(inbuffer + offset)));
state_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
state_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
state_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->state_outcome_length);
if(state_outcome_lengthT > state_outcome_length)
this->state_outcome = (char**)realloc(this->state_outcome, state_outcome_lengthT * sizeof(char*));
state_outcome_length = state_outcome_lengthT;
for( uint32_t i = 0; i < state_outcome_length; i++){
uint32_t length_st_state_outcome;
arrToVar(length_st_state_outcome, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_state_outcome; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_state_outcome-1]=0;
this->st_state_outcome = (char *)(inbuffer + offset-1);
offset += length_st_state_outcome;
memcpy( &(this->state_outcome[i]), &(this->st_state_outcome), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/OutcomeCondition"; };
const char * getMD5(){ return "3f00d7f2d34167712ca29ef288547863"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputActionGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorInputActionGoal_h
#define _ROS_flexbe_msgs_BehaviorInputActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "flexbe_msgs/BehaviorInputGoal.h"
namespace flexbe_msgs
{
class BehaviorInputActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef flexbe_msgs::BehaviorInputGoal _goal_type;
_goal_type goal;
BehaviorInputActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputActionGoal"; };
const char * getMD5(){ return "b2de1aae6b5512cca522fa05361cfdab"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionActionResult.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionActionResult_h
#define _ROS_flexbe_msgs_BehaviorExecutionActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "flexbe_msgs/BehaviorExecutionResult.h"
namespace flexbe_msgs
{
class BehaviorExecutionActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorExecutionResult _result_type;
_result_type result;
BehaviorExecutionActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionActionResult"; };
const char * getMD5(){ return "76e505f84da88685989704705a0d9846"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisActionFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisActionFeedback_h
#define _ROS_flexbe_msgs_BehaviorSynthesisActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "flexbe_msgs/BehaviorSynthesisFeedback.h"
namespace flexbe_msgs
{
class BehaviorSynthesisActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorSynthesisFeedback _feedback_type;
_feedback_type feedback;
BehaviorSynthesisActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisActionFeedback"; };
const char * getMD5(){ return "74b2c8a9bddfff7e1b57abd9d9fb5b18"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSelection.h | #ifndef _ROS_flexbe_msgs_BehaviorSelection_h
#define _ROS_flexbe_msgs_BehaviorSelection_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorModification.h"
namespace flexbe_msgs
{
class BehaviorSelection : public ros::Msg
{
public:
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
typedef int32_t _behavior_checksum_type;
_behavior_checksum_type behavior_checksum;
typedef uint8_t _autonomy_level_type;
_autonomy_level_type autonomy_level;
uint32_t arg_keys_length;
typedef char* _arg_keys_type;
_arg_keys_type st_arg_keys;
_arg_keys_type * arg_keys;
uint32_t arg_values_length;
typedef char* _arg_values_type;
_arg_values_type st_arg_values;
_arg_values_type * arg_values;
uint32_t input_keys_length;
typedef char* _input_keys_type;
_input_keys_type st_input_keys;
_input_keys_type * input_keys;
uint32_t input_values_length;
typedef char* _input_values_type;
_input_values_type st_input_values;
_input_values_type * input_values;
uint32_t modifications_length;
typedef flexbe_msgs::BehaviorModification _modifications_type;
_modifications_type st_modifications;
_modifications_type * modifications;
BehaviorSelection():
behavior_id(0),
behavior_checksum(0),
autonomy_level(0),
arg_keys_length(0), arg_keys(NULL),
arg_values_length(0), arg_values(NULL),
input_keys_length(0), input_keys(NULL),
input_values_length(0), input_values(NULL),
modifications_length(0), modifications(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_behavior_checksum;
u_behavior_checksum.real = this->behavior_checksum;
*(outbuffer + offset + 0) = (u_behavior_checksum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_checksum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_checksum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_checksum.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_checksum);
*(outbuffer + offset + 0) = (this->autonomy_level >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy_level);
*(outbuffer + offset + 0) = (this->arg_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_keys_length);
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_arg_keysi = strlen(this->arg_keys[i]);
varToArr(outbuffer + offset, length_arg_keysi);
offset += 4;
memcpy(outbuffer + offset, this->arg_keys[i], length_arg_keysi);
offset += length_arg_keysi;
}
*(outbuffer + offset + 0) = (this->arg_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_values_length);
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_arg_valuesi = strlen(this->arg_values[i]);
varToArr(outbuffer + offset, length_arg_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->arg_values[i], length_arg_valuesi);
offset += length_arg_valuesi;
}
*(outbuffer + offset + 0) = (this->input_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_keys_length);
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_input_keysi = strlen(this->input_keys[i]);
varToArr(outbuffer + offset, length_input_keysi);
offset += 4;
memcpy(outbuffer + offset, this->input_keys[i], length_input_keysi);
offset += length_input_keysi;
}
*(outbuffer + offset + 0) = (this->input_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_values_length);
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_input_valuesi = strlen(this->input_values[i]);
varToArr(outbuffer + offset, length_input_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->input_values[i], length_input_valuesi);
offset += length_input_valuesi;
}
*(outbuffer + offset + 0) = (this->modifications_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->modifications_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->modifications_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->modifications_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->modifications_length);
for( uint32_t i = 0; i < modifications_length; i++){
offset += this->modifications[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_behavior_checksum;
u_behavior_checksum.base = 0;
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_checksum = u_behavior_checksum.real;
offset += sizeof(this->behavior_checksum);
this->autonomy_level = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->autonomy_level);
uint32_t arg_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_keys_length);
if(arg_keys_lengthT > arg_keys_length)
this->arg_keys = (char**)realloc(this->arg_keys, arg_keys_lengthT * sizeof(char*));
arg_keys_length = arg_keys_lengthT;
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_st_arg_keys;
arrToVar(length_st_arg_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_keys-1]=0;
this->st_arg_keys = (char *)(inbuffer + offset-1);
offset += length_st_arg_keys;
memcpy( &(this->arg_keys[i]), &(this->st_arg_keys), sizeof(char*));
}
uint32_t arg_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_values_length);
if(arg_values_lengthT > arg_values_length)
this->arg_values = (char**)realloc(this->arg_values, arg_values_lengthT * sizeof(char*));
arg_values_length = arg_values_lengthT;
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_st_arg_values;
arrToVar(length_st_arg_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_values-1]=0;
this->st_arg_values = (char *)(inbuffer + offset-1);
offset += length_st_arg_values;
memcpy( &(this->arg_values[i]), &(this->st_arg_values), sizeof(char*));
}
uint32_t input_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_keys_length);
if(input_keys_lengthT > input_keys_length)
this->input_keys = (char**)realloc(this->input_keys, input_keys_lengthT * sizeof(char*));
input_keys_length = input_keys_lengthT;
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_st_input_keys;
arrToVar(length_st_input_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_keys-1]=0;
this->st_input_keys = (char *)(inbuffer + offset-1);
offset += length_st_input_keys;
memcpy( &(this->input_keys[i]), &(this->st_input_keys), sizeof(char*));
}
uint32_t input_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_values_length);
if(input_values_lengthT > input_values_length)
this->input_values = (char**)realloc(this->input_values, input_values_lengthT * sizeof(char*));
input_values_length = input_values_lengthT;
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_st_input_values;
arrToVar(length_st_input_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_values-1]=0;
this->st_input_values = (char *)(inbuffer + offset-1);
offset += length_st_input_values;
memcpy( &(this->input_values[i]), &(this->st_input_values), sizeof(char*));
}
uint32_t modifications_lengthT = ((uint32_t) (*(inbuffer + offset)));
modifications_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
modifications_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
modifications_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->modifications_length);
if(modifications_lengthT > modifications_length)
this->modifications = (flexbe_msgs::BehaviorModification*)realloc(this->modifications, modifications_lengthT * sizeof(flexbe_msgs::BehaviorModification));
modifications_length = modifications_lengthT;
for( uint32_t i = 0; i < modifications_length; i++){
offset += this->st_modifications.deserialize(inbuffer + offset);
memcpy( &(this->modifications[i]), &(this->st_modifications), sizeof(flexbe_msgs::BehaviorModification));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSelection"; };
const char * getMD5(){ return "514f1b101295bdbd417ee6cc46e3823c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BEStatus.h | #ifndef _ROS_flexbe_msgs_BEStatus_h
#define _ROS_flexbe_msgs_BEStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace flexbe_msgs
{
class BEStatus : public ros::Msg
{
public:
typedef ros::Time _stamp_type;
_stamp_type stamp;
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
typedef uint8_t _code_type;
_code_type code;
uint32_t args_length;
typedef char* _args_type;
_args_type st_args;
_args_type * args;
enum { STARTED = 0 };
enum { FINISHED = 1 };
enum { FAILED = 2 };
enum { LOCKED = 4 };
enum { WAITING = 5 };
enum { SWITCHING = 6 };
enum { WARNING = 10 };
enum { ERROR = 11 };
enum { READY = 20 };
BEStatus():
stamp(),
behavior_id(0),
code(0),
args_length(0), args(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.sec);
*(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.nsec);
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
*(outbuffer + offset + 0) = (this->code >> (8 * 0)) & 0xFF;
offset += sizeof(this->code);
*(outbuffer + offset + 0) = (this->args_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->args_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->args_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->args_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->args_length);
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_argsi = strlen(this->args[i]);
varToArr(outbuffer + offset, length_argsi);
offset += 4;
memcpy(outbuffer + offset, this->args[i], length_argsi);
offset += length_argsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->stamp.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.sec);
this->stamp.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.nsec);
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
this->code = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->code);
uint32_t args_lengthT = ((uint32_t) (*(inbuffer + offset)));
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->args_length);
if(args_lengthT > args_length)
this->args = (char**)realloc(this->args, args_lengthT * sizeof(char*));
args_length = args_lengthT;
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_st_args;
arrToVar(length_st_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_args-1]=0;
this->st_args = (char *)(inbuffer + offset-1);
offset += length_st_args;
memcpy( &(this->args[i]), &(this->st_args), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BEStatus"; };
const char * getMD5(){ return "467355de4ad406f864268f41621cb885"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisAction.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisAction_h
#define _ROS_flexbe_msgs_BehaviorSynthesisAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorSynthesisActionGoal.h"
#include "flexbe_msgs/BehaviorSynthesisActionResult.h"
#include "flexbe_msgs/BehaviorSynthesisActionFeedback.h"
namespace flexbe_msgs
{
class BehaviorSynthesisAction : public ros::Msg
{
public:
typedef flexbe_msgs::BehaviorSynthesisActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef flexbe_msgs::BehaviorSynthesisActionResult _action_result_type;
_action_result_type action_result;
typedef flexbe_msgs::BehaviorSynthesisActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
BehaviorSynthesisAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisAction"; };
const char * getMD5(){ return "3f70602e7ef6378d09fa82dd8284fb29"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/CommandFeedback.h | #ifndef _ROS_flexbe_msgs_CommandFeedback_h
#define _ROS_flexbe_msgs_CommandFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class CommandFeedback : public ros::Msg
{
public:
typedef const char* _command_type;
_command_type command;
uint32_t args_length;
typedef char* _args_type;
_args_type st_args;
_args_type * args;
CommandFeedback():
command(""),
args_length(0), args(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_command = strlen(this->command);
varToArr(outbuffer + offset, length_command);
offset += 4;
memcpy(outbuffer + offset, this->command, length_command);
offset += length_command;
*(outbuffer + offset + 0) = (this->args_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->args_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->args_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->args_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->args_length);
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_argsi = strlen(this->args[i]);
varToArr(outbuffer + offset, length_argsi);
offset += 4;
memcpy(outbuffer + offset, this->args[i], length_argsi);
offset += length_argsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_command;
arrToVar(length_command, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_command; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_command-1]=0;
this->command = (char *)(inbuffer + offset-1);
offset += length_command;
uint32_t args_lengthT = ((uint32_t) (*(inbuffer + offset)));
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->args_length);
if(args_lengthT > args_length)
this->args = (char**)realloc(this->args, args_lengthT * sizeof(char*));
args_length = args_lengthT;
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_st_args;
arrToVar(length_st_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_args-1]=0;
this->st_args = (char *)(inbuffer + offset-1);
offset += length_st_args;
memcpy( &(this->args[i]), &(this->st_args), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/CommandFeedback"; };
const char * getMD5(){ return "0c984ea7f8fc562a9c04a778877e1a03"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorInputFeedback_h
#define _ROS_flexbe_msgs_BehaviorInputFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorInputFeedback : public ros::Msg
{
public:
BehaviorInputFeedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rospy_tutorials/HeaderString.h | #ifndef _ROS_rospy_tutorials_HeaderString_h
#define _ROS_rospy_tutorials_HeaderString_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace rospy_tutorials
{
class HeaderString : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _data_type;
_data_type data;
HeaderString():
header(),
data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_data = strlen(this->data);
varToArr(outbuffer + offset, length_data);
offset += 4;
memcpy(outbuffer + offset, this->data, length_data);
offset += length_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_data;
arrToVar(length_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_data-1]=0;
this->data = (char *)(inbuffer + offset-1);
offset += length_data;
return offset;
}
const char * getType(){ return "rospy_tutorials/HeaderString"; };
const char * getMD5(){ return "c99a9440709e4d4a9716d55b8270d5e7"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rospy_tutorials/AddTwoInts.h | #ifndef _ROS_SERVICE_AddTwoInts_h
#define _ROS_SERVICE_AddTwoInts_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rospy_tutorials
{
static const char ADDTWOINTS[] = "rospy_tutorials/AddTwoInts";
class AddTwoIntsRequest : public ros::Msg
{
public:
typedef int64_t _a_type;
_a_type a;
typedef int64_t _b_type;
_b_type b;
AddTwoIntsRequest():
a(0),
b(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_a;
u_a.real = this->a;
*(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_a.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_a.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_a.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_a.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->a);
union {
int64_t real;
uint64_t base;
} u_b;
u_b.real = this->b;
*(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_b.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_b.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_b.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_b.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->b);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_a;
u_a.base = 0;
u_a.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->a = u_a.real;
offset += sizeof(this->a);
union {
int64_t real;
uint64_t base;
} u_b;
u_b.base = 0;
u_b.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->b = u_b.real;
offset += sizeof(this->b);
return offset;
}
const char * getType(){ return ADDTWOINTS; };
const char * getMD5(){ return "36d09b846be0b371c5f190354dd3153e"; };
};
class AddTwoIntsResponse : public ros::Msg
{
public:
typedef int64_t _sum_type;
_sum_type sum;
AddTwoIntsResponse():
sum(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_sum;
u_sum.real = this->sum;
*(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sum.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sum.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sum.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sum.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sum);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_sum;
u_sum.base = 0;
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sum = u_sum.real;
offset += sizeof(this->sum);
return offset;
}
const char * getType(){ return ADDTWOINTS; };
const char * getMD5(){ return "b88405221c77b1878a3cbbfff53428d7"; };
};
class AddTwoInts {
public:
typedef AddTwoIntsRequest Request;
typedef AddTwoIntsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rospy_tutorials/BadTwoInts.h | #ifndef _ROS_SERVICE_BadTwoInts_h
#define _ROS_SERVICE_BadTwoInts_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rospy_tutorials
{
static const char BADTWOINTS[] = "rospy_tutorials/BadTwoInts";
class BadTwoIntsRequest : public ros::Msg
{
public:
typedef int64_t _a_type;
_a_type a;
typedef int32_t _b_type;
_b_type b;
BadTwoIntsRequest():
a(0),
b(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_a;
u_a.real = this->a;
*(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_a.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_a.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_a.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_a.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->a);
union {
int32_t real;
uint32_t base;
} u_b;
u_b.real = this->b;
*(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->b);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_a;
u_a.base = 0;
u_a.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->a = u_a.real;
offset += sizeof(this->a);
union {
int32_t real;
uint32_t base;
} u_b;
u_b.base = 0;
u_b.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_b.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_b.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_b.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->b = u_b.real;
offset += sizeof(this->b);
return offset;
}
const char * getType(){ return BADTWOINTS; };
const char * getMD5(){ return "29bb5c7dea8bf822f53e94b0ee5a3a56"; };
};
class BadTwoIntsResponse : public ros::Msg
{
public:
typedef int32_t _sum_type;
_sum_type sum;
BadTwoIntsResponse():
sum(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_sum;
u_sum.real = this->sum;
*(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->sum);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_sum;
u_sum.base = 0;
u_sum.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sum.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sum.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sum.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->sum = u_sum.real;
offset += sizeof(this->sum);
return offset;
}
const char * getType(){ return BADTWOINTS; };
const char * getMD5(){ return "0ba699c25c9418c0366f3595c0c8e8ec"; };
};
class BadTwoInts {
public:
typedef BadTwoIntsRequest Request;
typedef BadTwoIntsResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rospy_tutorials/Floats.h | #ifndef _ROS_rospy_tutorials_Floats_h
#define _ROS_rospy_tutorials_Floats_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rospy_tutorials
{
class Floats : public ros::Msg
{
public:
uint32_t data_length;
typedef float _data_type;
_data_type st_data;
_data_type * data;
Floats():
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
union {
float real;
uint32_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (float*)realloc(this->data, data_lengthT * sizeof(float));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
float real;
uint32_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(float));
}
return offset;
}
const char * getType(){ return "rospy_tutorials/Floats"; };
const char * getMD5(){ return "420cd38b6b071cd49f2970c3e2cee511"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformGoal.h | #ifndef _ROS_tf2_msgs_LookupTransformGoal_h
#define _ROS_tf2_msgs_LookupTransformGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
#include "ros/duration.h"
namespace tf2_msgs
{
class LookupTransformGoal : public ros::Msg
{
public:
typedef const char* _target_frame_type;
_target_frame_type target_frame;
typedef const char* _source_frame_type;
_source_frame_type source_frame;
typedef ros::Time _source_time_type;
_source_time_type source_time;
typedef ros::Duration _timeout_type;
_timeout_type timeout;
typedef ros::Time _target_time_type;
_target_time_type target_time;
typedef const char* _fixed_frame_type;
_fixed_frame_type fixed_frame;
typedef bool _advanced_type;
_advanced_type advanced;
LookupTransformGoal():
target_frame(""),
source_frame(""),
source_time(),
timeout(),
target_time(),
fixed_frame(""),
advanced(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_target_frame = strlen(this->target_frame);
varToArr(outbuffer + offset, length_target_frame);
offset += 4;
memcpy(outbuffer + offset, this->target_frame, length_target_frame);
offset += length_target_frame;
uint32_t length_source_frame = strlen(this->source_frame);
varToArr(outbuffer + offset, length_source_frame);
offset += 4;
memcpy(outbuffer + offset, this->source_frame, length_source_frame);
offset += length_source_frame;
*(outbuffer + offset + 0) = (this->source_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->source_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->source_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->source_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->source_time.sec);
*(outbuffer + offset + 0) = (this->source_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->source_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->source_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->source_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->source_time.nsec);
*(outbuffer + offset + 0) = (this->timeout.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.sec);
*(outbuffer + offset + 0) = (this->timeout.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.nsec);
*(outbuffer + offset + 0) = (this->target_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->target_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->target_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->target_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->target_time.sec);
*(outbuffer + offset + 0) = (this->target_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->target_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->target_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->target_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->target_time.nsec);
uint32_t length_fixed_frame = strlen(this->fixed_frame);
varToArr(outbuffer + offset, length_fixed_frame);
offset += 4;
memcpy(outbuffer + offset, this->fixed_frame, length_fixed_frame);
offset += length_fixed_frame;
union {
bool real;
uint8_t base;
} u_advanced;
u_advanced.real = this->advanced;
*(outbuffer + offset + 0) = (u_advanced.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->advanced);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_target_frame;
arrToVar(length_target_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_target_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_target_frame-1]=0;
this->target_frame = (char *)(inbuffer + offset-1);
offset += length_target_frame;
uint32_t length_source_frame;
arrToVar(length_source_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_source_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_source_frame-1]=0;
this->source_frame = (char *)(inbuffer + offset-1);
offset += length_source_frame;
this->source_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->source_time.sec);
this->source_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->source_time.nsec);
this->timeout.sec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.sec);
this->timeout.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.nsec);
this->target_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->target_time.sec);
this->target_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->target_time.nsec);
uint32_t length_fixed_frame;
arrToVar(length_fixed_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_fixed_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_fixed_frame-1]=0;
this->fixed_frame = (char *)(inbuffer + offset-1);
offset += length_fixed_frame;
union {
bool real;
uint8_t base;
} u_advanced;
u_advanced.base = 0;
u_advanced.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->advanced = u_advanced.real;
offset += sizeof(this->advanced);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformGoal"; };
const char * getMD5(){ return "35e3720468131d675a18bb6f3e5f22f8"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformActionResult.h | #ifndef _ROS_tf2_msgs_LookupTransformActionResult_h
#define _ROS_tf2_msgs_LookupTransformActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "tf2_msgs/LookupTransformResult.h"
namespace tf2_msgs
{
class LookupTransformActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef tf2_msgs::LookupTransformResult _result_type;
_result_type result;
LookupTransformActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformActionResult"; };
const char * getMD5(){ return "ac26ce75a41384fa8bb4dc10f491ab90"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformActionFeedback.h | #ifndef _ROS_tf2_msgs_LookupTransformActionFeedback_h
#define _ROS_tf2_msgs_LookupTransformActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "tf2_msgs/LookupTransformFeedback.h"
namespace tf2_msgs
{
class LookupTransformActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef tf2_msgs::LookupTransformFeedback _feedback_type;
_feedback_type feedback;
LookupTransformActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/FrameGraph.h | #ifndef _ROS_SERVICE_FrameGraph_h
#define _ROS_SERVICE_FrameGraph_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace tf2_msgs
{
static const char FRAMEGRAPH[] = "tf2_msgs/FrameGraph";
class FrameGraphRequest : public ros::Msg
{
public:
FrameGraphRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return FRAMEGRAPH; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class FrameGraphResponse : public ros::Msg
{
public:
typedef const char* _frame_yaml_type;
_frame_yaml_type frame_yaml;
FrameGraphResponse():
frame_yaml("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_frame_yaml = strlen(this->frame_yaml);
varToArr(outbuffer + offset, length_frame_yaml);
offset += 4;
memcpy(outbuffer + offset, this->frame_yaml, length_frame_yaml);
offset += length_frame_yaml;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_frame_yaml;
arrToVar(length_frame_yaml, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_frame_yaml; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_frame_yaml-1]=0;
this->frame_yaml = (char *)(inbuffer + offset-1);
offset += length_frame_yaml;
return offset;
}
const char * getType(){ return FRAMEGRAPH; };
const char * getMD5(){ return "437ea58e9463815a0d511c7326b686b0"; };
};
class FrameGraph {
public:
typedef FrameGraphRequest Request;
typedef FrameGraphResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformResult.h | #ifndef _ROS_tf2_msgs_LookupTransformResult_h
#define _ROS_tf2_msgs_LookupTransformResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/TransformStamped.h"
#include "tf2_msgs/TF2Error.h"
namespace tf2_msgs
{
class LookupTransformResult : public ros::Msg
{
public:
typedef geometry_msgs::TransformStamped _transform_type;
_transform_type transform;
typedef tf2_msgs::TF2Error _error_type;
_error_type error;
LookupTransformResult():
transform(),
error()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->transform.serialize(outbuffer + offset);
offset += this->error.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->transform.deserialize(inbuffer + offset);
offset += this->error.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformResult"; };
const char * getMD5(){ return "3fe5db6a19ca9cfb675418c5ad875c36"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/TF2Error.h | #ifndef _ROS_tf2_msgs_TF2Error_h
#define _ROS_tf2_msgs_TF2Error_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace tf2_msgs
{
class TF2Error : public ros::Msg
{
public:
typedef uint8_t _error_type;
_error_type error;
typedef const char* _error_string_type;
_error_string_type error_string;
enum { NO_ERROR = 0 };
enum { LOOKUP_ERROR = 1 };
enum { CONNECTIVITY_ERROR = 2 };
enum { EXTRAPOLATION_ERROR = 3 };
enum { INVALID_ARGUMENT_ERROR = 4 };
enum { TIMEOUT_ERROR = 5 };
enum { TRANSFORM_ERROR = 6 };
TF2Error():
error(0),
error_string("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->error >> (8 * 0)) & 0xFF;
offset += sizeof(this->error);
uint32_t length_error_string = strlen(this->error_string);
varToArr(outbuffer + offset, length_error_string);
offset += 4;
memcpy(outbuffer + offset, this->error_string, length_error_string);
offset += length_error_string;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->error = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->error);
uint32_t length_error_string;
arrToVar(length_error_string, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_error_string; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_error_string-1]=0;
this->error_string = (char *)(inbuffer + offset-1);
offset += length_error_string;
return offset;
}
const char * getType(){ return "tf2_msgs/TF2Error"; };
const char * getMD5(){ return "bc6848fd6fd750c92e38575618a4917d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformFeedback.h | #ifndef _ROS_tf2_msgs_LookupTransformFeedback_h
#define _ROS_tf2_msgs_LookupTransformFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace tf2_msgs
{
class LookupTransformFeedback : public ros::Msg
{
public:
LookupTransformFeedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformAction.h | #ifndef _ROS_tf2_msgs_LookupTransformAction_h
#define _ROS_tf2_msgs_LookupTransformAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "tf2_msgs/LookupTransformActionGoal.h"
#include "tf2_msgs/LookupTransformActionResult.h"
#include "tf2_msgs/LookupTransformActionFeedback.h"
namespace tf2_msgs
{
class LookupTransformAction : public ros::Msg
{
public:
typedef tf2_msgs::LookupTransformActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef tf2_msgs::LookupTransformActionResult _action_result_type;
_action_result_type action_result;
typedef tf2_msgs::LookupTransformActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
LookupTransformAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformAction"; };
const char * getMD5(){ return "7ee01ba91a56c2245c610992dbaa3c37"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformActionGoal.h | #ifndef _ROS_tf2_msgs_LookupTransformActionGoal_h
#define _ROS_tf2_msgs_LookupTransformActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "tf2_msgs/LookupTransformGoal.h"
namespace tf2_msgs
{
class LookupTransformActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef tf2_msgs::LookupTransformGoal _goal_type;
_goal_type goal;
LookupTransformActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformActionGoal"; };
const char * getMD5(){ return "f2e7bcdb75c847978d0351a13e699da5"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/TFMessage.h | #ifndef _ROS_tf2_msgs_TFMessage_h
#define _ROS_tf2_msgs_TFMessage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/TransformStamped.h"
namespace tf2_msgs
{
class TFMessage : public ros::Msg
{
public:
uint32_t transforms_length;
typedef geometry_msgs::TransformStamped _transforms_type;
_transforms_type st_transforms;
_transforms_type * transforms;
TFMessage():
transforms_length(0), transforms(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->transforms_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transforms_length);
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->transforms[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transforms_length);
if(transforms_lengthT > transforms_length)
this->transforms = (geometry_msgs::TransformStamped*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::TransformStamped));
transforms_length = transforms_lengthT;
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->st_transforms.deserialize(inbuffer + offset);
memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::TransformStamped));
}
return offset;
}
const char * getType(){ return "tf2_msgs/TFMessage"; };
const char * getMD5(){ return "94810edda583a504dfda3829e70d7eec"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ar_track_alvar_msgs/AlvarMarker.h | #ifndef _ROS_ar_track_alvar_msgs_AlvarMarker_h
#define _ROS_ar_track_alvar_msgs_AlvarMarker_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/PoseStamped.h"
namespace ar_track_alvar_msgs
{
class AlvarMarker : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _id_type;
_id_type id;
typedef uint32_t _confidence_type;
_confidence_type confidence;
typedef geometry_msgs::PoseStamped _pose_type;
_pose_type pose;
AlvarMarker():
header(),
id(0),
confidence(0),
pose()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
*(outbuffer + offset + 0) = (this->confidence >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->confidence >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->confidence >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->confidence >> (8 * 3)) & 0xFF;
offset += sizeof(this->confidence);
offset += this->pose.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->id = ((uint32_t) (*(inbuffer + offset)));
this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->id);
this->confidence = ((uint32_t) (*(inbuffer + offset)));
this->confidence |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->confidence |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->confidence |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->confidence);
offset += this->pose.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "ar_track_alvar_msgs/AlvarMarker"; };
const char * getMD5(){ return "ef2b6ad42bcb18e16b22fefb5c0fb85f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/ar_track_alvar_msgs/AlvarMarkers.h | #ifndef _ROS_ar_track_alvar_msgs_AlvarMarkers_h
#define _ROS_ar_track_alvar_msgs_AlvarMarkers_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "ar_track_alvar_msgs/AlvarMarker.h"
namespace ar_track_alvar_msgs
{
class AlvarMarkers : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t markers_length;
typedef ar_track_alvar_msgs::AlvarMarker _markers_type;
_markers_type st_markers;
_markers_type * markers;
AlvarMarkers():
header(),
markers_length(0), markers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (ar_track_alvar_msgs::AlvarMarker*)realloc(this->markers, markers_lengthT * sizeof(ar_track_alvar_msgs::AlvarMarker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(ar_track_alvar_msgs::AlvarMarker));
}
return offset;
}
const char * getType(){ return "ar_track_alvar_msgs/AlvarMarkers"; };
const char * getMD5(){ return "943fe17bfb0b4ea7890368d0b25ad0ad"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionActionResult.h | #ifndef _ROS_control_msgs_SingleJointPositionActionResult_h
#define _ROS_control_msgs_SingleJointPositionActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/SingleJointPositionResult.h"
namespace control_msgs
{
class SingleJointPositionActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::SingleJointPositionResult _result_type;
_result_type result;
SingleJointPositionActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionActionResult"; };
const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PidState.h | #ifndef _ROS_control_msgs_PidState_h
#define _ROS_control_msgs_PidState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "ros/duration.h"
namespace control_msgs
{
class PidState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef ros::Duration _timestep_type;
_timestep_type timestep;
typedef double _error_type;
_error_type error;
typedef double _error_dot_type;
_error_dot_type error_dot;
typedef double _p_error_type;
_p_error_type p_error;
typedef double _i_error_type;
_i_error_type i_error;
typedef double _d_error_type;
_d_error_type d_error;
typedef double _p_term_type;
_p_term_type p_term;
typedef double _i_term_type;
_i_term_type i_term;
typedef double _d_term_type;
_d_term_type d_term;
typedef double _i_max_type;
_i_max_type i_max;
typedef double _i_min_type;
_i_min_type i_min;
typedef double _output_type;
_output_type output;
PidState():
header(),
timestep(),
error(0),
error_dot(0),
p_error(0),
i_error(0),
d_error(0),
p_term(0),
i_term(0),
d_term(0),
i_max(0),
i_min(0),
output(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->timestep.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestep.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestep.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestep.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestep.sec);
*(outbuffer + offset + 0) = (this->timestep.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestep.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestep.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestep.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestep.nsec);
union {
double real;
uint64_t base;
} u_error;
u_error.real = this->error;
*(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->error);
union {
double real;
uint64_t base;
} u_error_dot;
u_error_dot.real = this->error_dot;
*(outbuffer + offset + 0) = (u_error_dot.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error_dot.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error_dot.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error_dot.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_error_dot.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_error_dot.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_error_dot.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_error_dot.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->error_dot);
union {
double real;
uint64_t base;
} u_p_error;
u_p_error.real = this->p_error;
*(outbuffer + offset + 0) = (u_p_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_p_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_p_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_p_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_p_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_p_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_p_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_p_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->p_error);
union {
double real;
uint64_t base;
} u_i_error;
u_i_error.real = this->i_error;
*(outbuffer + offset + 0) = (u_i_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_error);
union {
double real;
uint64_t base;
} u_d_error;
u_d_error.real = this->d_error;
*(outbuffer + offset + 0) = (u_d_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_d_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_d_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_d_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_d_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_d_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_d_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_d_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->d_error);
union {
double real;
uint64_t base;
} u_p_term;
u_p_term.real = this->p_term;
*(outbuffer + offset + 0) = (u_p_term.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_p_term.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_p_term.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_p_term.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_p_term.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_p_term.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_p_term.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_p_term.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->p_term);
union {
double real;
uint64_t base;
} u_i_term;
u_i_term.real = this->i_term;
*(outbuffer + offset + 0) = (u_i_term.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_term.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_term.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_term.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_term.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_term.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_term.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_term.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_term);
union {
double real;
uint64_t base;
} u_d_term;
u_d_term.real = this->d_term;
*(outbuffer + offset + 0) = (u_d_term.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_d_term.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_d_term.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_d_term.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_d_term.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_d_term.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_d_term.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_d_term.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->d_term);
union {
double real;
uint64_t base;
} u_i_max;
u_i_max.real = this->i_max;
*(outbuffer + offset + 0) = (u_i_max.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_max.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_max.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_max.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_max.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_max.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_max.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_max.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_max);
union {
double real;
uint64_t base;
} u_i_min;
u_i_min.real = this->i_min;
*(outbuffer + offset + 0) = (u_i_min.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_min.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_min.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_min.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_min.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_min.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_min.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_min.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_min);
union {
double real;
uint64_t base;
} u_output;
u_output.real = this->output;
*(outbuffer + offset + 0) = (u_output.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_output.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_output.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_output.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_output.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_output.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_output.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_output.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->output);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->timestep.sec = ((uint32_t) (*(inbuffer + offset)));
this->timestep.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestep.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestep.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestep.sec);
this->timestep.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timestep.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestep.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestep.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestep.nsec);
union {
double real;
uint64_t base;
} u_error;
u_error.base = 0;
u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->error = u_error.real;
offset += sizeof(this->error);
union {
double real;
uint64_t base;
} u_error_dot;
u_error_dot.base = 0;
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_error_dot.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->error_dot = u_error_dot.real;
offset += sizeof(this->error_dot);
union {
double real;
uint64_t base;
} u_p_error;
u_p_error.base = 0;
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_p_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->p_error = u_p_error.real;
offset += sizeof(this->p_error);
union {
double real;
uint64_t base;
} u_i_error;
u_i_error.base = 0;
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_error = u_i_error.real;
offset += sizeof(this->i_error);
union {
double real;
uint64_t base;
} u_d_error;
u_d_error.base = 0;
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_d_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->d_error = u_d_error.real;
offset += sizeof(this->d_error);
union {
double real;
uint64_t base;
} u_p_term;
u_p_term.base = 0;
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_p_term.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->p_term = u_p_term.real;
offset += sizeof(this->p_term);
union {
double real;
uint64_t base;
} u_i_term;
u_i_term.base = 0;
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_term.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_term = u_i_term.real;
offset += sizeof(this->i_term);
union {
double real;
uint64_t base;
} u_d_term;
u_d_term.base = 0;
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_d_term.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->d_term = u_d_term.real;
offset += sizeof(this->d_term);
union {
double real;
uint64_t base;
} u_i_max;
u_i_max.base = 0;
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_max.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_max = u_i_max.real;
offset += sizeof(this->i_max);
union {
double real;
uint64_t base;
} u_i_min;
u_i_min.base = 0;
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_min.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_min = u_i_min.real;
offset += sizeof(this->i_min);
union {
double real;
uint64_t base;
} u_output;
u_output.base = 0;
u_output.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_output.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->output = u_output.real;
offset += sizeof(this->output);
return offset;
}
const char * getType(){ return "control_msgs/PidState"; };
const char * getMD5(){ return "b138ec00e886c10e73f27e8712252ea6"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionFeedback.h | #ifndef _ROS_control_msgs_SingleJointPositionFeedback_h
#define _ROS_control_msgs_SingleJointPositionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace control_msgs
{
class SingleJointPositionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef double _position_type;
_position_type position;
typedef double _velocity_type;
_velocity_type velocity;
typedef double _error_type;
_error_type error;
SingleJointPositionFeedback():
header(),
position(0),
velocity(0),
error(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_velocity;
u_velocity.real = this->velocity;
*(outbuffer + offset + 0) = (u_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity);
union {
double real;
uint64_t base;
} u_error;
u_error.real = this->error;
*(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->error);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_velocity;
u_velocity.base = 0;
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->velocity = u_velocity.real;
offset += sizeof(this->velocity);
union {
double real;
uint64_t base;
} u_error;
u_error.base = 0;
u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->error = u_error.real;
offset += sizeof(this->error);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionFeedback"; };
const char * getMD5(){ return "8cee65610a3d08e0a1bded82f146f1fd"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadActionGoal.h | #ifndef _ROS_control_msgs_PointHeadActionGoal_h
#define _ROS_control_msgs_PointHeadActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "control_msgs/PointHeadGoal.h"
namespace control_msgs
{
class PointHeadActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef control_msgs::PointHeadGoal _goal_type;
_goal_type goal;
PointHeadActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadActionGoal"; };
const char * getMD5(){ return "b53a8323d0ba7b310ba17a2d3a82a6b8"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandActionFeedback.h | #ifndef _ROS_control_msgs_GripperCommandActionFeedback_h
#define _ROS_control_msgs_GripperCommandActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/GripperCommandFeedback.h"
namespace control_msgs
{
class GripperCommandActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::GripperCommandFeedback _feedback_type;
_feedback_type feedback;
GripperCommandActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandActionFeedback"; };
const char * getMD5(){ return "653dff30c045f5e6ff3feb3409f4558d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTolerance.h | #ifndef _ROS_control_msgs_JointTolerance_h
#define _ROS_control_msgs_JointTolerance_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class JointTolerance : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef double _position_type;
_position_type position;
typedef double _velocity_type;
_velocity_type velocity;
typedef double _acceleration_type;
_acceleration_type acceleration;
JointTolerance():
name(""),
position(0),
velocity(0),
acceleration(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_velocity;
u_velocity.real = this->velocity;
*(outbuffer + offset + 0) = (u_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity);
union {
double real;
uint64_t base;
} u_acceleration;
u_acceleration.real = this->acceleration;
*(outbuffer + offset + 0) = (u_acceleration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_acceleration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_acceleration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_acceleration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_acceleration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_acceleration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_acceleration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_acceleration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->acceleration);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_velocity;
u_velocity.base = 0;
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->velocity = u_velocity.real;
offset += sizeof(this->velocity);
union {
double real;
uint64_t base;
} u_acceleration;
u_acceleration.base = 0;
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->acceleration = u_acceleration.real;
offset += sizeof(this->acceleration);
return offset;
}
const char * getType(){ return "control_msgs/JointTolerance"; };
const char * getMD5(){ return "f544fe9c16cf04547e135dd6063ff5be"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionAction.h | #ifndef _ROS_control_msgs_SingleJointPositionAction_h
#define _ROS_control_msgs_SingleJointPositionAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/SingleJointPositionActionGoal.h"
#include "control_msgs/SingleJointPositionActionResult.h"
#include "control_msgs/SingleJointPositionActionFeedback.h"
namespace control_msgs
{
class SingleJointPositionAction : public ros::Msg
{
public:
typedef control_msgs::SingleJointPositionActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::SingleJointPositionActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::SingleJointPositionActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
SingleJointPositionAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionAction"; };
const char * getMD5(){ return "c4a786b7d53e5d0983decf967a5a779e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryActionResult.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryActionResult_h
#define _ROS_control_msgs_FollowJointTrajectoryActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/FollowJointTrajectoryResult.h"
namespace control_msgs
{
class FollowJointTrajectoryActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::FollowJointTrajectoryResult _result_type;
_result_type result;
FollowJointTrajectoryActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryActionResult"; };
const char * getMD5(){ return "c4fb3b000dc9da4fd99699380efcc5d9"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryGoal.h | #ifndef _ROS_control_msgs_JointTrajectoryGoal_h
#define _ROS_control_msgs_JointTrajectoryGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
namespace control_msgs
{
class JointTrajectoryGoal : public ros::Msg
{
public:
typedef trajectory_msgs::JointTrajectory _trajectory_type;
_trajectory_type trajectory;
JointTrajectoryGoal():
trajectory()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryGoal"; };
const char * getMD5(){ return "2a0eff76c870e8595636c2a562ca298e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryActionGoal.h | #ifndef _ROS_control_msgs_JointTrajectoryActionGoal_h
#define _ROS_control_msgs_JointTrajectoryActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "control_msgs/JointTrajectoryGoal.h"
namespace control_msgs
{
class JointTrajectoryActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef control_msgs::JointTrajectoryGoal _goal_type;
_goal_type goal;
JointTrajectoryActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryActionGoal"; };
const char * getMD5(){ return "a99e83ef6185f9fdd7693efe99623a86"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryControllerState.h | #ifndef _ROS_control_msgs_JointTrajectoryControllerState_h
#define _ROS_control_msgs_JointTrajectoryControllerState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "trajectory_msgs/JointTrajectoryPoint.h"
namespace control_msgs
{
class JointTrajectoryControllerState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
typedef trajectory_msgs::JointTrajectoryPoint _desired_type;
_desired_type desired;
typedef trajectory_msgs::JointTrajectoryPoint _actual_type;
_actual_type actual;
typedef trajectory_msgs::JointTrajectoryPoint _error_type;
_error_type error;
JointTrajectoryControllerState():
header(),
joint_names_length(0), joint_names(NULL),
desired(),
actual(),
error()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
offset += this->desired.serialize(outbuffer + offset);
offset += this->actual.serialize(outbuffer + offset);
offset += this->error.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
offset += this->desired.deserialize(inbuffer + offset);
offset += this->actual.deserialize(inbuffer + offset);
offset += this->error.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryControllerState"; };
const char * getMD5(){ return "10817c60c2486ef6b33e97dcd87f4474"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/QueryTrajectoryState.h | #ifndef _ROS_SERVICE_QueryTrajectoryState_h
#define _ROS_SERVICE_QueryTrajectoryState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace control_msgs
{
static const char QUERYTRAJECTORYSTATE[] = "control_msgs/QueryTrajectoryState";
class QueryTrajectoryStateRequest : public ros::Msg
{
public:
typedef ros::Time _time_type;
_time_type time;
QueryTrajectoryStateRequest():
time()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time.sec);
*(outbuffer + offset + 0) = (this->time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->time.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->time.sec = ((uint32_t) (*(inbuffer + offset)));
this->time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time.sec);
this->time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->time.nsec);
return offset;
}
const char * getType(){ return QUERYTRAJECTORYSTATE; };
const char * getMD5(){ return "556a4fb76023a469987922359d08a844"; };
};
class QueryTrajectoryStateResponse : public ros::Msg
{
public:
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t position_length;
typedef double _position_type;
_position_type st_position;
_position_type * position;
uint32_t velocity_length;
typedef double _velocity_type;
_velocity_type st_velocity;
_velocity_type * velocity;
uint32_t acceleration_length;
typedef double _acceleration_type;
_acceleration_type st_acceleration;
_acceleration_type * acceleration;
QueryTrajectoryStateResponse():
name_length(0), name(NULL),
position_length(0), position(NULL),
velocity_length(0), velocity(NULL),
acceleration_length(0), acceleration(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->position_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_length);
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_positioni;
u_positioni.real = this->position[i];
*(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_positioni.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_positioni.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_positioni.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_positioni.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position[i]);
}
*(outbuffer + offset + 0) = (this->velocity_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocity_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocity_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocity_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocity_length);
for( uint32_t i = 0; i < velocity_length; i++){
union {
double real;
uint64_t base;
} u_velocityi;
u_velocityi.real = this->velocity[i];
*(outbuffer + offset + 0) = (u_velocityi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocityi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocityi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocityi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocityi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocityi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocityi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocityi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocity[i]);
}
*(outbuffer + offset + 0) = (this->acceleration_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->acceleration_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->acceleration_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->acceleration_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->acceleration_length);
for( uint32_t i = 0; i < acceleration_length; i++){
union {
double real;
uint64_t base;
} u_accelerationi;
u_accelerationi.real = this->acceleration[i];
*(outbuffer + offset + 0) = (u_accelerationi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_accelerationi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_accelerationi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_accelerationi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_accelerationi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_accelerationi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_accelerationi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_accelerationi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->acceleration[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t position_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_length);
if(position_lengthT > position_length)
this->position = (double*)realloc(this->position, position_lengthT * sizeof(double));
position_length = position_lengthT;
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_st_position;
u_st_position.base = 0;
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_position = u_st_position.real;
offset += sizeof(this->st_position);
memcpy( &(this->position[i]), &(this->st_position), sizeof(double));
}
uint32_t velocity_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocity_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocity_length);
if(velocity_lengthT > velocity_length)
this->velocity = (double*)realloc(this->velocity, velocity_lengthT * sizeof(double));
velocity_length = velocity_lengthT;
for( uint32_t i = 0; i < velocity_length; i++){
union {
double real;
uint64_t base;
} u_st_velocity;
u_st_velocity.base = 0;
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocity = u_st_velocity.real;
offset += sizeof(this->st_velocity);
memcpy( &(this->velocity[i]), &(this->st_velocity), sizeof(double));
}
uint32_t acceleration_lengthT = ((uint32_t) (*(inbuffer + offset)));
acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
acceleration_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->acceleration_length);
if(acceleration_lengthT > acceleration_length)
this->acceleration = (double*)realloc(this->acceleration, acceleration_lengthT * sizeof(double));
acceleration_length = acceleration_lengthT;
for( uint32_t i = 0; i < acceleration_length; i++){
union {
double real;
uint64_t base;
} u_st_acceleration;
u_st_acceleration.base = 0;
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_acceleration = u_st_acceleration.real;
offset += sizeof(this->st_acceleration);
memcpy( &(this->acceleration[i]), &(this->st_acceleration), sizeof(double));
}
return offset;
}
const char * getType(){ return QUERYTRAJECTORYSTATE; };
const char * getMD5(){ return "1f1a6554ad060f44d013e71868403c1a"; };
};
class QueryTrajectoryState {
public:
typedef QueryTrajectoryStateRequest Request;
typedef QueryTrajectoryStateResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/QueryCalibrationState.h | #ifndef _ROS_SERVICE_QueryCalibrationState_h
#define _ROS_SERVICE_QueryCalibrationState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
static const char QUERYCALIBRATIONSTATE[] = "control_msgs/QueryCalibrationState";
class QueryCalibrationStateRequest : public ros::Msg
{
public:
QueryCalibrationStateRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return QUERYCALIBRATIONSTATE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class QueryCalibrationStateResponse : public ros::Msg
{
public:
typedef bool _is_calibrated_type;
_is_calibrated_type is_calibrated;
QueryCalibrationStateResponse():
is_calibrated(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_is_calibrated;
u_is_calibrated.real = this->is_calibrated;
*(outbuffer + offset + 0) = (u_is_calibrated.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_calibrated);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_is_calibrated;
u_is_calibrated.base = 0;
u_is_calibrated.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_calibrated = u_is_calibrated.real;
offset += sizeof(this->is_calibrated);
return offset;
}
const char * getType(){ return QUERYCALIBRATIONSTATE; };
const char * getMD5(){ return "28af3beedcb84986b8e470dc5470507d"; };
};
class QueryCalibrationState {
public:
typedef QueryCalibrationStateRequest Request;
typedef QueryCalibrationStateResponse Response;
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandFeedback.h | #ifndef _ROS_control_msgs_GripperCommandFeedback_h
#define _ROS_control_msgs_GripperCommandFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class GripperCommandFeedback : public ros::Msg
{
public:
typedef double _position_type;
_position_type position;
typedef double _effort_type;
_effort_type effort;
typedef bool _stalled_type;
_stalled_type stalled;
typedef bool _reached_goal_type;
_reached_goal_type reached_goal;
GripperCommandFeedback():
position(0),
effort(0),
stalled(0),
reached_goal(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_effort;
u_effort.real = this->effort;
*(outbuffer + offset + 0) = (u_effort.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_effort.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_effort.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_effort.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_effort.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_effort.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_effort.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_effort.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->effort);
union {
bool real;
uint8_t base;
} u_stalled;
u_stalled.real = this->stalled;
*(outbuffer + offset + 0) = (u_stalled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->stalled);
union {
bool real;
uint8_t base;
} u_reached_goal;
u_reached_goal.real = this->reached_goal;
*(outbuffer + offset + 0) = (u_reached_goal.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->reached_goal);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_effort;
u_effort.base = 0;
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->effort = u_effort.real;
offset += sizeof(this->effort);
union {
bool real;
uint8_t base;
} u_stalled;
u_stalled.base = 0;
u_stalled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->stalled = u_stalled.real;
offset += sizeof(this->stalled);
union {
bool real;
uint8_t base;
} u_reached_goal;
u_reached_goal.base = 0;
u_reached_goal.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->reached_goal = u_reached_goal.real;
offset += sizeof(this->reached_goal);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandFeedback"; };
const char * getMD5(){ return "e4cbff56d3562bcf113da5a5adeef91f"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadFeedback.h | #ifndef _ROS_control_msgs_PointHeadFeedback_h
#define _ROS_control_msgs_PointHeadFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class PointHeadFeedback : public ros::Msg
{
public:
typedef double _pointing_angle_error_type;
_pointing_angle_error_type pointing_angle_error;
PointHeadFeedback():
pointing_angle_error(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_pointing_angle_error;
u_pointing_angle_error.real = this->pointing_angle_error;
*(outbuffer + offset + 0) = (u_pointing_angle_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_pointing_angle_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_pointing_angle_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_pointing_angle_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_pointing_angle_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_pointing_angle_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_pointing_angle_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_pointing_angle_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->pointing_angle_error);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_pointing_angle_error;
u_pointing_angle_error.base = 0;
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_pointing_angle_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->pointing_angle_error = u_pointing_angle_error.real;
offset += sizeof(this->pointing_angle_error);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadFeedback"; };
const char * getMD5(){ return "cce80d27fd763682da8805a73316cab4"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryGoal.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryGoal_h
#define _ROS_control_msgs_FollowJointTrajectoryGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "control_msgs/JointTolerance.h"
#include "ros/duration.h"
namespace control_msgs
{
class FollowJointTrajectoryGoal : public ros::Msg
{
public:
typedef trajectory_msgs::JointTrajectory _trajectory_type;
_trajectory_type trajectory;
uint32_t path_tolerance_length;
typedef control_msgs::JointTolerance _path_tolerance_type;
_path_tolerance_type st_path_tolerance;
_path_tolerance_type * path_tolerance;
uint32_t goal_tolerance_length;
typedef control_msgs::JointTolerance _goal_tolerance_type;
_goal_tolerance_type st_goal_tolerance;
_goal_tolerance_type * goal_tolerance;
typedef ros::Duration _goal_time_tolerance_type;
_goal_time_tolerance_type goal_time_tolerance;
FollowJointTrajectoryGoal():
trajectory(),
path_tolerance_length(0), path_tolerance(NULL),
goal_tolerance_length(0), goal_tolerance(NULL),
goal_time_tolerance()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->path_tolerance_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->path_tolerance_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->path_tolerance_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->path_tolerance_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->path_tolerance_length);
for( uint32_t i = 0; i < path_tolerance_length; i++){
offset += this->path_tolerance[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->goal_tolerance_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_tolerance_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_tolerance_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_tolerance_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_tolerance_length);
for( uint32_t i = 0; i < goal_tolerance_length; i++){
offset += this->goal_tolerance[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->goal_time_tolerance.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_time_tolerance.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_time_tolerance.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_time_tolerance.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_time_tolerance.sec);
*(outbuffer + offset + 0) = (this->goal_time_tolerance.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_time_tolerance.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_time_tolerance.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_time_tolerance.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_time_tolerance.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory.deserialize(inbuffer + offset);
uint32_t path_tolerance_lengthT = ((uint32_t) (*(inbuffer + offset)));
path_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
path_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
path_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->path_tolerance_length);
if(path_tolerance_lengthT > path_tolerance_length)
this->path_tolerance = (control_msgs::JointTolerance*)realloc(this->path_tolerance, path_tolerance_lengthT * sizeof(control_msgs::JointTolerance));
path_tolerance_length = path_tolerance_lengthT;
for( uint32_t i = 0; i < path_tolerance_length; i++){
offset += this->st_path_tolerance.deserialize(inbuffer + offset);
memcpy( &(this->path_tolerance[i]), &(this->st_path_tolerance), sizeof(control_msgs::JointTolerance));
}
uint32_t goal_tolerance_lengthT = ((uint32_t) (*(inbuffer + offset)));
goal_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
goal_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
goal_tolerance_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_tolerance_length);
if(goal_tolerance_lengthT > goal_tolerance_length)
this->goal_tolerance = (control_msgs::JointTolerance*)realloc(this->goal_tolerance, goal_tolerance_lengthT * sizeof(control_msgs::JointTolerance));
goal_tolerance_length = goal_tolerance_lengthT;
for( uint32_t i = 0; i < goal_tolerance_length; i++){
offset += this->st_goal_tolerance.deserialize(inbuffer + offset);
memcpy( &(this->goal_tolerance[i]), &(this->st_goal_tolerance), sizeof(control_msgs::JointTolerance));
}
this->goal_time_tolerance.sec = ((uint32_t) (*(inbuffer + offset)));
this->goal_time_tolerance.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->goal_time_tolerance.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->goal_time_tolerance.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_time_tolerance.sec);
this->goal_time_tolerance.nsec = ((uint32_t) (*(inbuffer + offset)));
this->goal_time_tolerance.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->goal_time_tolerance.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->goal_time_tolerance.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_time_tolerance.nsec);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryGoal"; };
const char * getMD5(){ return "69636787b6ecbde4d61d711979bc7ecb"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadActionFeedback.h | #ifndef _ROS_control_msgs_PointHeadActionFeedback_h
#define _ROS_control_msgs_PointHeadActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/PointHeadFeedback.h"
namespace control_msgs
{
class PointHeadActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::PointHeadFeedback _feedback_type;
_feedback_type feedback;
PointHeadActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadActionFeedback"; };
const char * getMD5(){ return "33c9244957176bbba97dd641119e8460"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointJog.h | #ifndef _ROS_control_msgs_JointJog_h
#define _ROS_control_msgs_JointJog_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace control_msgs
{
class JointJog : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t displacements_length;
typedef double _displacements_type;
_displacements_type st_displacements;
_displacements_type * displacements;
uint32_t velocities_length;
typedef double _velocities_type;
_velocities_type st_velocities;
_velocities_type * velocities;
typedef double _duration_type;
_duration_type duration;
JointJog():
header(),
joint_names_length(0), joint_names(NULL),
displacements_length(0), displacements(NULL),
velocities_length(0), velocities(NULL),
duration(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->displacements_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->displacements_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->displacements_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->displacements_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->displacements_length);
for( uint32_t i = 0; i < displacements_length; i++){
union {
double real;
uint64_t base;
} u_displacementsi;
u_displacementsi.real = this->displacements[i];
*(outbuffer + offset + 0) = (u_displacementsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_displacementsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_displacementsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_displacementsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_displacementsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_displacementsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_displacementsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_displacementsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->displacements[i]);
}
*(outbuffer + offset + 0) = (this->velocities_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->velocities_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->velocities_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->velocities_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->velocities_length);
for( uint32_t i = 0; i < velocities_length; i++){
union {
double real;
uint64_t base;
} u_velocitiesi;
u_velocitiesi.real = this->velocities[i];
*(outbuffer + offset + 0) = (u_velocitiesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_velocitiesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_velocitiesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_velocitiesi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_velocitiesi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_velocitiesi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_velocitiesi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_velocitiesi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->velocities[i]);
}
union {
double real;
uint64_t base;
} u_duration;
u_duration.real = this->duration;
*(outbuffer + offset + 0) = (u_duration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_duration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_duration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_duration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_duration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_duration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_duration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_duration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->duration);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t displacements_lengthT = ((uint32_t) (*(inbuffer + offset)));
displacements_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
displacements_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
displacements_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->displacements_length);
if(displacements_lengthT > displacements_length)
this->displacements = (double*)realloc(this->displacements, displacements_lengthT * sizeof(double));
displacements_length = displacements_lengthT;
for( uint32_t i = 0; i < displacements_length; i++){
union {
double real;
uint64_t base;
} u_st_displacements;
u_st_displacements.base = 0;
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_displacements.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_displacements = u_st_displacements.real;
offset += sizeof(this->st_displacements);
memcpy( &(this->displacements[i]), &(this->st_displacements), sizeof(double));
}
uint32_t velocities_lengthT = ((uint32_t) (*(inbuffer + offset)));
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
velocities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->velocities_length);
if(velocities_lengthT > velocities_length)
this->velocities = (double*)realloc(this->velocities, velocities_lengthT * sizeof(double));
velocities_length = velocities_lengthT;
for( uint32_t i = 0; i < velocities_length; i++){
union {
double real;
uint64_t base;
} u_st_velocities;
u_st_velocities.base = 0;
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_velocities.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_velocities = u_st_velocities.real;
offset += sizeof(this->st_velocities);
memcpy( &(this->velocities[i]), &(this->st_velocities), sizeof(double));
}
union {
double real;
uint64_t base;
} u_duration;
u_duration.base = 0;
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_duration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->duration = u_duration.real;
offset += sizeof(this->duration);
return offset;
}
const char * getType(){ return "control_msgs/JointJog"; };
const char * getMD5(){ return "1685da700c8c2e1254afc92a5fb89c96"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryAction.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryAction_h
#define _ROS_control_msgs_FollowJointTrajectoryAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/FollowJointTrajectoryActionGoal.h"
#include "control_msgs/FollowJointTrajectoryActionResult.h"
#include "control_msgs/FollowJointTrajectoryActionFeedback.h"
namespace control_msgs
{
class FollowJointTrajectoryAction : public ros::Msg
{
public:
typedef control_msgs::FollowJointTrajectoryActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::FollowJointTrajectoryActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::FollowJointTrajectoryActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
FollowJointTrajectoryAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryAction"; };
const char * getMD5(){ return "bc4f9b743838566551c0390c65f1a248"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionActionGoal.h | #ifndef _ROS_control_msgs_SingleJointPositionActionGoal_h
#define _ROS_control_msgs_SingleJointPositionActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "control_msgs/SingleJointPositionGoal.h"
namespace control_msgs
{
class SingleJointPositionActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef control_msgs::SingleJointPositionGoal _goal_type;
_goal_type goal;
SingleJointPositionActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionActionGoal"; };
const char * getMD5(){ return "4b0d3d091471663e17749c1d0db90f61"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionGoal.h | #ifndef _ROS_control_msgs_SingleJointPositionGoal_h
#define _ROS_control_msgs_SingleJointPositionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
namespace control_msgs
{
class SingleJointPositionGoal : public ros::Msg
{
public:
typedef double _position_type;
_position_type position;
typedef ros::Duration _min_duration_type;
_min_duration_type min_duration;
typedef double _max_velocity_type;
_max_velocity_type max_velocity;
SingleJointPositionGoal():
position(0),
min_duration(),
max_velocity(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
*(outbuffer + offset + 0) = (this->min_duration.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_duration.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_duration.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_duration.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_duration.sec);
*(outbuffer + offset + 0) = (this->min_duration.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_duration.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_duration.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_duration.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_duration.nsec);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.real = this->max_velocity;
*(outbuffer + offset + 0) = (u_max_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_velocity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_velocity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_velocity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_velocity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_velocity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_velocity);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
this->min_duration.sec = ((uint32_t) (*(inbuffer + offset)));
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_duration.sec);
this->min_duration.nsec = ((uint32_t) (*(inbuffer + offset)));
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_duration.nsec);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.base = 0;
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_velocity = u_max_velocity.real;
offset += sizeof(this->max_velocity);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionGoal"; };
const char * getMD5(){ return "fbaaa562a23a013fd5053e5f72cbb35c"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryResult.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryResult_h
#define _ROS_control_msgs_FollowJointTrajectoryResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class FollowJointTrajectoryResult : public ros::Msg
{
public:
typedef int32_t _error_code_type;
_error_code_type error_code;
typedef const char* _error_string_type;
_error_string_type error_string;
enum { SUCCESSFUL = 0 };
enum { INVALID_GOAL = -1 };
enum { INVALID_JOINTS = -2 };
enum { OLD_HEADER_TIMESTAMP = -3 };
enum { PATH_TOLERANCE_VIOLATED = -4 };
enum { GOAL_TOLERANCE_VIOLATED = -5 };
FollowJointTrajectoryResult():
error_code(0),
error_string("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_error_code;
u_error_code.real = this->error_code;
*(outbuffer + offset + 0) = (u_error_code.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error_code.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error_code.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error_code.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->error_code);
uint32_t length_error_string = strlen(this->error_string);
varToArr(outbuffer + offset, length_error_string);
offset += 4;
memcpy(outbuffer + offset, this->error_string, length_error_string);
offset += length_error_string;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_error_code;
u_error_code.base = 0;
u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error_code.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->error_code = u_error_code.real;
offset += sizeof(this->error_code);
uint32_t length_error_string;
arrToVar(length_error_string, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_error_string; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_error_string-1]=0;
this->error_string = (char *)(inbuffer + offset-1);
offset += length_error_string;
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryResult"; };
const char * getMD5(){ return "493383b18409bfb604b4e26c676401d2"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointControllerState.h | #ifndef _ROS_control_msgs_JointControllerState_h
#define _ROS_control_msgs_JointControllerState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace control_msgs
{
class JointControllerState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef double _set_point_type;
_set_point_type set_point;
typedef double _process_value_type;
_process_value_type process_value;
typedef double _process_value_dot_type;
_process_value_dot_type process_value_dot;
typedef double _error_type;
_error_type error;
typedef double _time_step_type;
_time_step_type time_step;
typedef double _command_type;
_command_type command;
typedef double _p_type;
_p_type p;
typedef double _i_type;
_i_type i;
typedef double _d_type;
_d_type d;
typedef double _i_clamp_type;
_i_clamp_type i_clamp;
typedef bool _antiwindup_type;
_antiwindup_type antiwindup;
JointControllerState():
header(),
set_point(0),
process_value(0),
process_value_dot(0),
error(0),
time_step(0),
command(0),
p(0),
i(0),
d(0),
i_clamp(0),
antiwindup(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_set_point;
u_set_point.real = this->set_point;
*(outbuffer + offset + 0) = (u_set_point.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_set_point.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_set_point.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_set_point.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_set_point.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_set_point.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_set_point.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_set_point.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->set_point);
union {
double real;
uint64_t base;
} u_process_value;
u_process_value.real = this->process_value;
*(outbuffer + offset + 0) = (u_process_value.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_process_value.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_process_value.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_process_value.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_process_value.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_process_value.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_process_value.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_process_value.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->process_value);
union {
double real;
uint64_t base;
} u_process_value_dot;
u_process_value_dot.real = this->process_value_dot;
*(outbuffer + offset + 0) = (u_process_value_dot.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_process_value_dot.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_process_value_dot.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_process_value_dot.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_process_value_dot.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_process_value_dot.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_process_value_dot.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_process_value_dot.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->process_value_dot);
union {
double real;
uint64_t base;
} u_error;
u_error.real = this->error;
*(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_error.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_error.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_error.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_error.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_error.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_error.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_error.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->error);
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.real = this->time_step;
*(outbuffer + offset + 0) = (u_time_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_time_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_time_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_time_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_time_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->time_step);
union {
double real;
uint64_t base;
} u_command;
u_command.real = this->command;
*(outbuffer + offset + 0) = (u_command.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_command.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_command.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_command.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_command.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_command.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_command.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_command.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->command);
union {
double real;
uint64_t base;
} u_p;
u_p.real = this->p;
*(outbuffer + offset + 0) = (u_p.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_p.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_p.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_p.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_p.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_p.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_p.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_p.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->p);
union {
double real;
uint64_t base;
} u_i;
u_i.real = this->i;
*(outbuffer + offset + 0) = (u_i.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i);
union {
double real;
uint64_t base;
} u_d;
u_d.real = this->d;
*(outbuffer + offset + 0) = (u_d.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_d.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_d.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_d.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_d.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_d.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_d.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_d.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->d);
union {
double real;
uint64_t base;
} u_i_clamp;
u_i_clamp.real = this->i_clamp;
*(outbuffer + offset + 0) = (u_i_clamp.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_i_clamp.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_i_clamp.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_i_clamp.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_i_clamp.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_i_clamp.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_i_clamp.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_i_clamp.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->i_clamp);
union {
bool real;
uint8_t base;
} u_antiwindup;
u_antiwindup.real = this->antiwindup;
*(outbuffer + offset + 0) = (u_antiwindup.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->antiwindup);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_set_point;
u_set_point.base = 0;
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_set_point.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->set_point = u_set_point.real;
offset += sizeof(this->set_point);
union {
double real;
uint64_t base;
} u_process_value;
u_process_value.base = 0;
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_process_value.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->process_value = u_process_value.real;
offset += sizeof(this->process_value);
union {
double real;
uint64_t base;
} u_process_value_dot;
u_process_value_dot.base = 0;
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_process_value_dot.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->process_value_dot = u_process_value_dot.real;
offset += sizeof(this->process_value_dot);
union {
double real;
uint64_t base;
} u_error;
u_error.base = 0;
u_error.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_error.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->error = u_error.real;
offset += sizeof(this->error);
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.base = 0;
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->time_step = u_time_step.real;
offset += sizeof(this->time_step);
union {
double real;
uint64_t base;
} u_command;
u_command.base = 0;
u_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->command = u_command.real;
offset += sizeof(this->command);
union {
double real;
uint64_t base;
} u_p;
u_p.base = 0;
u_p.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_p.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->p = u_p.real;
offset += sizeof(this->p);
union {
double real;
uint64_t base;
} u_i;
u_i.base = 0;
u_i.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i = u_i.real;
offset += sizeof(this->i);
union {
double real;
uint64_t base;
} u_d;
u_d.base = 0;
u_d.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_d.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->d = u_d.real;
offset += sizeof(this->d);
union {
double real;
uint64_t base;
} u_i_clamp;
u_i_clamp.base = 0;
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_i_clamp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->i_clamp = u_i_clamp.real;
offset += sizeof(this->i_clamp);
union {
bool real;
uint8_t base;
} u_antiwindup;
u_antiwindup.base = 0;
u_antiwindup.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->antiwindup = u_antiwindup.real;
offset += sizeof(this->antiwindup);
return offset;
}
const char * getType(){ return "control_msgs/JointControllerState"; };
const char * getMD5(){ return "987ad85e4756f3aef7f1e5e7fe0595d1"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadAction.h | #ifndef _ROS_control_msgs_PointHeadAction_h
#define _ROS_control_msgs_PointHeadAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/PointHeadActionGoal.h"
#include "control_msgs/PointHeadActionResult.h"
#include "control_msgs/PointHeadActionFeedback.h"
namespace control_msgs
{
class PointHeadAction : public ros::Msg
{
public:
typedef control_msgs::PointHeadActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::PointHeadActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::PointHeadActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
PointHeadAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadAction"; };
const char * getMD5(){ return "7252920f1243de1b741f14f214125371"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandGoal.h | #ifndef _ROS_control_msgs_GripperCommandGoal_h
#define _ROS_control_msgs_GripperCommandGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/GripperCommand.h"
namespace control_msgs
{
class GripperCommandGoal : public ros::Msg
{
public:
typedef control_msgs::GripperCommand _command_type;
_command_type command;
GripperCommandGoal():
command()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->command.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->command.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandGoal"; };
const char * getMD5(){ return "86fd82f4ddc48a4cb6856cfa69217e43"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryAction.h | #ifndef _ROS_control_msgs_JointTrajectoryAction_h
#define _ROS_control_msgs_JointTrajectoryAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/JointTrajectoryActionGoal.h"
#include "control_msgs/JointTrajectoryActionResult.h"
#include "control_msgs/JointTrajectoryActionFeedback.h"
namespace control_msgs
{
class JointTrajectoryAction : public ros::Msg
{
public:
typedef control_msgs::JointTrajectoryActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::JointTrajectoryActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::JointTrajectoryActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
JointTrajectoryAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryAction"; };
const char * getMD5(){ return "a04ba3ee8f6a2d0985a6aeaf23d9d7ad"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadGoal.h | #ifndef _ROS_control_msgs_PointHeadGoal_h
#define _ROS_control_msgs_PointHeadGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PointStamped.h"
#include "geometry_msgs/Vector3.h"
#include "ros/duration.h"
namespace control_msgs
{
class PointHeadGoal : public ros::Msg
{
public:
typedef geometry_msgs::PointStamped _target_type;
_target_type target;
typedef geometry_msgs::Vector3 _pointing_axis_type;
_pointing_axis_type pointing_axis;
typedef const char* _pointing_frame_type;
_pointing_frame_type pointing_frame;
typedef ros::Duration _min_duration_type;
_min_duration_type min_duration;
typedef double _max_velocity_type;
_max_velocity_type max_velocity;
PointHeadGoal():
target(),
pointing_axis(),
pointing_frame(""),
min_duration(),
max_velocity(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->target.serialize(outbuffer + offset);
offset += this->pointing_axis.serialize(outbuffer + offset);
uint32_t length_pointing_frame = strlen(this->pointing_frame);
varToArr(outbuffer + offset, length_pointing_frame);
offset += 4;
memcpy(outbuffer + offset, this->pointing_frame, length_pointing_frame);
offset += length_pointing_frame;
*(outbuffer + offset + 0) = (this->min_duration.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_duration.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_duration.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_duration.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_duration.sec);
*(outbuffer + offset + 0) = (this->min_duration.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->min_duration.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->min_duration.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->min_duration.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_duration.nsec);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.real = this->max_velocity;
*(outbuffer + offset + 0) = (u_max_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_velocity.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_velocity.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_velocity.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_velocity.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_velocity.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_velocity);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->target.deserialize(inbuffer + offset);
offset += this->pointing_axis.deserialize(inbuffer + offset);
uint32_t length_pointing_frame;
arrToVar(length_pointing_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_pointing_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_pointing_frame-1]=0;
this->pointing_frame = (char *)(inbuffer + offset-1);
offset += length_pointing_frame;
this->min_duration.sec = ((uint32_t) (*(inbuffer + offset)));
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->min_duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_duration.sec);
this->min_duration.nsec = ((uint32_t) (*(inbuffer + offset)));
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->min_duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->min_duration.nsec);
union {
double real;
uint64_t base;
} u_max_velocity;
u_max_velocity.base = 0;
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_velocity.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_velocity = u_max_velocity.real;
offset += sizeof(this->max_velocity);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadGoal"; };
const char * getMD5(){ return "8b92b1cd5e06c8a94c917dc3209a4c1d"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadResult.h | #ifndef _ROS_control_msgs_PointHeadResult_h
#define _ROS_control_msgs_PointHeadResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class PointHeadResult : public ros::Msg
{
public:
PointHeadResult()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "control_msgs/PointHeadResult"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryActionResult.h | #ifndef _ROS_control_msgs_JointTrajectoryActionResult_h
#define _ROS_control_msgs_JointTrajectoryActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/JointTrajectoryResult.h"
namespace control_msgs
{
class JointTrajectoryActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::JointTrajectoryResult _result_type;
_result_type result;
JointTrajectoryActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryActionResult"; };
const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionActionFeedback.h | #ifndef _ROS_control_msgs_SingleJointPositionActionFeedback_h
#define _ROS_control_msgs_SingleJointPositionActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/SingleJointPositionFeedback.h"
namespace control_msgs
{
class SingleJointPositionActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::SingleJointPositionFeedback _feedback_type;
_feedback_type feedback;
SingleJointPositionActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionActionFeedback"; };
const char * getMD5(){ return "3503b7cf8972f90d245850a5d8796cfa"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandAction.h | #ifndef _ROS_control_msgs_GripperCommandAction_h
#define _ROS_control_msgs_GripperCommandAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "control_msgs/GripperCommandActionGoal.h"
#include "control_msgs/GripperCommandActionResult.h"
#include "control_msgs/GripperCommandActionFeedback.h"
namespace control_msgs
{
class GripperCommandAction : public ros::Msg
{
public:
typedef control_msgs::GripperCommandActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef control_msgs::GripperCommandActionResult _action_result_type;
_action_result_type action_result;
typedef control_msgs::GripperCommandActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
GripperCommandAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandAction"; };
const char * getMD5(){ return "950b2a6ebe831f5d4f4ceaba3d8be01e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryResult.h | #ifndef _ROS_control_msgs_JointTrajectoryResult_h
#define _ROS_control_msgs_JointTrajectoryResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class JointTrajectoryResult : public ros::Msg
{
public:
JointTrajectoryResult()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryResult"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryActionFeedback.h | #ifndef _ROS_control_msgs_JointTrajectoryActionFeedback_h
#define _ROS_control_msgs_JointTrajectoryActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/JointTrajectoryFeedback.h"
namespace control_msgs
{
class JointTrajectoryActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::JointTrajectoryFeedback _feedback_type;
_feedback_type feedback;
JointTrajectoryActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/JointTrajectoryFeedback.h | #ifndef _ROS_control_msgs_JointTrajectoryFeedback_h
#define _ROS_control_msgs_JointTrajectoryFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class JointTrajectoryFeedback : public ros::Msg
{
public:
JointTrajectoryFeedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "control_msgs/JointTrajectoryFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandActionGoal.h | #ifndef _ROS_control_msgs_GripperCommandActionGoal_h
#define _ROS_control_msgs_GripperCommandActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "control_msgs/GripperCommandGoal.h"
namespace control_msgs
{
class GripperCommandActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef control_msgs::GripperCommandGoal _goal_type;
_goal_type goal;
GripperCommandActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandActionGoal"; };
const char * getMD5(){ return "aa581f648a35ed681db2ec0bf7a82bea"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/SingleJointPositionResult.h | #ifndef _ROS_control_msgs_SingleJointPositionResult_h
#define _ROS_control_msgs_SingleJointPositionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class SingleJointPositionResult : public ros::Msg
{
public:
SingleJointPositionResult()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return "control_msgs/SingleJointPositionResult"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommand.h | #ifndef _ROS_control_msgs_GripperCommand_h
#define _ROS_control_msgs_GripperCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_msgs
{
class GripperCommand : public ros::Msg
{
public:
typedef double _position_type;
_position_type position;
typedef double _max_effort_type;
_max_effort_type max_effort;
GripperCommand():
position(0),
max_effort(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.real = this->position;
*(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_max_effort;
u_max_effort.real = this->max_effort;
*(outbuffer + offset + 0) = (u_max_effort.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_effort.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_effort.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_effort.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_effort.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_effort.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_effort.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_effort.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_effort);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->position = u_position.real;
offset += sizeof(this->position);
union {
double real;
uint64_t base;
} u_max_effort;
u_max_effort.base = 0;
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_effort = u_max_effort.real;
offset += sizeof(this->max_effort);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommand"; };
const char * getMD5(){ return "680acaff79486f017132a7f198d40f08"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryFeedback.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryFeedback_h
#define _ROS_control_msgs_FollowJointTrajectoryFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "trajectory_msgs/JointTrajectoryPoint.h"
namespace control_msgs
{
class FollowJointTrajectoryFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
typedef trajectory_msgs::JointTrajectoryPoint _desired_type;
_desired_type desired;
typedef trajectory_msgs::JointTrajectoryPoint _actual_type;
_actual_type actual;
typedef trajectory_msgs::JointTrajectoryPoint _error_type;
_error_type error;
FollowJointTrajectoryFeedback():
header(),
joint_names_length(0), joint_names(NULL),
desired(),
actual(),
error()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
offset += this->desired.serialize(outbuffer + offset);
offset += this->actual.serialize(outbuffer + offset);
offset += this->error.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
offset += this->desired.deserialize(inbuffer + offset);
offset += this->actual.deserialize(inbuffer + offset);
offset += this->error.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryFeedback"; };
const char * getMD5(){ return "10817c60c2486ef6b33e97dcd87f4474"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/GripperCommandActionResult.h | #ifndef _ROS_control_msgs_GripperCommandActionResult_h
#define _ROS_control_msgs_GripperCommandActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/GripperCommandResult.h"
namespace control_msgs
{
class GripperCommandActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::GripperCommandResult _result_type;
_result_type result;
GripperCommandActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/GripperCommandActionResult"; };
const char * getMD5(){ return "143702cb2df0f163c5283cedc5efc6b6"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/PointHeadActionResult.h | #ifndef _ROS_control_msgs_PointHeadActionResult_h
#define _ROS_control_msgs_PointHeadActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/PointHeadResult.h"
namespace control_msgs
{
class PointHeadActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::PointHeadResult _result_type;
_result_type result;
PointHeadActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/PointHeadActionResult"; };
const char * getMD5(){ return "1eb06eeff08fa7ea874431638cb52332"; };
};
}
#endif
|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_msgs/FollowJointTrajectoryActionFeedback.h | #ifndef _ROS_control_msgs_FollowJointTrajectoryActionFeedback_h
#define _ROS_control_msgs_FollowJointTrajectoryActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "control_msgs/FollowJointTrajectoryFeedback.h"
namespace control_msgs
{
class FollowJointTrajectoryActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef control_msgs::FollowJointTrajectoryFeedback _feedback_type;
_feedback_type feedback;
FollowJointTrajectoryActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "control_msgs/FollowJointTrajectoryActionFeedback"; };
const char * getMD5(){ return "d8920dc4eae9fc107e00999cce4be641"; };
};
}
#endif
|
Subsets and Splits