file_path
stringlengths 21
207
| content
stringlengths 5
1.02M
| size
int64 5
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/DigitalIOStates.h | #ifndef _ROS_baxter_core_msgs_DigitalIOStates_h
#define _ROS_baxter_core_msgs_DigitalIOStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/DigitalIOState.h"
namespace baxter_core_msgs
{
class DigitalIOStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::DigitalIOState _states_type;
_states_type st_states;
_states_type * states;
DigitalIOStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(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;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
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 = (baxter_core_msgs::DigitalIOState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::DigitalIOState));
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(baxter_core_msgs::DigitalIOState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/DigitalIOStates"; };
const char * getMD5(){ return "d434210c6ec20947fec667d6c13d6062"; };
};
}
#endif
| 3,926 | C | 37.5 | 139 | 0.581508 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/HeadState.h | #ifndef _ROS_baxter_core_msgs_HeadState_h
#define _ROS_baxter_core_msgs_HeadState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class HeadState : public ros::Msg
{
public:
typedef float _pan_type;
_pan_type pan;
typedef bool _isTurning_type;
_isTurning_type isTurning;
typedef bool _isNodding_type;
_isNodding_type isNodding;
typedef bool _isPanEnabled_type;
_isPanEnabled_type isPanEnabled;
HeadState():
pan(0),
isTurning(0),
isNodding(0),
isPanEnabled(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_pan;
u_pan.real = this->pan;
*(outbuffer + offset + 0) = (u_pan.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_pan.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_pan.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_pan.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->pan);
union {
bool real;
uint8_t base;
} u_isTurning;
u_isTurning.real = this->isTurning;
*(outbuffer + offset + 0) = (u_isTurning.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isTurning);
union {
bool real;
uint8_t base;
} u_isNodding;
u_isNodding.real = this->isNodding;
*(outbuffer + offset + 0) = (u_isNodding.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isNodding);
union {
bool real;
uint8_t base;
} u_isPanEnabled;
u_isPanEnabled.real = this->isPanEnabled;
*(outbuffer + offset + 0) = (u_isPanEnabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isPanEnabled);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_pan;
u_pan.base = 0;
u_pan.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_pan.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_pan.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_pan.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->pan = u_pan.real;
offset += sizeof(this->pan);
union {
bool real;
uint8_t base;
} u_isTurning;
u_isTurning.base = 0;
u_isTurning.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isTurning = u_isTurning.real;
offset += sizeof(this->isTurning);
union {
bool real;
uint8_t base;
} u_isNodding;
u_isNodding.base = 0;
u_isNodding.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isNodding = u_isNodding.real;
offset += sizeof(this->isNodding);
union {
bool real;
uint8_t base;
} u_isPanEnabled;
u_isPanEnabled.base = 0;
u_isPanEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isPanEnabled = u_isPanEnabled.real;
offset += sizeof(this->isPanEnabled);
return offset;
}
const char * getType(){ return "baxter_core_msgs/HeadState"; };
const char * getMD5(){ return "71c43b264307205358e7e49be5601348"; };
};
}
#endif
| 3,369 | C | 27.803419 | 79 | 0.540813 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AnalogIOStates.h | #ifndef _ROS_baxter_core_msgs_AnalogIOStates_h
#define _ROS_baxter_core_msgs_AnalogIOStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/AnalogIOState.h"
namespace baxter_core_msgs
{
class AnalogIOStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::AnalogIOState _states_type;
_states_type st_states;
_states_type * states;
AnalogIOStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(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;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
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 = (baxter_core_msgs::AnalogIOState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::AnalogIOState));
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(baxter_core_msgs::AnalogIOState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/AnalogIOStates"; };
const char * getMD5(){ return "0a05ba3bbb53a8a3b164e34946d619f7"; };
};
}
#endif
| 3,916 | C | 37.40196 | 137 | 0.580439 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/ListCameras.h | #ifndef _ROS_SERVICE_ListCameras_h
#define _ROS_SERVICE_ListCameras_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
static const char LISTCAMERAS[] = "baxter_core_msgs/ListCameras";
class ListCamerasRequest : public ros::Msg
{
public:
ListCamerasRequest()
{
}
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 LISTCAMERAS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class ListCamerasResponse : public ros::Msg
{
public:
uint32_t cameras_length;
typedef char* _cameras_type;
_cameras_type st_cameras;
_cameras_type * cameras;
ListCamerasResponse():
cameras_length(0), cameras(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->cameras_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cameras_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cameras_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cameras_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cameras_length);
for( uint32_t i = 0; i < cameras_length; i++){
uint32_t length_camerasi = strlen(this->cameras[i]);
varToArr(outbuffer + offset, length_camerasi);
offset += 4;
memcpy(outbuffer + offset, this->cameras[i], length_camerasi);
offset += length_camerasi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t cameras_lengthT = ((uint32_t) (*(inbuffer + offset)));
cameras_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cameras_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cameras_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cameras_length);
if(cameras_lengthT > cameras_length)
this->cameras = (char**)realloc(this->cameras, cameras_lengthT * sizeof(char*));
cameras_length = cameras_lengthT;
for( uint32_t i = 0; i < cameras_length; i++){
uint32_t length_st_cameras;
arrToVar(length_st_cameras, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_cameras; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_cameras-1]=0;
this->st_cameras = (char *)(inbuffer + offset-1);
offset += length_st_cameras;
memcpy( &(this->cameras[i]), &(this->st_cameras), sizeof(char*));
}
return offset;
}
const char * getType(){ return LISTCAMERAS; };
const char * getMD5(){ return "855b31192ab61744e7deb992d94db7ff"; };
};
class ListCameras {
public:
typedef ListCamerasRequest Request;
typedef ListCamerasResponse Response;
};
}
#endif
| 3,119 | C | 27.888889 | 88 | 0.601795 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CameraSettings.h | #ifndef _ROS_baxter_core_msgs_CameraSettings_h
#define _ROS_baxter_core_msgs_CameraSettings_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/CameraControl.h"
namespace baxter_core_msgs
{
class CameraSettings : public ros::Msg
{
public:
typedef int32_t _width_type;
_width_type width;
typedef int32_t _height_type;
_height_type height;
typedef float _fps_type;
_fps_type fps;
uint32_t controls_length;
typedef baxter_core_msgs::CameraControl _controls_type;
_controls_type st_controls;
_controls_type * controls;
CameraSettings():
width(0),
height(0),
fps(0),
controls_length(0), controls(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_width;
u_width.real = this->width;
*(outbuffer + offset + 0) = (u_width.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_width.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_width.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_width.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
union {
int32_t real;
uint32_t base;
} u_height;
u_height.real = this->height;
*(outbuffer + offset + 0) = (u_height.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_height.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_height.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_height.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
union {
float real;
uint32_t base;
} u_fps;
u_fps.real = this->fps;
*(outbuffer + offset + 0) = (u_fps.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fps.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fps.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fps.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fps);
*(outbuffer + offset + 0) = (this->controls_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->controls_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->controls_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->controls_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->controls_length);
for( uint32_t i = 0; i < controls_length; i++){
offset += this->controls[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_width;
u_width.base = 0;
u_width.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_width.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_width.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_width.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->width = u_width.real;
offset += sizeof(this->width);
union {
int32_t real;
uint32_t base;
} u_height;
u_height.base = 0;
u_height.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_height.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_height.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_height.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->height = u_height.real;
offset += sizeof(this->height);
union {
float real;
uint32_t base;
} u_fps;
u_fps.base = 0;
u_fps.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fps.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fps.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fps.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fps = u_fps.real;
offset += sizeof(this->fps);
uint32_t controls_lengthT = ((uint32_t) (*(inbuffer + offset)));
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->controls_length);
if(controls_lengthT > controls_length)
this->controls = (baxter_core_msgs::CameraControl*)realloc(this->controls, controls_lengthT * sizeof(baxter_core_msgs::CameraControl));
controls_length = controls_lengthT;
for( uint32_t i = 0; i < controls_length; i++){
offset += this->st_controls.deserialize(inbuffer + offset);
memcpy( &(this->controls[i]), &(this->st_controls), sizeof(baxter_core_msgs::CameraControl));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/CameraSettings"; };
const char * getMD5(){ return "d133bef4a3bd9a6e490a5dc91d20f429"; };
};
}
#endif
| 5,088 | C | 36.145985 | 143 | 0.536557 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/NavigatorState.h | #ifndef _ROS_baxter_core_msgs_NavigatorState_h
#define _ROS_baxter_core_msgs_NavigatorState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class NavigatorState : public ros::Msg
{
public:
uint32_t button_names_length;
typedef char* _button_names_type;
_button_names_type st_button_names;
_button_names_type * button_names;
uint32_t buttons_length;
typedef bool _buttons_type;
_buttons_type st_buttons;
_buttons_type * buttons;
typedef uint8_t _wheel_type;
_wheel_type wheel;
uint32_t light_names_length;
typedef char* _light_names_type;
_light_names_type st_light_names;
_light_names_type * light_names;
uint32_t lights_length;
typedef bool _lights_type;
_lights_type st_lights;
_lights_type * lights;
NavigatorState():
button_names_length(0), button_names(NULL),
buttons_length(0), buttons(NULL),
wheel(0),
light_names_length(0), light_names(NULL),
lights_length(0), lights(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->button_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->button_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->button_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->button_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->button_names_length);
for( uint32_t i = 0; i < button_names_length; i++){
uint32_t length_button_namesi = strlen(this->button_names[i]);
varToArr(outbuffer + offset, length_button_namesi);
offset += 4;
memcpy(outbuffer + offset, this->button_names[i], length_button_namesi);
offset += length_button_namesi;
}
*(outbuffer + offset + 0) = (this->buttons_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->buttons_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->buttons_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->buttons_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->buttons_length);
for( uint32_t i = 0; i < buttons_length; i++){
union {
bool real;
uint8_t base;
} u_buttonsi;
u_buttonsi.real = this->buttons[i];
*(outbuffer + offset + 0) = (u_buttonsi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->buttons[i]);
}
*(outbuffer + offset + 0) = (this->wheel >> (8 * 0)) & 0xFF;
offset += sizeof(this->wheel);
*(outbuffer + offset + 0) = (this->light_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->light_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->light_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->light_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->light_names_length);
for( uint32_t i = 0; i < light_names_length; i++){
uint32_t length_light_namesi = strlen(this->light_names[i]);
varToArr(outbuffer + offset, length_light_namesi);
offset += 4;
memcpy(outbuffer + offset, this->light_names[i], length_light_namesi);
offset += length_light_namesi;
}
*(outbuffer + offset + 0) = (this->lights_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lights_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lights_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lights_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->lights_length);
for( uint32_t i = 0; i < lights_length; i++){
union {
bool real;
uint8_t base;
} u_lightsi;
u_lightsi.real = this->lights[i];
*(outbuffer + offset + 0) = (u_lightsi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->lights[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t button_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
button_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
button_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
button_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->button_names_length);
if(button_names_lengthT > button_names_length)
this->button_names = (char**)realloc(this->button_names, button_names_lengthT * sizeof(char*));
button_names_length = button_names_lengthT;
for( uint32_t i = 0; i < button_names_length; i++){
uint32_t length_st_button_names;
arrToVar(length_st_button_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_button_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_button_names-1]=0;
this->st_button_names = (char *)(inbuffer + offset-1);
offset += length_st_button_names;
memcpy( &(this->button_names[i]), &(this->st_button_names), sizeof(char*));
}
uint32_t buttons_lengthT = ((uint32_t) (*(inbuffer + offset)));
buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->buttons_length);
if(buttons_lengthT > buttons_length)
this->buttons = (bool*)realloc(this->buttons, buttons_lengthT * sizeof(bool));
buttons_length = buttons_lengthT;
for( uint32_t i = 0; i < buttons_length; i++){
union {
bool real;
uint8_t base;
} u_st_buttons;
u_st_buttons.base = 0;
u_st_buttons.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_buttons = u_st_buttons.real;
offset += sizeof(this->st_buttons);
memcpy( &(this->buttons[i]), &(this->st_buttons), sizeof(bool));
}
this->wheel = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->wheel);
uint32_t light_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
light_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
light_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
light_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->light_names_length);
if(light_names_lengthT > light_names_length)
this->light_names = (char**)realloc(this->light_names, light_names_lengthT * sizeof(char*));
light_names_length = light_names_lengthT;
for( uint32_t i = 0; i < light_names_length; i++){
uint32_t length_st_light_names;
arrToVar(length_st_light_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_light_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_light_names-1]=0;
this->st_light_names = (char *)(inbuffer + offset-1);
offset += length_st_light_names;
memcpy( &(this->light_names[i]), &(this->st_light_names), sizeof(char*));
}
uint32_t lights_lengthT = ((uint32_t) (*(inbuffer + offset)));
lights_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
lights_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
lights_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lights_length);
if(lights_lengthT > lights_length)
this->lights = (bool*)realloc(this->lights, lights_lengthT * sizeof(bool));
lights_length = lights_lengthT;
for( uint32_t i = 0; i < lights_length; i++){
union {
bool real;
uint8_t base;
} u_st_lights;
u_st_lights.base = 0;
u_st_lights.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_lights = u_st_lights.real;
offset += sizeof(this->st_lights);
memcpy( &(this->lights[i]), &(this->st_lights), sizeof(bool));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/NavigatorState"; };
const char * getMD5(){ return "680d121a1f16a32647298b292492fffd"; };
};
}
#endif
| 8,416 | C | 41.943877 | 103 | 0.570223 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AnalogIOState.h | #ifndef _ROS_baxter_core_msgs_AnalogIOState_h
#define _ROS_baxter_core_msgs_AnalogIOState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace baxter_core_msgs
{
class AnalogIOState : public ros::Msg
{
public:
typedef ros::Time _timestamp_type;
_timestamp_type timestamp;
typedef double _value_type;
_value_type value;
typedef bool _isInputOnly_type;
_isInputOnly_type isInputOnly;
AnalogIOState():
timestamp(),
value(0),
isInputOnly(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->timestamp.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestamp.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestamp.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestamp.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestamp.sec);
*(outbuffer + offset + 0) = (this->timestamp.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestamp.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestamp.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestamp.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestamp.nsec);
union {
double real;
uint64_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;
*(outbuffer + offset + 4) = (u_value.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_value.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_value.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_value.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->value);
union {
bool real;
uint8_t base;
} u_isInputOnly;
u_isInputOnly.real = this->isInputOnly;
*(outbuffer + offset + 0) = (u_isInputOnly.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isInputOnly);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->timestamp.sec = ((uint32_t) (*(inbuffer + offset)));
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestamp.sec);
this->timestamp.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestamp.nsec);
union {
double real;
uint64_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_value.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->value = u_value.real;
offset += sizeof(this->value);
union {
bool real;
uint8_t base;
} u_isInputOnly;
u_isInputOnly.base = 0;
u_isInputOnly.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isInputOnly = u_isInputOnly.real;
offset += sizeof(this->isInputOnly);
return offset;
}
const char * getType(){ return "baxter_core_msgs/AnalogIOState"; };
const char * getMD5(){ return "39af371963dc9e4447e91f430c720b33"; };
};
}
#endif
| 4,342 | C | 37.433628 | 81 | 0.534546 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorState.h | #ifndef _ROS_baxter_core_msgs_EndEffectorState_h
#define _ROS_baxter_core_msgs_EndEffectorState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace baxter_core_msgs
{
class EndEffectorState : public ros::Msg
{
public:
typedef ros::Time _timestamp_type;
_timestamp_type timestamp;
typedef uint32_t _id_type;
_id_type id;
typedef uint8_t _enabled_type;
_enabled_type enabled;
typedef uint8_t _calibrated_type;
_calibrated_type calibrated;
typedef uint8_t _ready_type;
_ready_type ready;
typedef uint8_t _moving_type;
_moving_type moving;
typedef uint8_t _gripping_type;
_gripping_type gripping;
typedef uint8_t _missed_type;
_missed_type missed;
typedef uint8_t _error_type;
_error_type error;
typedef uint8_t _reverse_type;
_reverse_type reverse;
typedef float _position_type;
_position_type position;
typedef float _force_type;
_force_type force;
typedef const char* _state_type;
_state_type state;
typedef const char* _command_type;
_command_type command;
typedef const char* _command_sender_type;
_command_sender_type command_sender;
typedef uint32_t _command_sequence_type;
_command_sequence_type command_sequence;
enum { STATE_FALSE = 0 };
enum { STATE_TRUE = 1 };
enum { STATE_UNKNOWN = 2 };
enum { POSITION_CLOSED = 0.0 };
enum { POSITION_OPEN = 100.0 };
enum { FORCE_MIN = 0.0 };
enum { FORCE_MAX = 100.0 };
EndEffectorState():
timestamp(),
id(0),
enabled(0),
calibrated(0),
ready(0),
moving(0),
gripping(0),
missed(0),
error(0),
reverse(0),
position(0),
force(0),
state(""),
command(""),
command_sender(""),
command_sequence(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->timestamp.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestamp.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestamp.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestamp.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestamp.sec);
*(outbuffer + offset + 0) = (this->timestamp.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timestamp.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timestamp.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timestamp.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timestamp.nsec);
*(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->enabled >> (8 * 0)) & 0xFF;
offset += sizeof(this->enabled);
*(outbuffer + offset + 0) = (this->calibrated >> (8 * 0)) & 0xFF;
offset += sizeof(this->calibrated);
*(outbuffer + offset + 0) = (this->ready >> (8 * 0)) & 0xFF;
offset += sizeof(this->ready);
*(outbuffer + offset + 0) = (this->moving >> (8 * 0)) & 0xFF;
offset += sizeof(this->moving);
*(outbuffer + offset + 0) = (this->gripping >> (8 * 0)) & 0xFF;
offset += sizeof(this->gripping);
*(outbuffer + offset + 0) = (this->missed >> (8 * 0)) & 0xFF;
offset += sizeof(this->missed);
*(outbuffer + offset + 0) = (this->error >> (8 * 0)) & 0xFF;
offset += sizeof(this->error);
*(outbuffer + offset + 0) = (this->reverse >> (8 * 0)) & 0xFF;
offset += sizeof(this->reverse);
union {
float real;
uint32_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;
offset += sizeof(this->position);
union {
float real;
uint32_t base;
} u_force;
u_force.real = this->force;
*(outbuffer + offset + 0) = (u_force.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_force.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_force.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_force.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->force);
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
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_command_sender = strlen(this->command_sender);
varToArr(outbuffer + offset, length_command_sender);
offset += 4;
memcpy(outbuffer + offset, this->command_sender, length_command_sender);
offset += length_command_sender;
*(outbuffer + offset + 0) = (this->command_sequence >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->command_sequence >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->command_sequence >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->command_sequence >> (8 * 3)) & 0xFF;
offset += sizeof(this->command_sequence);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->timestamp.sec = ((uint32_t) (*(inbuffer + offset)));
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestamp.sec);
this->timestamp.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timestamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timestamp.nsec);
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->enabled = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->enabled);
this->calibrated = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->calibrated);
this->ready = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->ready);
this->moving = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->moving);
this->gripping = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->gripping);
this->missed = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->missed);
this->error = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->error);
this->reverse = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->reverse);
union {
float real;
uint32_t base;
} u_position;
u_position.base = 0;
u_position.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_position.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_position.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_position.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->position = u_position.real;
offset += sizeof(this->position);
union {
float real;
uint32_t base;
} u_force;
u_force.base = 0;
u_force.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_force.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_force.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_force.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->force = u_force.real;
offset += sizeof(this->force);
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
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_command_sender;
arrToVar(length_command_sender, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_command_sender; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_command_sender-1]=0;
this->command_sender = (char *)(inbuffer + offset-1);
offset += length_command_sender;
this->command_sequence = ((uint32_t) (*(inbuffer + offset)));
this->command_sequence |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->command_sequence |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->command_sequence |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->command_sequence);
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndEffectorState"; };
const char * getMD5(){ return "ade777f069d738595bc19e246b8ec7a0"; };
};
}
#endif
| 10,287 | C | 39.988048 | 83 | 0.549723 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AnalogOutputCommand.h | #ifndef _ROS_baxter_core_msgs_AnalogOutputCommand_h
#define _ROS_baxter_core_msgs_AnalogOutputCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class AnalogOutputCommand : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef uint16_t _value_type;
_value_type value;
AnalogOutputCommand():
name(""),
value(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;
*(outbuffer + offset + 0) = (this->value >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->value >> (8 * 1)) & 0xFF;
offset += sizeof(this->value);
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;
this->value = ((uint16_t) (*(inbuffer + offset)));
this->value |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "baxter_core_msgs/AnalogOutputCommand"; };
const char * getMD5(){ return "a7b945129a083ca4095d48aa94841d85"; };
};
}
#endif
| 1,730 | C | 25.630769 | 77 | 0.59422 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CameraControl.h | #ifndef _ROS_baxter_core_msgs_CameraControl_h
#define _ROS_baxter_core_msgs_CameraControl_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class CameraControl : public ros::Msg
{
public:
typedef int32_t _id_type;
_id_type id;
typedef int32_t _value_type;
_value_type value;
enum { CAMERA_CONTROL_EXPOSURE = 100 };
enum { CAMERA_CONTROL_GAIN = 101 };
enum { CAMERA_CONTROL_WHITE_BALANCE_R = 102 };
enum { CAMERA_CONTROL_WHITE_BALANCE_G = 103 };
enum { CAMERA_CONTROL_WHITE_BALANCE_B = 104 };
enum { CAMERA_CONTROL_WINDOW_X = 105 };
enum { CAMERA_CONTROL_WINDOW_Y = 106 };
enum { CAMERA_CONTROL_FLIP = 107 };
enum { CAMERA_CONTROL_MIRROR = 108 };
enum { CAMERA_CONTROL_RESOLUTION_HALF = 109 };
CameraControl():
id(0),
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
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_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
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 "baxter_core_msgs/CameraControl"; };
const char * getMD5(){ return "01e38dd67dfb36af457f0915248629d1"; };
};
}
#endif
| 3,017 | C | 30.113402 | 73 | 0.526019 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorCommand.h | #ifndef _ROS_baxter_core_msgs_EndEffectorCommand_h
#define _ROS_baxter_core_msgs_EndEffectorCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class EndEffectorCommand : public ros::Msg
{
public:
typedef uint32_t _id_type;
_id_type id;
typedef const char* _command_type;
_command_type command;
typedef const char* _args_type;
_args_type args;
typedef const char* _sender_type;
_sender_type sender;
typedef uint32_t _sequence_type;
_sequence_type sequence;
enum { CMD_NO_OP = no_op };
enum { CMD_SET = set };
enum { CMD_CONFIGURE = configure };
enum { CMD_REBOOT = reboot };
enum { CMD_RESET = reset };
enum { CMD_CALIBRATE = calibrate };
enum { CMD_CLEAR_CALIBRATION = clear_calibration };
enum { CMD_PREPARE_TO_GRIP = prepare_to_grip };
enum { CMD_GRIP = grip };
enum { CMD_RELEASE = release };
enum { CMD_GO = go };
enum { CMD_STOP = stop };
EndEffectorCommand():
id(0),
command(""),
args(""),
sender(""),
sequence(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(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);
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_args = strlen(this->args);
varToArr(outbuffer + offset, length_args);
offset += 4;
memcpy(outbuffer + offset, this->args, length_args);
offset += length_args;
uint32_t length_sender = strlen(this->sender);
varToArr(outbuffer + offset, length_sender);
offset += 4;
memcpy(outbuffer + offset, this->sender, length_sender);
offset += length_sender;
*(outbuffer + offset + 0) = (this->sequence >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sequence >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sequence >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sequence >> (8 * 3)) & 0xFF;
offset += sizeof(this->sequence);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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);
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_args;
arrToVar(length_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_args-1]=0;
this->args = (char *)(inbuffer + offset-1);
offset += length_args;
uint32_t length_sender;
arrToVar(length_sender, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_sender; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_sender-1]=0;
this->sender = (char *)(inbuffer + offset-1);
offset += length_sender;
this->sequence = ((uint32_t) (*(inbuffer + offset)));
this->sequence |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->sequence |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->sequence |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sequence);
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndEffectorCommand"; };
const char * getMD5(){ return "c003234e90416f2ca02ac7837c42cbb7"; };
};
}
#endif
| 4,465 | C | 33.890625 | 76 | 0.56327 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndpointState.h | #ifndef _ROS_baxter_core_msgs_EndpointState_h
#define _ROS_baxter_core_msgs_EndpointState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
#include "geometry_msgs/Wrench.h"
namespace baxter_core_msgs
{
class EndpointState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
typedef geometry_msgs::Wrench _wrench_type;
_wrench_type wrench;
EndpointState():
header(),
pose(),
twist(),
wrench()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.serialize(outbuffer + offset);
offset += this->twist.serialize(outbuffer + offset);
offset += this->wrench.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->pose.deserialize(inbuffer + offset);
offset += this->twist.deserialize(inbuffer + offset);
offset += this->wrench.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndpointState"; };
const char * getMD5(){ return "44bea01d596ff699fa1447bec34167ac"; };
};
}
#endif
| 1,636 | C | 24.984127 | 72 | 0.648533 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/HeadPanCommand.h | #ifndef _ROS_baxter_core_msgs_HeadPanCommand_h
#define _ROS_baxter_core_msgs_HeadPanCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class HeadPanCommand : public ros::Msg
{
public:
typedef float _target_type;
_target_type target;
typedef float _speed_ratio_type;
_speed_ratio_type speed_ratio;
typedef uint8_t _enable_pan_request_type;
_enable_pan_request_type enable_pan_request;
enum { MAX_SPEED_RATIO = 1.0 };
enum { MIN_SPEED_RATIO = 0.0 };
enum { REQUEST_PAN_DISABLE = 0 };
enum { REQUEST_PAN_ENABLE = 1 };
enum { REQUEST_PAN_VOID = 2 };
HeadPanCommand():
target(0),
speed_ratio(0),
enable_pan_request(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_target;
u_target.real = this->target;
*(outbuffer + offset + 0) = (u_target.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_target.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_target.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_target.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->target);
union {
float real;
uint32_t base;
} u_speed_ratio;
u_speed_ratio.real = this->speed_ratio;
*(outbuffer + offset + 0) = (u_speed_ratio.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_speed_ratio.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_speed_ratio.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_speed_ratio.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->speed_ratio);
*(outbuffer + offset + 0) = (this->enable_pan_request >> (8 * 0)) & 0xFF;
offset += sizeof(this->enable_pan_request);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_target;
u_target.base = 0;
u_target.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_target.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_target.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_target.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->target = u_target.real;
offset += sizeof(this->target);
union {
float real;
uint32_t base;
} u_speed_ratio;
u_speed_ratio.base = 0;
u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_speed_ratio.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->speed_ratio = u_speed_ratio.real;
offset += sizeof(this->speed_ratio);
this->enable_pan_request = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->enable_pan_request);
return offset;
}
const char * getType(){ return "baxter_core_msgs/HeadPanCommand"; };
const char * getMD5(){ return "23b8a3f4b7ee9de7099d029e57660a8c"; };
};
}
#endif
| 3,317 | C | 32.515151 | 79 | 0.548086 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AssemblyStates.h | #ifndef _ROS_baxter_core_msgs_AssemblyStates_h
#define _ROS_baxter_core_msgs_AssemblyStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/AssemblyState.h"
namespace baxter_core_msgs
{
class AssemblyStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::AssemblyState _states_type;
_states_type st_states;
_states_type * states;
AssemblyStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(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;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
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 = (baxter_core_msgs::AssemblyState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::AssemblyState));
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(baxter_core_msgs::AssemblyState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/AssemblyStates"; };
const char * getMD5(){ return "63427318d41dbd2077c105027ad82a2b"; };
};
}
#endif
| 3,916 | C | 37.40196 | 137 | 0.580439 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/AssemblyState.h | #ifndef _ROS_baxter_core_msgs_AssemblyState_h
#define _ROS_baxter_core_msgs_AssemblyState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class AssemblyState : public ros::Msg
{
public:
typedef bool _ready_type;
_ready_type ready;
typedef bool _enabled_type;
_enabled_type enabled;
typedef bool _stopped_type;
_stopped_type stopped;
typedef bool _error_type;
_error_type error;
typedef uint8_t _estop_button_type;
_estop_button_type estop_button;
typedef uint8_t _estop_source_type;
_estop_source_type estop_source;
enum { ESTOP_BUTTON_UNPRESSED = 0 };
enum { ESTOP_BUTTON_PRESSED = 1 };
enum { ESTOP_BUTTON_UNKNOWN = 2 };
enum { ESTOP_BUTTON_RELEASED = 3 };
enum { ESTOP_SOURCE_NONE = 0 };
enum { ESTOP_SOURCE_USER = 1 };
enum { ESTOP_SOURCE_UNKNOWN = 2 };
enum { ESTOP_SOURCE_FAULT = 3 };
enum { ESTOP_SOURCE_BRAIN = 4 };
AssemblyState():
ready(0),
enabled(0),
stopped(0),
error(0),
estop_button(0),
estop_source(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_ready;
u_ready.real = this->ready;
*(outbuffer + offset + 0) = (u_ready.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->ready);
union {
bool real;
uint8_t base;
} u_enabled;
u_enabled.real = this->enabled;
*(outbuffer + offset + 0) = (u_enabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->enabled);
union {
bool real;
uint8_t base;
} u_stopped;
u_stopped.real = this->stopped;
*(outbuffer + offset + 0) = (u_stopped.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->stopped);
union {
bool real;
uint8_t base;
} u_error;
u_error.real = this->error;
*(outbuffer + offset + 0) = (u_error.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->error);
*(outbuffer + offset + 0) = (this->estop_button >> (8 * 0)) & 0xFF;
offset += sizeof(this->estop_button);
*(outbuffer + offset + 0) = (this->estop_source >> (8 * 0)) & 0xFF;
offset += sizeof(this->estop_source);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_ready;
u_ready.base = 0;
u_ready.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->ready = u_ready.real;
offset += sizeof(this->ready);
union {
bool real;
uint8_t base;
} u_enabled;
u_enabled.base = 0;
u_enabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->enabled = u_enabled.real;
offset += sizeof(this->enabled);
union {
bool real;
uint8_t base;
} u_stopped;
u_stopped.base = 0;
u_stopped.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->stopped = u_stopped.real;
offset += sizeof(this->stopped);
union {
bool real;
uint8_t base;
} u_error;
u_error.base = 0;
u_error.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->error = u_error.real;
offset += sizeof(this->error);
this->estop_button = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->estop_button);
this->estop_source = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->estop_source);
return offset;
}
const char * getType(){ return "baxter_core_msgs/AssemblyState"; };
const char * getMD5(){ return "356d9dd237ce73b2667da9235f541933"; };
};
}
#endif
| 3,889 | C | 28.029851 | 74 | 0.539727 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/JointCommand.h | #ifndef _ROS_baxter_core_msgs_JointCommand_h
#define _ROS_baxter_core_msgs_JointCommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class JointCommand : public ros::Msg
{
public:
typedef int32_t _mode_type;
_mode_type mode;
uint32_t command_length;
typedef double _command_type;
_command_type st_command;
_command_type * command;
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
enum { POSITION_MODE = 1 };
enum { VELOCITY_MODE = 2 };
enum { TORQUE_MODE = 3 };
enum { RAW_POSITION_MODE = 4 };
JointCommand():
mode(0),
command_length(0), command(NULL),
names_length(0), names(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_mode;
u_mode.real = this->mode;
*(outbuffer + offset + 0) = (u_mode.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mode.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mode.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mode.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->mode);
*(outbuffer + offset + 0) = (this->command_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->command_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->command_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->command_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->command_length);
for( uint32_t i = 0; i < command_length; i++){
union {
double real;
uint64_t base;
} u_commandi;
u_commandi.real = this->command[i];
*(outbuffer + offset + 0) = (u_commandi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_commandi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_commandi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_commandi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_commandi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_commandi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_commandi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_commandi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->command[i]);
}
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_mode;
u_mode.base = 0;
u_mode.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mode.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mode.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mode.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->mode = u_mode.real;
offset += sizeof(this->mode);
uint32_t command_lengthT = ((uint32_t) (*(inbuffer + offset)));
command_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
command_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
command_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->command_length);
if(command_lengthT > command_length)
this->command = (double*)realloc(this->command, command_lengthT * sizeof(double));
command_length = command_lengthT;
for( uint32_t i = 0; i < command_length; i++){
union {
double real;
uint64_t base;
} u_st_command;
u_st_command.base = 0;
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_command.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_command = u_st_command.real;
offset += sizeof(this->st_command);
memcpy( &(this->command[i]), &(this->st_command), sizeof(double));
}
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/JointCommand"; };
const char * getMD5(){ return "19bfec8434dd568ab3c633d187c36f2e"; };
};
}
#endif
| 6,300 | C | 39.391025 | 90 | 0.534762 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/OpenCamera.h | #ifndef _ROS_SERVICE_OpenCamera_h
#define _ROS_SERVICE_OpenCamera_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/CameraSettings.h"
namespace baxter_core_msgs
{
static const char OPENCAMERA[] = "baxter_core_msgs/OpenCamera";
class OpenCameraRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef baxter_core_msgs::CameraSettings _settings_type;
_settings_type settings;
OpenCameraRequest():
name(""),
settings()
{
}
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;
offset += this->settings.serialize(outbuffer + offset);
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;
offset += this->settings.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return OPENCAMERA; };
const char * getMD5(){ return "c4194eee32741c5a98ef8da9666fa6c9"; };
};
class OpenCameraResponse : public ros::Msg
{
public:
typedef int32_t _err_type;
_err_type err;
OpenCameraResponse():
err(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_err;
u_err.real = this->err;
*(outbuffer + offset + 0) = (u_err.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_err.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_err.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_err.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->err);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_err;
u_err.base = 0;
u_err.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_err.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->err = u_err.real;
offset += sizeof(this->err);
return offset;
}
const char * getType(){ return OPENCAMERA; };
const char * getMD5(){ return "b6e094011a4dfaee5eddf447220446cf"; };
};
class OpenCamera {
public:
typedef OpenCameraRequest Request;
typedef OpenCameraResponse Response;
};
}
#endif
| 3,083 | C | 25.135593 | 72 | 0.578008 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/NavigatorStates.h | #ifndef _ROS_baxter_core_msgs_NavigatorStates_h
#define _ROS_baxter_core_msgs_NavigatorStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_core_msgs/NavigatorState.h"
namespace baxter_core_msgs
{
class NavigatorStates : public ros::Msg
{
public:
uint32_t names_length;
typedef char* _names_type;
_names_type st_names;
_names_type * names;
uint32_t states_length;
typedef baxter_core_msgs::NavigatorState _states_type;
_states_type st_states;
_states_type * states;
NavigatorStates():
names_length(0), names(NULL),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->names_length);
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_namesi = strlen(this->names[i]);
varToArr(outbuffer + offset, length_namesi);
offset += 4;
memcpy(outbuffer + offset, this->names[i], length_namesi);
offset += length_namesi;
}
*(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;
uint32_t names_lengthT = ((uint32_t) (*(inbuffer + offset)));
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->names_length);
if(names_lengthT > names_length)
this->names = (char**)realloc(this->names, names_lengthT * sizeof(char*));
names_length = names_lengthT;
for( uint32_t i = 0; i < names_length; i++){
uint32_t length_st_names;
arrToVar(length_st_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_names-1]=0;
this->st_names = (char *)(inbuffer + offset-1);
offset += length_st_names;
memcpy( &(this->names[i]), &(this->st_names), sizeof(char*));
}
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 = (baxter_core_msgs::NavigatorState*)realloc(this->states, states_lengthT * sizeof(baxter_core_msgs::NavigatorState));
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(baxter_core_msgs::NavigatorState));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/NavigatorStates"; };
const char * getMD5(){ return "2c2eeb02fbbaa6f1ab6c680887f2db78"; };
};
}
#endif
| 3,926 | C | 37.5 | 139 | 0.581508 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/bond/Status.h | #ifndef _ROS_bond_Status_h
#define _ROS_bond_Status_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace bond
{
class Status : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _id_type;
_id_type id;
typedef const char* _instance_id_type;
_instance_id_type instance_id;
typedef bool _active_type;
_active_type active;
typedef float _heartbeat_timeout_type;
_heartbeat_timeout_type heartbeat_timeout;
typedef float _heartbeat_period_type;
_heartbeat_period_type heartbeat_period;
Status():
header(),
id(""),
instance_id(""),
active(0),
heartbeat_timeout(0),
heartbeat_period(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
uint32_t length_instance_id = strlen(this->instance_id);
varToArr(outbuffer + offset, length_instance_id);
offset += 4;
memcpy(outbuffer + offset, this->instance_id, length_instance_id);
offset += length_instance_id;
union {
bool real;
uint8_t base;
} u_active;
u_active.real = this->active;
*(outbuffer + offset + 0) = (u_active.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->active);
union {
float real;
uint32_t base;
} u_heartbeat_timeout;
u_heartbeat_timeout.real = this->heartbeat_timeout;
*(outbuffer + offset + 0) = (u_heartbeat_timeout.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_heartbeat_timeout.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_heartbeat_timeout.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_heartbeat_timeout.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->heartbeat_timeout);
union {
float real;
uint32_t base;
} u_heartbeat_period;
u_heartbeat_period.real = this->heartbeat_period;
*(outbuffer + offset + 0) = (u_heartbeat_period.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_heartbeat_period.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_heartbeat_period.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_heartbeat_period.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->heartbeat_period);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
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;
uint32_t length_instance_id;
arrToVar(length_instance_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_instance_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_instance_id-1]=0;
this->instance_id = (char *)(inbuffer + offset-1);
offset += length_instance_id;
union {
bool real;
uint8_t base;
} u_active;
u_active.base = 0;
u_active.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->active = u_active.real;
offset += sizeof(this->active);
union {
float real;
uint32_t base;
} u_heartbeat_timeout;
u_heartbeat_timeout.base = 0;
u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_heartbeat_timeout.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->heartbeat_timeout = u_heartbeat_timeout.real;
offset += sizeof(this->heartbeat_timeout);
union {
float real;
uint32_t base;
} u_heartbeat_period;
u_heartbeat_period.base = 0;
u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_heartbeat_period.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->heartbeat_period = u_heartbeat_period.real;
offset += sizeof(this->heartbeat_period);
return offset;
}
const char * getType(){ return "bond/Status"; };
const char * getMD5(){ return "eacc84bf5d65b6777d4c50f463dfb9c8"; };
};
}
#endif
| 5,059 | C | 33.896551 | 85 | 0.574422 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/bond/Constants.h | #ifndef _ROS_bond_Constants_h
#define _ROS_bond_Constants_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace bond
{
class Constants : public ros::Msg
{
public:
enum { DEAD_PUBLISH_PERIOD = 0.05 };
enum { DEFAULT_CONNECT_TIMEOUT = 10.0 };
enum { DEFAULT_HEARTBEAT_TIMEOUT = 4.0 };
enum { DEFAULT_DISCONNECT_TIMEOUT = 2.0 };
enum { DEFAULT_HEARTBEAT_PERIOD = 1.0 };
enum { DISABLE_HEARTBEAT_TIMEOUT_PARAM = /bond_disable_heartbeat_timeout };
Constants()
{
}
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 "bond/Constants"; };
const char * getMD5(){ return "6fc594dc1d7bd7919077042712f8c8b0"; };
};
}
#endif
| 931 | C | 19.711111 | 81 | 0.619764 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/TeleportAbsolute.h | #ifndef _ROS_SERVICE_TeleportAbsolute_h
#define _ROS_SERVICE_TeleportAbsolute_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char TELEPORTABSOLUTE[] = "turtlesim/TeleportAbsolute";
class TeleportAbsoluteRequest : public ros::Msg
{
public:
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _theta_type;
_theta_type theta;
TeleportAbsoluteRequest():
x(0),
y(0),
theta(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.real = this->theta;
*(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->theta);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.base = 0;
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->theta = u_theta.real;
offset += sizeof(this->theta);
return offset;
}
const char * getType(){ return TELEPORTABSOLUTE; };
const char * getMD5(){ return "a130bc60ee6513855dc62ea83fcc5b20"; };
};
class TeleportAbsoluteResponse : public ros::Msg
{
public:
TeleportAbsoluteResponse()
{
}
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 TELEPORTABSOLUTE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class TeleportAbsolute {
public:
typedef TeleportAbsoluteRequest Request;
typedef TeleportAbsoluteResponse Response;
};
}
#endif
| 4,039 | C | 27.251748 | 73 | 0.51795 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Color.h | #ifndef _ROS_turtlesim_Color_h
#define _ROS_turtlesim_Color_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
class Color : public ros::Msg
{
public:
typedef uint8_t _r_type;
_r_type r;
typedef uint8_t _g_type;
_g_type g;
typedef uint8_t _b_type;
_b_type b;
Color():
r(0),
g(0),
b(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->r >> (8 * 0)) & 0xFF;
offset += sizeof(this->r);
*(outbuffer + offset + 0) = (this->g >> (8 * 0)) & 0xFF;
offset += sizeof(this->g);
*(outbuffer + offset + 0) = (this->b >> (8 * 0)) & 0xFF;
offset += sizeof(this->b);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->r = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->r);
this->g = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->g);
this->b = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->b);
return offset;
}
const char * getType(){ return "turtlesim/Color"; };
const char * getMD5(){ return "353891e354491c51aabe32df673fb446"; };
};
}
#endif
| 1,336 | C | 21.283333 | 72 | 0.53518 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/SetPen.h | #ifndef _ROS_SERVICE_SetPen_h
#define _ROS_SERVICE_SetPen_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char SETPEN[] = "turtlesim/SetPen";
class SetPenRequest : public ros::Msg
{
public:
typedef uint8_t _r_type;
_r_type r;
typedef uint8_t _g_type;
_g_type g;
typedef uint8_t _b_type;
_b_type b;
typedef uint8_t _width_type;
_width_type width;
typedef uint8_t _off_type;
_off_type off;
SetPenRequest():
r(0),
g(0),
b(0),
width(0),
off(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->r >> (8 * 0)) & 0xFF;
offset += sizeof(this->r);
*(outbuffer + offset + 0) = (this->g >> (8 * 0)) & 0xFF;
offset += sizeof(this->g);
*(outbuffer + offset + 0) = (this->b >> (8 * 0)) & 0xFF;
offset += sizeof(this->b);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
offset += sizeof(this->width);
*(outbuffer + offset + 0) = (this->off >> (8 * 0)) & 0xFF;
offset += sizeof(this->off);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->r = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->r);
this->g = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->g);
this->b = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->b);
this->width = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->width);
this->off = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->off);
return offset;
}
const char * getType(){ return SETPEN; };
const char * getMD5(){ return "9f452acce566bf0c0954594f69a8e41b"; };
};
class SetPenResponse : public ros::Msg
{
public:
SetPenResponse()
{
}
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 SETPEN; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetPen {
public:
typedef SetPenRequest Request;
typedef SetPenResponse Response;
};
}
#endif
| 2,467 | C | 22.283019 | 72 | 0.552898 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Pose.h | #ifndef _ROS_turtlesim_Pose_h
#define _ROS_turtlesim_Pose_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
class Pose : public ros::Msg
{
public:
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _theta_type;
_theta_type theta;
typedef float _linear_velocity_type;
_linear_velocity_type linear_velocity;
typedef float _angular_velocity_type;
_angular_velocity_type angular_velocity;
Pose():
x(0),
y(0),
theta(0),
linear_velocity(0),
angular_velocity(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.real = this->theta;
*(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->theta);
union {
float real;
uint32_t base;
} u_linear_velocity;
u_linear_velocity.real = this->linear_velocity;
*(outbuffer + offset + 0) = (u_linear_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_linear_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_linear_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_linear_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->linear_velocity);
union {
float real;
uint32_t base;
} u_angular_velocity;
u_angular_velocity.real = this->angular_velocity;
*(outbuffer + offset + 0) = (u_angular_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angular_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angular_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angular_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angular_velocity);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.base = 0;
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->theta = u_theta.real;
offset += sizeof(this->theta);
union {
float real;
uint32_t base;
} u_linear_velocity;
u_linear_velocity.base = 0;
u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_linear_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->linear_velocity = u_linear_velocity.real;
offset += sizeof(this->linear_velocity);
union {
float real;
uint32_t base;
} u_angular_velocity;
u_angular_velocity.base = 0;
u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angular_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angular_velocity = u_angular_velocity.real;
offset += sizeof(this->angular_velocity);
return offset;
}
const char * getType(){ return "turtlesim/Pose"; };
const char * getMD5(){ return "863b248d5016ca62ea2e895ae5265cf9"; };
};
}
#endif
| 5,658 | C | 34.591195 | 84 | 0.511665 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Kill.h | #ifndef _ROS_SERVICE_Kill_h
#define _ROS_SERVICE_Kill_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char KILL[] = "turtlesim/Kill";
class KillRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
KillRequest():
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 KILL; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class KillResponse : public ros::Msg
{
public:
KillResponse()
{
}
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 KILL; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class Kill {
public:
typedef KillRequest Request;
typedef KillResponse Response;
};
}
#endif
| 1,789 | C | 19.340909 | 72 | 0.60313 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/TeleportRelative.h | #ifndef _ROS_SERVICE_TeleportRelative_h
#define _ROS_SERVICE_TeleportRelative_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char TELEPORTRELATIVE[] = "turtlesim/TeleportRelative";
class TeleportRelativeRequest : public ros::Msg
{
public:
typedef float _linear_type;
_linear_type linear;
typedef float _angular_type;
_angular_type angular;
TeleportRelativeRequest():
linear(0),
angular(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_linear;
u_linear.real = this->linear;
*(outbuffer + offset + 0) = (u_linear.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_linear.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_linear.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_linear.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->linear);
union {
float real;
uint32_t base;
} u_angular;
u_angular.real = this->angular;
*(outbuffer + offset + 0) = (u_angular.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_angular.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_angular.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_angular.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->angular);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_linear;
u_linear.base = 0;
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_linear.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->linear = u_linear.real;
offset += sizeof(this->linear);
union {
float real;
uint32_t base;
} u_angular;
u_angular.base = 0;
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_angular.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->angular = u_angular.real;
offset += sizeof(this->angular);
return offset;
}
const char * getType(){ return TELEPORTRELATIVE; };
const char * getMD5(){ return "9d5c2dcd348ac8f76ce2a4307bd63a13"; };
};
class TeleportRelativeResponse : public ros::Msg
{
public:
TeleportRelativeResponse()
{
}
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 TELEPORTRELATIVE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class TeleportRelative {
public:
typedef TeleportRelativeRequest Request;
typedef TeleportRelativeResponse Response;
};
}
#endif
| 3,314 | C | 26.857143 | 75 | 0.562764 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlesim/Spawn.h | #ifndef _ROS_SERVICE_Spawn_h
#define _ROS_SERVICE_Spawn_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlesim
{
static const char SPAWN[] = "turtlesim/Spawn";
class SpawnRequest : public ros::Msg
{
public:
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _theta_type;
_theta_type theta;
typedef const char* _name_type;
_name_type name;
SpawnRequest():
x(0),
y(0),
theta(0),
name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.real = this->theta;
*(outbuffer + offset + 0) = (u_theta.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_theta.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_theta.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_theta.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->theta);
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;
union {
float real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
float real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
union {
float real;
uint32_t base;
} u_theta;
u_theta.base = 0;
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_theta.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->theta = u_theta.real;
offset += sizeof(this->theta);
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 SPAWN; };
const char * getMD5(){ return "57f001c49ab7b11d699f8606c1f4f7ff"; };
};
class SpawnResponse : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
SpawnResponse():
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 SPAWN; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class Spawn {
public:
typedef SpawnRequest Request;
typedef SpawnResponse Response;
};
}
#endif
| 5,108 | C | 27.864407 | 73 | 0.518207 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/control_toolbox/SetPidGains.h | #ifndef _ROS_SERVICE_SetPidGains_h
#define _ROS_SERVICE_SetPidGains_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace control_toolbox
{
static const char SETPIDGAINS[] = "control_toolbox/SetPidGains";
class SetPidGainsRequest : public ros::Msg
{
public:
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;
SetPidGainsRequest():
p(0),
i(0),
d(0),
i_clamp(0),
antiwindup(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
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;
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 SETPIDGAINS; };
const char * getMD5(){ return "4a43159879643e60937bf2893b633607"; };
};
class SetPidGainsResponse : public ros::Msg
{
public:
SetPidGainsResponse()
{
}
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 SETPIDGAINS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetPidGains {
public:
typedef SetPidGainsRequest Request;
typedef SetPidGainsResponse Response;
};
}
#endif
| 7,703 | C | 34.502304 | 77 | 0.485655 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/GetOctomap.h | #ifndef _ROS_SERVICE_GetOctomap_h
#define _ROS_SERVICE_GetOctomap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "octomap_msgs/Octomap.h"
namespace octomap_msgs
{
static const char GETOCTOMAP[] = "octomap_msgs/GetOctomap";
class GetOctomapRequest : public ros::Msg
{
public:
GetOctomapRequest()
{
}
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 GETOCTOMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetOctomapResponse : public ros::Msg
{
public:
typedef octomap_msgs::Octomap _map_type;
_map_type map;
GetOctomapResponse():
map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETOCTOMAP; };
const char * getMD5(){ return "be9d2869d24fe40d6bc21ac21f6bb2c5"; };
};
class GetOctomap {
public:
typedef GetOctomapRequest Request;
typedef GetOctomapResponse Response;
};
}
#endif
| 1,497 | C | 18.454545 | 72 | 0.639947 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/OctomapWithPose.h | #ifndef _ROS_octomap_msgs_OctomapWithPose_h
#define _ROS_octomap_msgs_OctomapWithPose_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "octomap_msgs/Octomap.h"
namespace octomap_msgs
{
class OctomapWithPose : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _origin_type;
_origin_type origin;
typedef octomap_msgs::Octomap _octomap_type;
_octomap_type octomap;
OctomapWithPose():
header(),
origin(),
octomap()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->origin.serialize(outbuffer + offset);
offset += this->octomap.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->origin.deserialize(inbuffer + offset);
offset += this->octomap.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "octomap_msgs/OctomapWithPose"; };
const char * getMD5(){ return "20b380aca6a508a657e95526cddaf618"; };
};
}
#endif
| 1,408 | C | 23.719298 | 72 | 0.654119 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/BoundingBoxQuery.h | #ifndef _ROS_SERVICE_BoundingBoxQuery_h
#define _ROS_SERVICE_BoundingBoxQuery_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Point.h"
namespace octomap_msgs
{
static const char BOUNDINGBOXQUERY[] = "octomap_msgs/BoundingBoxQuery";
class BoundingBoxQueryRequest : public ros::Msg
{
public:
typedef geometry_msgs::Point _min_type;
_min_type min;
typedef geometry_msgs::Point _max_type;
_max_type max;
BoundingBoxQueryRequest():
min(),
max()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->min.serialize(outbuffer + offset);
offset += this->max.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->min.deserialize(inbuffer + offset);
offset += this->max.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return BOUNDINGBOXQUERY; };
const char * getMD5(){ return "93aa3d73b866f04880927745f4aab303"; };
};
class BoundingBoxQueryResponse : public ros::Msg
{
public:
BoundingBoxQueryResponse()
{
}
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 BOUNDINGBOXQUERY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class BoundingBoxQuery {
public:
typedef BoundingBoxQueryRequest Request;
typedef BoundingBoxQueryResponse Response;
};
}
#endif
| 1,768 | C | 20.57317 | 72 | 0.652149 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/octomap_msgs/Octomap.h | #ifndef _ROS_octomap_msgs_Octomap_h
#define _ROS_octomap_msgs_Octomap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace octomap_msgs
{
class Octomap : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef bool _binary_type;
_binary_type binary;
typedef const char* _id_type;
_id_type id;
typedef double _resolution_type;
_resolution_type resolution;
uint32_t data_length;
typedef int8_t _data_type;
_data_type st_data;
_data_type * data;
Octomap():
header(),
binary(0),
id(""),
resolution(0),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_binary;
u_binary.real = this->binary;
*(outbuffer + offset + 0) = (u_binary.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->binary);
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 {
double real;
uint64_t base;
} u_resolution;
u_resolution.real = this->resolution;
*(outbuffer + offset + 0) = (u_resolution.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_resolution.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_resolution.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_resolution.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_resolution.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_resolution.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_resolution.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_resolution.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->resolution);
*(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 {
int8_t real;
uint8_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_binary;
u_binary.base = 0;
u_binary.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->binary = u_binary.real;
offset += sizeof(this->binary);
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 {
double real;
uint64_t base;
} u_resolution;
u_resolution.base = 0;
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_resolution.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->resolution = u_resolution.real;
offset += sizeof(this->resolution);
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 = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "octomap_msgs/Octomap"; };
const char * getMD5(){ return "9a45536b45c5e409cd49f04bb2d9999f"; };
};
}
#endif
| 5,281 | C | 34.213333 | 81 | 0.535694 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf/tf.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ROS_TF_H_
#define ROS_TF_H_
#include "geometry_msgs/TransformStamped.h"
namespace tf
{
static inline geometry_msgs::Quaternion createQuaternionFromYaw(double yaw)
{
geometry_msgs::Quaternion q;
q.x = 0;
q.y = 0;
q.z = sin(yaw * 0.5);
q.w = cos(yaw * 0.5);
return q;
}
}
#endif
| 1,945 | C | 33.14035 | 75 | 0.74036 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf/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 tf
{
static const char FRAMEGRAPH[] = "tf/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* _dot_graph_type;
_dot_graph_type dot_graph;
FrameGraphResponse():
dot_graph("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_dot_graph = strlen(this->dot_graph);
varToArr(outbuffer + offset, length_dot_graph);
offset += 4;
memcpy(outbuffer + offset, this->dot_graph, length_dot_graph);
offset += length_dot_graph;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_dot_graph;
arrToVar(length_dot_graph, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_dot_graph; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_dot_graph-1]=0;
this->dot_graph = (char *)(inbuffer + offset-1);
offset += length_dot_graph;
return offset;
}
const char * getType(){ return FRAMEGRAPH; };
const char * getMD5(){ return "c4af9ac907e58e906eb0b6e3c58478c0"; };
};
class FrameGraph {
public:
typedef FrameGraphRequest Request;
typedef FrameGraphResponse Response;
};
}
#endif
| 1,933 | C | 20.977272 | 72 | 0.624418 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf/transform_broadcaster.h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote prducts derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ROS_TRANSFORM_BROADCASTER_H_
#define ROS_TRANSFORM_BROADCASTER_H_
#include "ros.h"
#include "tfMessage.h"
namespace tf
{
class TransformBroadcaster
{
public:
TransformBroadcaster() : publisher_("/tf", &internal_msg) {}
void init(ros::NodeHandle &nh)
{
nh.advertise(publisher_);
}
void sendTransform(geometry_msgs::TransformStamped &transform)
{
internal_msg.transforms_length = 1;
internal_msg.transforms = &transform;
publisher_.publish(&internal_msg);
}
private:
tf::tfMessage internal_msg;
ros::Publisher publisher_;
};
}
#endif
| 2,225 | C | 30.8 | 71 | 0.742022 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf/tfMessage.h | #ifndef _ROS_tf_tfMessage_h
#define _ROS_tf_tfMessage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/TransformStamped.h"
namespace tf
{
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 "tf/tfMessage"; };
const char * getMD5(){ return "94810edda583a504dfda3829e70d7eec"; };
};
}
#endif
| 2,210 | C | 33.015384 | 149 | 0.617647 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/UpdateStatus.h | #ifndef _ROS_baxter_maintenance_msgs_UpdateStatus_h
#define _ROS_baxter_maintenance_msgs_UpdateStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_maintenance_msgs
{
class UpdateStatus : public ros::Msg
{
public:
typedef uint16_t _status_type;
_status_type status;
typedef float _progress_type;
_progress_type progress;
typedef const char* _long_description_type;
_long_description_type long_description;
enum { STS_IDLE = 0 };
enum { STS_INVALID = 1 };
enum { STS_BUSY = 2 };
enum { STS_CANCELLED = 3 };
enum { STS_ERR = 4 };
enum { STS_MOUNT_UPDATE = 5 };
enum { STS_VERIFY_UPDATE = 6 };
enum { STS_PREP_STAGING = 7 };
enum { STS_MOUNT_STAGING = 8 };
enum { STS_EXTRACT_UPDATE = 9 };
enum { STS_LOAD_KEXEC = 10 };
UpdateStatus():
status(0),
progress(0),
long_description("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->status >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->status >> (8 * 1)) & 0xFF;
offset += sizeof(this->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);
uint32_t length_long_description = strlen(this->long_description);
varToArr(outbuffer + offset, length_long_description);
offset += 4;
memcpy(outbuffer + offset, this->long_description, length_long_description);
offset += length_long_description;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->status = ((uint16_t) (*(inbuffer + offset)));
this->status |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->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);
uint32_t length_long_description;
arrToVar(length_long_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_long_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_long_description-1]=0;
this->long_description = (char *)(inbuffer + offset-1);
offset += length_long_description;
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/UpdateStatus"; };
const char * getMD5(){ return "74e246350421569590252c39e8aa7b85"; };
};
}
#endif
| 3,332 | C | 32.33 | 82 | 0.57383 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/CalibrateArmData.h | #ifndef _ROS_baxter_maintenance_msgs_CalibrateArmData_h
#define _ROS_baxter_maintenance_msgs_CalibrateArmData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_maintenance_msgs
{
class CalibrateArmData : public ros::Msg
{
public:
typedef bool _suppressWriteToFile_type;
_suppressWriteToFile_type suppressWriteToFile;
CalibrateArmData():
suppressWriteToFile(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_suppressWriteToFile;
u_suppressWriteToFile.real = this->suppressWriteToFile;
*(outbuffer + offset + 0) = (u_suppressWriteToFile.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->suppressWriteToFile);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_suppressWriteToFile;
u_suppressWriteToFile.base = 0;
u_suppressWriteToFile.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->suppressWriteToFile = u_suppressWriteToFile.real;
offset += sizeof(this->suppressWriteToFile);
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/CalibrateArmData"; };
const char * getMD5(){ return "ba9ee949ea363f7bcfc8cc74e0bcb69d"; };
};
}
#endif
| 1,455 | C | 24.543859 | 86 | 0.650172 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/CalibrateArmEnable.h | #ifndef _ROS_baxter_maintenance_msgs_CalibrateArmEnable_h
#define _ROS_baxter_maintenance_msgs_CalibrateArmEnable_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_maintenance_msgs/CalibrateArmData.h"
namespace baxter_maintenance_msgs
{
class CalibrateArmEnable : public ros::Msg
{
public:
typedef bool _isEnabled_type;
_isEnabled_type isEnabled;
typedef const char* _uid_type;
_uid_type uid;
typedef baxter_maintenance_msgs::CalibrateArmData _data_type;
_data_type data;
CalibrateArmEnable():
isEnabled(0),
uid(""),
data()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.real = this->isEnabled;
*(outbuffer + offset + 0) = (u_isEnabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isEnabled);
uint32_t length_uid = strlen(this->uid);
varToArr(outbuffer + offset, length_uid);
offset += 4;
memcpy(outbuffer + offset, this->uid, length_uid);
offset += length_uid;
offset += this->data.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.base = 0;
u_isEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isEnabled = u_isEnabled.real;
offset += sizeof(this->isEnabled);
uint32_t length_uid;
arrToVar(length_uid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_uid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_uid-1]=0;
this->uid = (char *)(inbuffer + offset-1);
offset += length_uid;
offset += this->data.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/CalibrateArmEnable"; };
const char * getMD5(){ return "d7ff300fd410d4ac849664ab8143da39"; };
};
}
#endif
| 2,181 | C | 26.275 | 83 | 0.609354 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/UpdateSources.h | #ifndef _ROS_baxter_maintenance_msgs_UpdateSources_h
#define _ROS_baxter_maintenance_msgs_UpdateSources_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_maintenance_msgs/UpdateSource.h"
namespace baxter_maintenance_msgs
{
class UpdateSources : public ros::Msg
{
public:
typedef const char* _uuid_type;
_uuid_type uuid;
uint32_t sources_length;
typedef baxter_maintenance_msgs::UpdateSource _sources_type;
_sources_type st_sources;
_sources_type * sources;
UpdateSources():
uuid(""),
sources_length(0), sources(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_uuid = strlen(this->uuid);
varToArr(outbuffer + offset, length_uuid);
offset += 4;
memcpy(outbuffer + offset, this->uuid, length_uuid);
offset += length_uuid;
*(outbuffer + offset + 0) = (this->sources_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sources_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sources_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sources_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->sources_length);
for( uint32_t i = 0; i < sources_length; i++){
offset += this->sources[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_uuid;
arrToVar(length_uuid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_uuid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_uuid-1]=0;
this->uuid = (char *)(inbuffer + offset-1);
offset += length_uuid;
uint32_t sources_lengthT = ((uint32_t) (*(inbuffer + offset)));
sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sources_length);
if(sources_lengthT > sources_length)
this->sources = (baxter_maintenance_msgs::UpdateSource*)realloc(this->sources, sources_lengthT * sizeof(baxter_maintenance_msgs::UpdateSource));
sources_length = sources_lengthT;
for( uint32_t i = 0; i < sources_length; i++){
offset += this->st_sources.deserialize(inbuffer + offset);
memcpy( &(this->sources[i]), &(this->st_sources), sizeof(baxter_maintenance_msgs::UpdateSource));
}
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/UpdateSources"; };
const char * getMD5(){ return "b3b428bf55e80e83d378830c33b3405b"; };
};
}
#endif
| 2,857 | C | 33.853658 | 152 | 0.60973 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/UpdateSource.h | #ifndef _ROS_baxter_maintenance_msgs_UpdateSource_h
#define _ROS_baxter_maintenance_msgs_UpdateSource_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_maintenance_msgs
{
class UpdateSource : public ros::Msg
{
public:
typedef const char* _devname_type;
_devname_type devname;
typedef const char* _filename_type;
_filename_type filename;
typedef const char* _version_type;
_version_type version;
typedef const char* _uuid_type;
_uuid_type uuid;
UpdateSource():
devname(""),
filename(""),
version(""),
uuid("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_devname = strlen(this->devname);
varToArr(outbuffer + offset, length_devname);
offset += 4;
memcpy(outbuffer + offset, this->devname, length_devname);
offset += length_devname;
uint32_t length_filename = strlen(this->filename);
varToArr(outbuffer + offset, length_filename);
offset += 4;
memcpy(outbuffer + offset, this->filename, length_filename);
offset += length_filename;
uint32_t length_version = strlen(this->version);
varToArr(outbuffer + offset, length_version);
offset += 4;
memcpy(outbuffer + offset, this->version, length_version);
offset += length_version;
uint32_t length_uuid = strlen(this->uuid);
varToArr(outbuffer + offset, length_uuid);
offset += 4;
memcpy(outbuffer + offset, this->uuid, length_uuid);
offset += length_uuid;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_devname;
arrToVar(length_devname, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_devname; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_devname-1]=0;
this->devname = (char *)(inbuffer + offset-1);
offset += length_devname;
uint32_t length_filename;
arrToVar(length_filename, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_filename; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_filename-1]=0;
this->filename = (char *)(inbuffer + offset-1);
offset += length_filename;
uint32_t length_version;
arrToVar(length_version, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_version; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_version-1]=0;
this->version = (char *)(inbuffer + offset-1);
offset += length_version;
uint32_t length_uuid;
arrToVar(length_uuid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_uuid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_uuid-1]=0;
this->uuid = (char *)(inbuffer + offset-1);
offset += length_uuid;
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/UpdateSource"; };
const char * getMD5(){ return "88ad69e3ed4d619e167c9d83e6d9310f"; };
};
}
#endif
| 3,285 | C | 29.71028 | 77 | 0.614307 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/TareEnable.h | #ifndef _ROS_baxter_maintenance_msgs_TareEnable_h
#define _ROS_baxter_maintenance_msgs_TareEnable_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "baxter_maintenance_msgs/TareData.h"
namespace baxter_maintenance_msgs
{
class TareEnable : public ros::Msg
{
public:
typedef bool _isEnabled_type;
_isEnabled_type isEnabled;
typedef const char* _uid_type;
_uid_type uid;
typedef baxter_maintenance_msgs::TareData _data_type;
_data_type data;
TareEnable():
isEnabled(0),
uid(""),
data()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.real = this->isEnabled;
*(outbuffer + offset + 0) = (u_isEnabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isEnabled);
uint32_t length_uid = strlen(this->uid);
varToArr(outbuffer + offset, length_uid);
offset += 4;
memcpy(outbuffer + offset, this->uid, length_uid);
offset += length_uid;
offset += this->data.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_isEnabled;
u_isEnabled.base = 0;
u_isEnabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->isEnabled = u_isEnabled.real;
offset += sizeof(this->isEnabled);
uint32_t length_uid;
arrToVar(length_uid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_uid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_uid-1]=0;
this->uid = (char *)(inbuffer + offset-1);
offset += length_uid;
offset += this->data.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/TareEnable"; };
const char * getMD5(){ return "1d38ec0923789ab928453d933bef8c51"; };
};
}
#endif
| 2,125 | C | 25.575 | 76 | 0.599059 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_maintenance_msgs/TareData.h | #ifndef _ROS_baxter_maintenance_msgs_TareData_h
#define _ROS_baxter_maintenance_msgs_TareData_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_maintenance_msgs
{
class TareData : public ros::Msg
{
public:
typedef bool _tuneGravitySpring_type;
_tuneGravitySpring_type tuneGravitySpring;
TareData():
tuneGravitySpring(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_tuneGravitySpring;
u_tuneGravitySpring.real = this->tuneGravitySpring;
*(outbuffer + offset + 0) = (u_tuneGravitySpring.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->tuneGravitySpring);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_tuneGravitySpring;
u_tuneGravitySpring.base = 0;
u_tuneGravitySpring.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->tuneGravitySpring = u_tuneGravitySpring.real;
offset += sizeof(this->tuneGravitySpring);
return offset;
}
const char * getType(){ return "baxter_maintenance_msgs/TareData"; };
const char * getMD5(){ return "241e9c2ceee7da9db50693da0b3f2741"; };
};
}
#endif
| 1,385 | C | 23.315789 | 84 | 0.632491 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/navfn/MakeNavPlan.h | #ifndef _ROS_SERVICE_MakeNavPlan_h
#define _ROS_SERVICE_MakeNavPlan_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
namespace navfn
{
static const char MAKENAVPLAN[] = "navfn/MakeNavPlan";
class MakeNavPlanRequest : public ros::Msg
{
public:
typedef geometry_msgs::PoseStamped _start_type;
_start_type start;
typedef geometry_msgs::PoseStamped _goal_type;
_goal_type goal;
MakeNavPlanRequest():
start(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->start.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->start.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return MAKENAVPLAN; };
const char * getMD5(){ return "2fe3126bd5b2d56edd5005220333d4fd"; };
};
class MakeNavPlanResponse : public ros::Msg
{
public:
typedef uint8_t _plan_found_type;
_plan_found_type plan_found;
typedef const char* _error_message_type;
_error_message_type error_message;
uint32_t path_length;
typedef geometry_msgs::PoseStamped _path_type;
_path_type st_path;
_path_type * path;
MakeNavPlanResponse():
plan_found(0),
error_message(""),
path_length(0), path(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->plan_found >> (8 * 0)) & 0xFF;
offset += sizeof(this->plan_found);
uint32_t length_error_message = strlen(this->error_message);
varToArr(outbuffer + offset, length_error_message);
offset += 4;
memcpy(outbuffer + offset, this->error_message, length_error_message);
offset += length_error_message;
*(outbuffer + offset + 0) = (this->path_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->path_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->path_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->path_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->path_length);
for( uint32_t i = 0; i < path_length; i++){
offset += this->path[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->plan_found = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->plan_found);
uint32_t length_error_message;
arrToVar(length_error_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_error_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_error_message-1]=0;
this->error_message = (char *)(inbuffer + offset-1);
offset += length_error_message;
uint32_t path_lengthT = ((uint32_t) (*(inbuffer + offset)));
path_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
path_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
path_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->path_length);
if(path_lengthT > path_length)
this->path = (geometry_msgs::PoseStamped*)realloc(this->path, path_lengthT * sizeof(geometry_msgs::PoseStamped));
path_length = path_lengthT;
for( uint32_t i = 0; i < path_length; i++){
offset += this->st_path.deserialize(inbuffer + offset);
memcpy( &(this->path[i]), &(this->st_path), sizeof(geometry_msgs::PoseStamped));
}
return offset;
}
const char * getType(){ return MAKENAVPLAN; };
const char * getMD5(){ return "8b8ed7edf1b237dc9ddda8c8ffed5d3a"; };
};
class MakeNavPlan {
public:
typedef MakeNavPlanRequest Request;
typedef MakeNavPlanResponse Response;
};
}
#endif
| 4,147 | C | 30.664122 | 121 | 0.606945 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/navfn/SetCostmap.h | #ifndef _ROS_SERVICE_SetCostmap_h
#define _ROS_SERVICE_SetCostmap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace navfn
{
static const char SETCOSTMAP[] = "navfn/SetCostmap";
class SetCostmapRequest : public ros::Msg
{
public:
uint32_t costs_length;
typedef uint8_t _costs_type;
_costs_type st_costs;
_costs_type * costs;
typedef uint16_t _height_type;
_height_type height;
typedef uint16_t _width_type;
_width_type width;
SetCostmapRequest():
costs_length(0), costs(NULL),
height(0),
width(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->costs_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->costs_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->costs_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->costs_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->costs_length);
for( uint32_t i = 0; i < costs_length; i++){
*(outbuffer + offset + 0) = (this->costs[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->costs[i]);
}
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
offset += sizeof(this->height);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
offset += sizeof(this->width);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t costs_lengthT = ((uint32_t) (*(inbuffer + offset)));
costs_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
costs_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
costs_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->costs_length);
if(costs_lengthT > costs_length)
this->costs = (uint8_t*)realloc(this->costs, costs_lengthT * sizeof(uint8_t));
costs_length = costs_lengthT;
for( uint32_t i = 0; i < costs_length; i++){
this->st_costs = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_costs);
memcpy( &(this->costs[i]), &(this->st_costs), sizeof(uint8_t));
}
this->height = ((uint16_t) (*(inbuffer + offset)));
this->height |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->height);
this->width = ((uint16_t) (*(inbuffer + offset)));
this->width |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->width);
return offset;
}
const char * getType(){ return SETCOSTMAP; };
const char * getMD5(){ return "370ec969cdb71f9cde7c7cbe0d752308"; };
};
class SetCostmapResponse : public ros::Msg
{
public:
SetCostmapResponse()
{
}
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 SETCOSTMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetCostmap {
public:
typedef SetCostmapRequest Request;
typedef SetCostmapResponse Response;
};
}
#endif
| 3,493 | C | 29.120689 | 86 | 0.564271 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupAction.h | #ifndef _ROS_moveit_msgs_MoveGroupAction_h
#define _ROS_moveit_msgs_MoveGroupAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveGroupActionGoal.h"
#include "moveit_msgs/MoveGroupActionResult.h"
#include "moveit_msgs/MoveGroupActionFeedback.h"
namespace moveit_msgs
{
class MoveGroupAction : public ros::Msg
{
public:
typedef moveit_msgs::MoveGroupActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::MoveGroupActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::MoveGroupActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
MoveGroupAction():
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 "moveit_msgs/MoveGroupAction"; };
const char * getMD5(){ return "be9c7984423000efe94194063f359cfc"; };
};
}
#endif
| 1,616 | C | 27.368421 | 73 | 0.6875 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/OrientationConstraint.h | #ifndef _ROS_moveit_msgs_OrientationConstraint_h
#define _ROS_moveit_msgs_OrientationConstraint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Quaternion.h"
namespace moveit_msgs
{
class OrientationConstraint : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Quaternion _orientation_type;
_orientation_type orientation;
typedef const char* _link_name_type;
_link_name_type link_name;
typedef double _absolute_x_axis_tolerance_type;
_absolute_x_axis_tolerance_type absolute_x_axis_tolerance;
typedef double _absolute_y_axis_tolerance_type;
_absolute_y_axis_tolerance_type absolute_y_axis_tolerance;
typedef double _absolute_z_axis_tolerance_type;
_absolute_z_axis_tolerance_type absolute_z_axis_tolerance;
typedef double _weight_type;
_weight_type weight;
OrientationConstraint():
header(),
orientation(),
link_name(""),
absolute_x_axis_tolerance(0),
absolute_y_axis_tolerance(0),
absolute_z_axis_tolerance(0),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->orientation.serialize(outbuffer + offset);
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_absolute_x_axis_tolerance;
u_absolute_x_axis_tolerance.real = this->absolute_x_axis_tolerance;
*(outbuffer + offset + 0) = (u_absolute_x_axis_tolerance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_absolute_x_axis_tolerance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_absolute_x_axis_tolerance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_absolute_x_axis_tolerance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_absolute_x_axis_tolerance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_absolute_x_axis_tolerance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_absolute_x_axis_tolerance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_absolute_x_axis_tolerance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->absolute_x_axis_tolerance);
union {
double real;
uint64_t base;
} u_absolute_y_axis_tolerance;
u_absolute_y_axis_tolerance.real = this->absolute_y_axis_tolerance;
*(outbuffer + offset + 0) = (u_absolute_y_axis_tolerance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_absolute_y_axis_tolerance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_absolute_y_axis_tolerance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_absolute_y_axis_tolerance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_absolute_y_axis_tolerance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_absolute_y_axis_tolerance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_absolute_y_axis_tolerance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_absolute_y_axis_tolerance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->absolute_y_axis_tolerance);
union {
double real;
uint64_t base;
} u_absolute_z_axis_tolerance;
u_absolute_z_axis_tolerance.real = this->absolute_z_axis_tolerance;
*(outbuffer + offset + 0) = (u_absolute_z_axis_tolerance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_absolute_z_axis_tolerance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_absolute_z_axis_tolerance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_absolute_z_axis_tolerance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_absolute_z_axis_tolerance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_absolute_z_axis_tolerance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_absolute_z_axis_tolerance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_absolute_z_axis_tolerance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->absolute_z_axis_tolerance);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->orientation.deserialize(inbuffer + offset);
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_absolute_x_axis_tolerance;
u_absolute_x_axis_tolerance.base = 0;
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_absolute_x_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->absolute_x_axis_tolerance = u_absolute_x_axis_tolerance.real;
offset += sizeof(this->absolute_x_axis_tolerance);
union {
double real;
uint64_t base;
} u_absolute_y_axis_tolerance;
u_absolute_y_axis_tolerance.base = 0;
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_absolute_y_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->absolute_y_axis_tolerance = u_absolute_y_axis_tolerance.real;
offset += sizeof(this->absolute_y_axis_tolerance);
union {
double real;
uint64_t base;
} u_absolute_z_axis_tolerance;
u_absolute_z_axis_tolerance.base = 0;
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_absolute_z_axis_tolerance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->absolute_z_axis_tolerance = u_absolute_z_axis_tolerance.real;
offset += sizeof(this->absolute_z_axis_tolerance);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/OrientationConstraint"; };
const char * getMD5(){ return "ab5cefb9bc4c0089620f5eb4caf4e59a"; };
};
}
#endif
| 9,785 | C | 48.928571 | 93 | 0.576392 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetMotionSequence.h | #ifndef _ROS_SERVICE_GetMotionSequence_h
#define _ROS_SERVICE_GetMotionSequence_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionSequenceRequest.h"
#include "moveit_msgs/MotionSequenceResponse.h"
namespace moveit_msgs
{
static const char GETMOTIONSEQUENCE[] = "moveit_msgs/GetMotionSequence";
class GetMotionSequenceRequest : public ros::Msg
{
public:
typedef moveit_msgs::MotionSequenceRequest _request_type;
_request_type request;
GetMotionSequenceRequest():
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 GETMOTIONSEQUENCE; };
const char * getMD5(){ return "bae3996834a2cd1013b32c29e6a79b4e"; };
};
class GetMotionSequenceResponse : public ros::Msg
{
public:
typedef moveit_msgs::MotionSequenceResponse _response_type;
_response_type response;
GetMotionSequenceResponse():
response()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->response.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->response.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMOTIONSEQUENCE; };
const char * getMD5(){ return "039cee462ada3f0feb5f4e2e12baefae"; };
};
class GetMotionSequence {
public:
typedef GetMotionSequenceRequest Request;
typedef GetMotionSequenceResponse Response;
};
}
#endif
| 1,924 | C | 22.192771 | 72 | 0.676195 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceResponse.h | #ifndef _ROS_moveit_msgs_MotionSequenceResponse_h
#define _ROS_moveit_msgs_MotionSequenceResponse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
namespace moveit_msgs
{
class MotionSequenceResponse : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
typedef moveit_msgs::RobotState _sequence_start_type;
_sequence_start_type sequence_start;
uint32_t planned_trajectories_length;
typedef moveit_msgs::RobotTrajectory _planned_trajectories_type;
_planned_trajectories_type st_planned_trajectories;
_planned_trajectories_type * planned_trajectories;
typedef double _planning_time_type;
_planning_time_type planning_time;
MotionSequenceResponse():
error_code(),
sequence_start(),
planned_trajectories_length(0), planned_trajectories(NULL),
planning_time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
offset += this->sequence_start.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->planned_trajectories_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planned_trajectories_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planned_trajectories_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planned_trajectories_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planned_trajectories_length);
for( uint32_t i = 0; i < planned_trajectories_length; i++){
offset += this->planned_trajectories[i].serialize(outbuffer + offset);
}
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
offset += this->sequence_start.deserialize(inbuffer + offset);
uint32_t planned_trajectories_lengthT = ((uint32_t) (*(inbuffer + offset)));
planned_trajectories_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planned_trajectories_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planned_trajectories_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planned_trajectories_length);
if(planned_trajectories_lengthT > planned_trajectories_length)
this->planned_trajectories = (moveit_msgs::RobotTrajectory*)realloc(this->planned_trajectories, planned_trajectories_lengthT * sizeof(moveit_msgs::RobotTrajectory));
planned_trajectories_length = planned_trajectories_lengthT;
for( uint32_t i = 0; i < planned_trajectories_length; i++){
offset += this->st_planned_trajectories.deserialize(inbuffer + offset);
memcpy( &(this->planned_trajectories[i]), &(this->st_planned_trajectories), sizeof(moveit_msgs::RobotTrajectory));
}
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionSequenceResponse"; };
const char * getMD5(){ return "3b9d4e8079db4576e4829d30617a3d1d"; };
};
}
#endif
| 4,953 | C | 44.449541 | 173 | 0.618211 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ChangeControlDimensions.h | #ifndef _ROS_SERVICE_ChangeControlDimensions_h
#define _ROS_SERVICE_ChangeControlDimensions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char CHANGECONTROLDIMENSIONS[] = "moveit_msgs/ChangeControlDimensions";
class ChangeControlDimensionsRequest : public ros::Msg
{
public:
typedef bool _control_x_translation_type;
_control_x_translation_type control_x_translation;
typedef bool _control_y_translation_type;
_control_y_translation_type control_y_translation;
typedef bool _control_z_translation_type;
_control_z_translation_type control_z_translation;
typedef bool _control_x_rotation_type;
_control_x_rotation_type control_x_rotation;
typedef bool _control_y_rotation_type;
_control_y_rotation_type control_y_rotation;
typedef bool _control_z_rotation_type;
_control_z_rotation_type control_z_rotation;
ChangeControlDimensionsRequest():
control_x_translation(0),
control_y_translation(0),
control_z_translation(0),
control_x_rotation(0),
control_y_rotation(0),
control_z_rotation(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_control_x_translation;
u_control_x_translation.real = this->control_x_translation;
*(outbuffer + offset + 0) = (u_control_x_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_x_translation);
union {
bool real;
uint8_t base;
} u_control_y_translation;
u_control_y_translation.real = this->control_y_translation;
*(outbuffer + offset + 0) = (u_control_y_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_y_translation);
union {
bool real;
uint8_t base;
} u_control_z_translation;
u_control_z_translation.real = this->control_z_translation;
*(outbuffer + offset + 0) = (u_control_z_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_z_translation);
union {
bool real;
uint8_t base;
} u_control_x_rotation;
u_control_x_rotation.real = this->control_x_rotation;
*(outbuffer + offset + 0) = (u_control_x_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_x_rotation);
union {
bool real;
uint8_t base;
} u_control_y_rotation;
u_control_y_rotation.real = this->control_y_rotation;
*(outbuffer + offset + 0) = (u_control_y_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_y_rotation);
union {
bool real;
uint8_t base;
} u_control_z_rotation;
u_control_z_rotation.real = this->control_z_rotation;
*(outbuffer + offset + 0) = (u_control_z_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->control_z_rotation);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_control_x_translation;
u_control_x_translation.base = 0;
u_control_x_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_x_translation = u_control_x_translation.real;
offset += sizeof(this->control_x_translation);
union {
bool real;
uint8_t base;
} u_control_y_translation;
u_control_y_translation.base = 0;
u_control_y_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_y_translation = u_control_y_translation.real;
offset += sizeof(this->control_y_translation);
union {
bool real;
uint8_t base;
} u_control_z_translation;
u_control_z_translation.base = 0;
u_control_z_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_z_translation = u_control_z_translation.real;
offset += sizeof(this->control_z_translation);
union {
bool real;
uint8_t base;
} u_control_x_rotation;
u_control_x_rotation.base = 0;
u_control_x_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_x_rotation = u_control_x_rotation.real;
offset += sizeof(this->control_x_rotation);
union {
bool real;
uint8_t base;
} u_control_y_rotation;
u_control_y_rotation.base = 0;
u_control_y_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_y_rotation = u_control_y_rotation.real;
offset += sizeof(this->control_y_rotation);
union {
bool real;
uint8_t base;
} u_control_z_rotation;
u_control_z_rotation.base = 0;
u_control_z_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->control_z_rotation = u_control_z_rotation.real;
offset += sizeof(this->control_z_rotation);
return offset;
}
const char * getType(){ return CHANGECONTROLDIMENSIONS; };
const char * getMD5(){ return "64c0dd6d519e78f5ce2626b06dab34c1"; };
};
class ChangeControlDimensionsResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
ChangeControlDimensionsResponse():
success(0)
{
}
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);
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);
return offset;
}
const char * getType(){ return CHANGECONTROLDIMENSIONS; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class ChangeControlDimensions {
public:
typedef ChangeControlDimensionsRequest Request;
typedef ChangeControlDimensionsResponse Response;
};
}
#endif
| 6,437 | C | 31.680203 | 88 | 0.607737 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GraspPlanning.h | #ifndef _ROS_SERVICE_GraspPlanning_h
#define _ROS_SERVICE_GraspPlanning_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/Grasp.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/CollisionObject.h"
namespace moveit_msgs
{
static const char GRASPPLANNING[] = "moveit_msgs/GraspPlanning";
class GraspPlanningRequest : public ros::Msg
{
public:
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::CollisionObject _target_type;
_target_type target;
uint32_t support_surfaces_length;
typedef char* _support_surfaces_type;
_support_surfaces_type st_support_surfaces;
_support_surfaces_type * support_surfaces;
uint32_t candidate_grasps_length;
typedef moveit_msgs::Grasp _candidate_grasps_type;
_candidate_grasps_type st_candidate_grasps;
_candidate_grasps_type * candidate_grasps;
uint32_t movable_obstacles_length;
typedef moveit_msgs::CollisionObject _movable_obstacles_type;
_movable_obstacles_type st_movable_obstacles;
_movable_obstacles_type * movable_obstacles;
GraspPlanningRequest():
group_name(""),
target(),
support_surfaces_length(0), support_surfaces(NULL),
candidate_grasps_length(0), candidate_grasps(NULL),
movable_obstacles_length(0), movable_obstacles(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
offset += this->target.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->support_surfaces_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->support_surfaces_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->support_surfaces_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->support_surfaces_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->support_surfaces_length);
for( uint32_t i = 0; i < support_surfaces_length; i++){
uint32_t length_support_surfacesi = strlen(this->support_surfaces[i]);
varToArr(outbuffer + offset, length_support_surfacesi);
offset += 4;
memcpy(outbuffer + offset, this->support_surfaces[i], length_support_surfacesi);
offset += length_support_surfacesi;
}
*(outbuffer + offset + 0) = (this->candidate_grasps_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->candidate_grasps_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->candidate_grasps_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->candidate_grasps_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->candidate_grasps_length);
for( uint32_t i = 0; i < candidate_grasps_length; i++){
offset += this->candidate_grasps[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->movable_obstacles_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->movable_obstacles_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->movable_obstacles_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->movable_obstacles_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->movable_obstacles_length);
for( uint32_t i = 0; i < movable_obstacles_length; i++){
offset += this->movable_obstacles[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
offset += this->target.deserialize(inbuffer + offset);
uint32_t support_surfaces_lengthT = ((uint32_t) (*(inbuffer + offset)));
support_surfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
support_surfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
support_surfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->support_surfaces_length);
if(support_surfaces_lengthT > support_surfaces_length)
this->support_surfaces = (char**)realloc(this->support_surfaces, support_surfaces_lengthT * sizeof(char*));
support_surfaces_length = support_surfaces_lengthT;
for( uint32_t i = 0; i < support_surfaces_length; i++){
uint32_t length_st_support_surfaces;
arrToVar(length_st_support_surfaces, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_support_surfaces; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_support_surfaces-1]=0;
this->st_support_surfaces = (char *)(inbuffer + offset-1);
offset += length_st_support_surfaces;
memcpy( &(this->support_surfaces[i]), &(this->st_support_surfaces), sizeof(char*));
}
uint32_t candidate_grasps_lengthT = ((uint32_t) (*(inbuffer + offset)));
candidate_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
candidate_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
candidate_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->candidate_grasps_length);
if(candidate_grasps_lengthT > candidate_grasps_length)
this->candidate_grasps = (moveit_msgs::Grasp*)realloc(this->candidate_grasps, candidate_grasps_lengthT * sizeof(moveit_msgs::Grasp));
candidate_grasps_length = candidate_grasps_lengthT;
for( uint32_t i = 0; i < candidate_grasps_length; i++){
offset += this->st_candidate_grasps.deserialize(inbuffer + offset);
memcpy( &(this->candidate_grasps[i]), &(this->st_candidate_grasps), sizeof(moveit_msgs::Grasp));
}
uint32_t movable_obstacles_lengthT = ((uint32_t) (*(inbuffer + offset)));
movable_obstacles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
movable_obstacles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
movable_obstacles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->movable_obstacles_length);
if(movable_obstacles_lengthT > movable_obstacles_length)
this->movable_obstacles = (moveit_msgs::CollisionObject*)realloc(this->movable_obstacles, movable_obstacles_lengthT * sizeof(moveit_msgs::CollisionObject));
movable_obstacles_length = movable_obstacles_lengthT;
for( uint32_t i = 0; i < movable_obstacles_length; i++){
offset += this->st_movable_obstacles.deserialize(inbuffer + offset);
memcpy( &(this->movable_obstacles[i]), &(this->st_movable_obstacles), sizeof(moveit_msgs::CollisionObject));
}
return offset;
}
const char * getType(){ return GRASPPLANNING; };
const char * getMD5(){ return "c234e9a645708cc86b57a43999746ae6"; };
};
class GraspPlanningResponse : public ros::Msg
{
public:
uint32_t grasps_length;
typedef moveit_msgs::Grasp _grasps_type;
_grasps_type st_grasps;
_grasps_type * grasps;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GraspPlanningResponse():
grasps_length(0), grasps(NULL),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->grasps_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->grasps_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->grasps_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->grasps_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->grasps_length);
for( uint32_t i = 0; i < grasps_length; i++){
offset += this->grasps[i].serialize(outbuffer + offset);
}
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t grasps_lengthT = ((uint32_t) (*(inbuffer + offset)));
grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->grasps_length);
if(grasps_lengthT > grasps_length)
this->grasps = (moveit_msgs::Grasp*)realloc(this->grasps, grasps_lengthT * sizeof(moveit_msgs::Grasp));
grasps_length = grasps_lengthT;
for( uint32_t i = 0; i < grasps_length; i++){
offset += this->st_grasps.deserialize(inbuffer + offset);
memcpy( &(this->grasps[i]), &(this->st_grasps), sizeof(moveit_msgs::Grasp));
}
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GRASPPLANNING; };
const char * getMD5(){ return "bb8169d403b6e9f96bf61e22a50d13ae"; };
};
class GraspPlanning {
public:
typedef GraspPlanningRequest Request;
typedef GraspPlanningResponse Response;
};
}
#endif
| 9,642 | C | 44.2723 | 164 | 0.624974 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupResult.h | #ifndef _ROS_moveit_msgs_PickupResult_h
#define _ROS_moveit_msgs_PickupResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/Grasp.h"
namespace moveit_msgs
{
class PickupResult : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
uint32_t trajectory_stages_length;
typedef moveit_msgs::RobotTrajectory _trajectory_stages_type;
_trajectory_stages_type st_trajectory_stages;
_trajectory_stages_type * trajectory_stages;
uint32_t trajectory_descriptions_length;
typedef char* _trajectory_descriptions_type;
_trajectory_descriptions_type st_trajectory_descriptions;
_trajectory_descriptions_type * trajectory_descriptions;
typedef moveit_msgs::Grasp _grasp_type;
_grasp_type grasp;
typedef double _planning_time_type;
_planning_time_type planning_time;
PickupResult():
error_code(),
trajectory_start(),
trajectory_stages_length(0), trajectory_stages(NULL),
trajectory_descriptions_length(0), trajectory_descriptions(NULL),
grasp(),
planning_time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
offset += this->trajectory_start.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->trajectory_stages_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_stages_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_stages_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_stages_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_stages_length);
for( uint32_t i = 0; i < trajectory_stages_length; i++){
offset += this->trajectory_stages[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->trajectory_descriptions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_descriptions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_descriptions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_descriptions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_descriptions_length);
for( uint32_t i = 0; i < trajectory_descriptions_length; i++){
uint32_t length_trajectory_descriptionsi = strlen(this->trajectory_descriptions[i]);
varToArr(outbuffer + offset, length_trajectory_descriptionsi);
offset += 4;
memcpy(outbuffer + offset, this->trajectory_descriptions[i], length_trajectory_descriptionsi);
offset += length_trajectory_descriptionsi;
}
offset += this->grasp.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
offset += this->trajectory_start.deserialize(inbuffer + offset);
uint32_t trajectory_stages_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_stages_length);
if(trajectory_stages_lengthT > trajectory_stages_length)
this->trajectory_stages = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory_stages, trajectory_stages_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_stages_length = trajectory_stages_lengthT;
for( uint32_t i = 0; i < trajectory_stages_length; i++){
offset += this->st_trajectory_stages.deserialize(inbuffer + offset);
memcpy( &(this->trajectory_stages[i]), &(this->st_trajectory_stages), sizeof(moveit_msgs::RobotTrajectory));
}
uint32_t trajectory_descriptions_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_descriptions_length);
if(trajectory_descriptions_lengthT > trajectory_descriptions_length)
this->trajectory_descriptions = (char**)realloc(this->trajectory_descriptions, trajectory_descriptions_lengthT * sizeof(char*));
trajectory_descriptions_length = trajectory_descriptions_lengthT;
for( uint32_t i = 0; i < trajectory_descriptions_length; i++){
uint32_t length_st_trajectory_descriptions;
arrToVar(length_st_trajectory_descriptions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_trajectory_descriptions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_trajectory_descriptions-1]=0;
this->st_trajectory_descriptions = (char *)(inbuffer + offset-1);
offset += length_st_trajectory_descriptions;
memcpy( &(this->trajectory_descriptions[i]), &(this->st_trajectory_descriptions), sizeof(char*));
}
offset += this->grasp.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupResult"; };
const char * getMD5(){ return "c1e72234397d9de0761966243e264774"; };
};
}
#endif
| 7,545 | C | 48.644737 | 164 | 0.628761 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanRequest.h | #ifndef _ROS_moveit_msgs_MotionPlanRequest_h
#define _ROS_moveit_msgs_MotionPlanRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/WorkspaceParameters.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/Constraints.h"
#include "moveit_msgs/TrajectoryConstraints.h"
namespace moveit_msgs
{
class MotionPlanRequest : public ros::Msg
{
public:
typedef moveit_msgs::WorkspaceParameters _workspace_parameters_type;
_workspace_parameters_type workspace_parameters;
typedef moveit_msgs::RobotState _start_state_type;
_start_state_type start_state;
uint32_t goal_constraints_length;
typedef moveit_msgs::Constraints _goal_constraints_type;
_goal_constraints_type st_goal_constraints;
_goal_constraints_type * goal_constraints;
typedef moveit_msgs::Constraints _path_constraints_type;
_path_constraints_type path_constraints;
typedef moveit_msgs::TrajectoryConstraints _trajectory_constraints_type;
_trajectory_constraints_type trajectory_constraints;
typedef const char* _planner_id_type;
_planner_id_type planner_id;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef int32_t _num_planning_attempts_type;
_num_planning_attempts_type num_planning_attempts;
typedef double _allowed_planning_time_type;
_allowed_planning_time_type allowed_planning_time;
typedef double _max_velocity_scaling_factor_type;
_max_velocity_scaling_factor_type max_velocity_scaling_factor;
typedef double _max_acceleration_scaling_factor_type;
_max_acceleration_scaling_factor_type max_acceleration_scaling_factor;
MotionPlanRequest():
workspace_parameters(),
start_state(),
goal_constraints_length(0), goal_constraints(NULL),
path_constraints(),
trajectory_constraints(),
planner_id(""),
group_name(""),
num_planning_attempts(0),
allowed_planning_time(0),
max_velocity_scaling_factor(0),
max_acceleration_scaling_factor(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->workspace_parameters.serialize(outbuffer + offset);
offset += this->start_state.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->goal_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->goal_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->goal_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->goal_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->goal_constraints_length);
for( uint32_t i = 0; i < goal_constraints_length; i++){
offset += this->goal_constraints[i].serialize(outbuffer + offset);
}
offset += this->path_constraints.serialize(outbuffer + offset);
offset += this->trajectory_constraints.serialize(outbuffer + offset);
uint32_t length_planner_id = strlen(this->planner_id);
varToArr(outbuffer + offset, length_planner_id);
offset += 4;
memcpy(outbuffer + offset, this->planner_id, length_planner_id);
offset += length_planner_id;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
union {
int32_t real;
uint32_t base;
} u_num_planning_attempts;
u_num_planning_attempts.real = this->num_planning_attempts;
*(outbuffer + offset + 0) = (u_num_planning_attempts.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_num_planning_attempts.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_num_planning_attempts.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_num_planning_attempts.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->num_planning_attempts);
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.real = this->allowed_planning_time;
*(outbuffer + offset + 0) = (u_allowed_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_allowed_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_allowed_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_allowed_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_allowed_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_allowed_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_allowed_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_allowed_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->allowed_planning_time);
union {
double real;
uint64_t base;
} u_max_velocity_scaling_factor;
u_max_velocity_scaling_factor.real = this->max_velocity_scaling_factor;
*(outbuffer + offset + 0) = (u_max_velocity_scaling_factor.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_velocity_scaling_factor.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_velocity_scaling_factor.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_velocity_scaling_factor.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_velocity_scaling_factor.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_velocity_scaling_factor.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_velocity_scaling_factor.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_velocity_scaling_factor.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_velocity_scaling_factor);
union {
double real;
uint64_t base;
} u_max_acceleration_scaling_factor;
u_max_acceleration_scaling_factor.real = this->max_acceleration_scaling_factor;
*(outbuffer + offset + 0) = (u_max_acceleration_scaling_factor.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_acceleration_scaling_factor.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_acceleration_scaling_factor.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_acceleration_scaling_factor.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_acceleration_scaling_factor.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_acceleration_scaling_factor.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_acceleration_scaling_factor.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_acceleration_scaling_factor.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_acceleration_scaling_factor);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->workspace_parameters.deserialize(inbuffer + offset);
offset += this->start_state.deserialize(inbuffer + offset);
uint32_t goal_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
goal_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
goal_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
goal_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->goal_constraints_length);
if(goal_constraints_lengthT > goal_constraints_length)
this->goal_constraints = (moveit_msgs::Constraints*)realloc(this->goal_constraints, goal_constraints_lengthT * sizeof(moveit_msgs::Constraints));
goal_constraints_length = goal_constraints_lengthT;
for( uint32_t i = 0; i < goal_constraints_length; i++){
offset += this->st_goal_constraints.deserialize(inbuffer + offset);
memcpy( &(this->goal_constraints[i]), &(this->st_goal_constraints), sizeof(moveit_msgs::Constraints));
}
offset += this->path_constraints.deserialize(inbuffer + offset);
offset += this->trajectory_constraints.deserialize(inbuffer + offset);
uint32_t length_planner_id;
arrToVar(length_planner_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_id-1]=0;
this->planner_id = (char *)(inbuffer + offset-1);
offset += length_planner_id;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
union {
int32_t real;
uint32_t base;
} u_num_planning_attempts;
u_num_planning_attempts.base = 0;
u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_num_planning_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->num_planning_attempts = u_num_planning_attempts.real;
offset += sizeof(this->num_planning_attempts);
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.base = 0;
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->allowed_planning_time = u_allowed_planning_time.real;
offset += sizeof(this->allowed_planning_time);
union {
double real;
uint64_t base;
} u_max_velocity_scaling_factor;
u_max_velocity_scaling_factor.base = 0;
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_velocity_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_velocity_scaling_factor = u_max_velocity_scaling_factor.real;
offset += sizeof(this->max_velocity_scaling_factor);
union {
double real;
uint64_t base;
} u_max_acceleration_scaling_factor;
u_max_acceleration_scaling_factor.base = 0;
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_acceleration_scaling_factor.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_acceleration_scaling_factor = u_max_acceleration_scaling_factor.real;
offset += sizeof(this->max_acceleration_scaling_factor);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionPlanRequest"; };
const char * getMD5(){ return "c3bec13a525a6ae66e0fc57b768fdca6"; };
};
}
#endif
| 12,859 | C | 52.140496 | 153 | 0.614356 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceActionFeedback.h | #ifndef _ROS_moveit_msgs_PlaceActionFeedback_h
#define _ROS_moveit_msgs_PlaceActionFeedback_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 "moveit_msgs/PlaceFeedback.h"
namespace moveit_msgs
{
class PlaceActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::PlaceFeedback _feedback_type;
_feedback_type feedback;
PlaceActionFeedback():
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 "moveit_msgs/PlaceActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
| 1,454 | C | 24.526315 | 72 | 0.665062 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryFeedback.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryFeedback_h
#define _ROS_moveit_msgs_ExecuteTrajectoryFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class ExecuteTrajectoryFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
ExecuteTrajectoryFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/ExecuteTrajectoryFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
| 1,340 | C | 22.946428 | 78 | 0.632836 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryGoal.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryGoal_h
#define _ROS_moveit_msgs_ExecuteTrajectoryGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotTrajectory.h"
namespace moveit_msgs
{
class ExecuteTrajectoryGoal : public ros::Msg
{
public:
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type trajectory;
ExecuteTrajectoryGoal():
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 "moveit_msgs/ExecuteTrajectoryGoal"; };
const char * getMD5(){ return "054c09e62210d7faad2f9fffdad07b57"; };
};
}
#endif
| 984 | C | 20.888888 | 74 | 0.675813 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupActionResult.h | #ifndef _ROS_moveit_msgs_PickupActionResult_h
#define _ROS_moveit_msgs_PickupActionResult_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 "moveit_msgs/PickupResult.h"
namespace moveit_msgs
{
class PickupActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::PickupResult _result_type;
_result_type result;
PickupActionResult():
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 "moveit_msgs/PickupActionResult"; };
const char * getMD5(){ return "4c148688ab234ff8a8c02f1b8360c1bb"; };
};
}
#endif
| 1,435 | C | 24.192982 | 72 | 0.660627 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/Grasp.h | #ifndef _ROS_moveit_msgs_Grasp_h
#define _ROS_moveit_msgs_Grasp_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "geometry_msgs/PoseStamped.h"
#include "moveit_msgs/GripperTranslation.h"
namespace moveit_msgs
{
class Grasp : public ros::Msg
{
public:
typedef const char* _id_type;
_id_type id;
typedef trajectory_msgs::JointTrajectory _pre_grasp_posture_type;
_pre_grasp_posture_type pre_grasp_posture;
typedef trajectory_msgs::JointTrajectory _grasp_posture_type;
_grasp_posture_type grasp_posture;
typedef geometry_msgs::PoseStamped _grasp_pose_type;
_grasp_pose_type grasp_pose;
typedef double _grasp_quality_type;
_grasp_quality_type grasp_quality;
typedef moveit_msgs::GripperTranslation _pre_grasp_approach_type;
_pre_grasp_approach_type pre_grasp_approach;
typedef moveit_msgs::GripperTranslation _post_grasp_retreat_type;
_post_grasp_retreat_type post_grasp_retreat;
typedef moveit_msgs::GripperTranslation _post_place_retreat_type;
_post_place_retreat_type post_place_retreat;
typedef float _max_contact_force_type;
_max_contact_force_type max_contact_force;
uint32_t allowed_touch_objects_length;
typedef char* _allowed_touch_objects_type;
_allowed_touch_objects_type st_allowed_touch_objects;
_allowed_touch_objects_type * allowed_touch_objects;
Grasp():
id(""),
pre_grasp_posture(),
grasp_posture(),
grasp_pose(),
grasp_quality(0),
pre_grasp_approach(),
post_grasp_retreat(),
post_place_retreat(),
max_contact_force(0),
allowed_touch_objects_length(0), allowed_touch_objects(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;
offset += this->pre_grasp_posture.serialize(outbuffer + offset);
offset += this->grasp_posture.serialize(outbuffer + offset);
offset += this->grasp_pose.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_grasp_quality;
u_grasp_quality.real = this->grasp_quality;
*(outbuffer + offset + 0) = (u_grasp_quality.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_grasp_quality.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_grasp_quality.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_grasp_quality.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_grasp_quality.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_grasp_quality.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_grasp_quality.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_grasp_quality.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->grasp_quality);
offset += this->pre_grasp_approach.serialize(outbuffer + offset);
offset += this->post_grasp_retreat.serialize(outbuffer + offset);
offset += this->post_place_retreat.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_max_contact_force;
u_max_contact_force.real = this->max_contact_force;
*(outbuffer + offset + 0) = (u_max_contact_force.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_contact_force.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_contact_force.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_contact_force.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_contact_force);
*(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->allowed_touch_objects_length);
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]);
varToArr(outbuffer + offset, length_allowed_touch_objectsi);
offset += 4;
memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi);
offset += length_allowed_touch_objectsi;
}
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;
offset += this->pre_grasp_posture.deserialize(inbuffer + offset);
offset += this->grasp_posture.deserialize(inbuffer + offset);
offset += this->grasp_pose.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_grasp_quality;
u_grasp_quality.base = 0;
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_grasp_quality.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->grasp_quality = u_grasp_quality.real;
offset += sizeof(this->grasp_quality);
offset += this->pre_grasp_approach.deserialize(inbuffer + offset);
offset += this->post_grasp_retreat.deserialize(inbuffer + offset);
offset += this->post_place_retreat.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_max_contact_force;
u_max_contact_force.base = 0;
u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_contact_force.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->max_contact_force = u_max_contact_force.real;
offset += sizeof(this->max_contact_force);
uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->allowed_touch_objects_length);
if(allowed_touch_objects_lengthT > allowed_touch_objects_length)
this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*));
allowed_touch_objects_length = allowed_touch_objects_lengthT;
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_st_allowed_touch_objects;
arrToVar(length_st_allowed_touch_objects, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_allowed_touch_objects-1]=0;
this->st_allowed_touch_objects = (char *)(inbuffer + offset-1);
offset += length_st_allowed_touch_objects;
memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/Grasp"; };
const char * getMD5(){ return "e26c8fb64f589c33c5d5e54bd7b5e4cb"; };
};
}
#endif
| 8,381 | C | 45.054945 | 130 | 0.609832 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ContactInformation.h | #ifndef _ROS_moveit_msgs_ContactInformation_h
#define _ROS_moveit_msgs_ContactInformation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Point.h"
#include "geometry_msgs/Vector3.h"
namespace moveit_msgs
{
class ContactInformation : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Point _position_type;
_position_type position;
typedef geometry_msgs::Vector3 _normal_type;
_normal_type normal;
typedef double _depth_type;
_depth_type depth;
typedef const char* _contact_body_1_type;
_contact_body_1_type contact_body_1;
typedef uint32_t _body_type_1_type;
_body_type_1_type body_type_1;
typedef const char* _contact_body_2_type;
_contact_body_2_type contact_body_2;
typedef uint32_t _body_type_2_type;
_body_type_2_type body_type_2;
enum { ROBOT_LINK = 0 };
enum { WORLD_OBJECT = 1 };
enum { ROBOT_ATTACHED = 2 };
ContactInformation():
header(),
position(),
normal(),
depth(0),
contact_body_1(""),
body_type_1(0),
contact_body_2(""),
body_type_2(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->position.serialize(outbuffer + offset);
offset += this->normal.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_depth;
u_depth.real = this->depth;
*(outbuffer + offset + 0) = (u_depth.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_depth.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_depth.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_depth.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_depth.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_depth.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_depth.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_depth.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->depth);
uint32_t length_contact_body_1 = strlen(this->contact_body_1);
varToArr(outbuffer + offset, length_contact_body_1);
offset += 4;
memcpy(outbuffer + offset, this->contact_body_1, length_contact_body_1);
offset += length_contact_body_1;
*(outbuffer + offset + 0) = (this->body_type_1 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->body_type_1 >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->body_type_1 >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->body_type_1 >> (8 * 3)) & 0xFF;
offset += sizeof(this->body_type_1);
uint32_t length_contact_body_2 = strlen(this->contact_body_2);
varToArr(outbuffer + offset, length_contact_body_2);
offset += 4;
memcpy(outbuffer + offset, this->contact_body_2, length_contact_body_2);
offset += length_contact_body_2;
*(outbuffer + offset + 0) = (this->body_type_2 >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->body_type_2 >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->body_type_2 >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->body_type_2 >> (8 * 3)) & 0xFF;
offset += sizeof(this->body_type_2);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->position.deserialize(inbuffer + offset);
offset += this->normal.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_depth;
u_depth.base = 0;
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_depth.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->depth = u_depth.real;
offset += sizeof(this->depth);
uint32_t length_contact_body_1;
arrToVar(length_contact_body_1, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_contact_body_1; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_contact_body_1-1]=0;
this->contact_body_1 = (char *)(inbuffer + offset-1);
offset += length_contact_body_1;
this->body_type_1 = ((uint32_t) (*(inbuffer + offset)));
this->body_type_1 |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->body_type_1 |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->body_type_1 |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->body_type_1);
uint32_t length_contact_body_2;
arrToVar(length_contact_body_2, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_contact_body_2; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_contact_body_2-1]=0;
this->contact_body_2 = (char *)(inbuffer + offset-1);
offset += length_contact_body_2;
this->body_type_2 = ((uint32_t) (*(inbuffer + offset)));
this->body_type_2 |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->body_type_2 |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->body_type_2 |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->body_type_2);
return offset;
}
const char * getType(){ return "moveit_msgs/ContactInformation"; };
const char * getMD5(){ return "116228ca08b0c286ec5ca32a50fdc17b"; };
};
}
#endif
| 6,147 | C | 39.447368 | 78 | 0.562388 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningSceneComponents.h | #ifndef _ROS_moveit_msgs_PlanningSceneComponents_h
#define _ROS_moveit_msgs_PlanningSceneComponents_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PlanningSceneComponents : public ros::Msg
{
public:
typedef uint32_t _components_type;
_components_type components;
enum { SCENE_SETTINGS = 1 };
enum { ROBOT_STATE = 2 };
enum { ROBOT_STATE_ATTACHED_OBJECTS = 4 };
enum { WORLD_OBJECT_NAMES = 8 };
enum { WORLD_OBJECT_GEOMETRY = 16 };
enum { OCTOMAP = 32 };
enum { TRANSFORMS = 64 };
enum { ALLOWED_COLLISION_MATRIX = 128 };
enum { LINK_PADDING_AND_SCALING = 256 };
enum { OBJECT_COLORS = 512 };
PlanningSceneComponents():
components(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->components >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->components >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->components >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->components >> (8 * 3)) & 0xFF;
offset += sizeof(this->components);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->components = ((uint32_t) (*(inbuffer + offset)));
this->components |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->components |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->components |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->components);
return offset;
}
const char * getType(){ return "moveit_msgs/PlanningSceneComponents"; };
const char * getMD5(){ return "bc993e784476960b918b6e7ad5bb58ce"; };
};
}
#endif
| 1,863 | C | 29.064516 | 77 | 0.587762 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupActionFeedback.h | #ifndef _ROS_moveit_msgs_PickupActionFeedback_h
#define _ROS_moveit_msgs_PickupActionFeedback_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 "moveit_msgs/PickupFeedback.h"
namespace moveit_msgs
{
class PickupActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::PickupFeedback _feedback_type;
_feedback_type feedback;
PickupActionFeedback():
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 "moveit_msgs/PickupActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
| 1,461 | C | 24.649122 | 73 | 0.666667 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryResult.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryResult_h
#define _ROS_moveit_msgs_ExecuteTrajectoryResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
namespace moveit_msgs
{
class ExecuteTrajectoryResult : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
ExecuteTrajectoryResult():
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/ExecuteTrajectoryResult"; };
const char * getMD5(){ return "1f7ab918f5d0c5312f25263d3d688122"; };
};
}
#endif
| 996 | C | 21.155555 | 76 | 0.673695 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ChangeDriftDimensions.h | #ifndef _ROS_SERVICE_ChangeDriftDimensions_h
#define _ROS_SERVICE_ChangeDriftDimensions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Transform.h"
namespace moveit_msgs
{
static const char CHANGEDRIFTDIMENSIONS[] = "moveit_msgs/ChangeDriftDimensions";
class ChangeDriftDimensionsRequest : public ros::Msg
{
public:
typedef bool _drift_x_translation_type;
_drift_x_translation_type drift_x_translation;
typedef bool _drift_y_translation_type;
_drift_y_translation_type drift_y_translation;
typedef bool _drift_z_translation_type;
_drift_z_translation_type drift_z_translation;
typedef bool _drift_x_rotation_type;
_drift_x_rotation_type drift_x_rotation;
typedef bool _drift_y_rotation_type;
_drift_y_rotation_type drift_y_rotation;
typedef bool _drift_z_rotation_type;
_drift_z_rotation_type drift_z_rotation;
typedef geometry_msgs::Transform _transform_jog_frame_to_drift_frame_type;
_transform_jog_frame_to_drift_frame_type transform_jog_frame_to_drift_frame;
ChangeDriftDimensionsRequest():
drift_x_translation(0),
drift_y_translation(0),
drift_z_translation(0),
drift_x_rotation(0),
drift_y_rotation(0),
drift_z_rotation(0),
transform_jog_frame_to_drift_frame()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_drift_x_translation;
u_drift_x_translation.real = this->drift_x_translation;
*(outbuffer + offset + 0) = (u_drift_x_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_x_translation);
union {
bool real;
uint8_t base;
} u_drift_y_translation;
u_drift_y_translation.real = this->drift_y_translation;
*(outbuffer + offset + 0) = (u_drift_y_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_y_translation);
union {
bool real;
uint8_t base;
} u_drift_z_translation;
u_drift_z_translation.real = this->drift_z_translation;
*(outbuffer + offset + 0) = (u_drift_z_translation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_z_translation);
union {
bool real;
uint8_t base;
} u_drift_x_rotation;
u_drift_x_rotation.real = this->drift_x_rotation;
*(outbuffer + offset + 0) = (u_drift_x_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_x_rotation);
union {
bool real;
uint8_t base;
} u_drift_y_rotation;
u_drift_y_rotation.real = this->drift_y_rotation;
*(outbuffer + offset + 0) = (u_drift_y_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_y_rotation);
union {
bool real;
uint8_t base;
} u_drift_z_rotation;
u_drift_z_rotation.real = this->drift_z_rotation;
*(outbuffer + offset + 0) = (u_drift_z_rotation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->drift_z_rotation);
offset += this->transform_jog_frame_to_drift_frame.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_drift_x_translation;
u_drift_x_translation.base = 0;
u_drift_x_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_x_translation = u_drift_x_translation.real;
offset += sizeof(this->drift_x_translation);
union {
bool real;
uint8_t base;
} u_drift_y_translation;
u_drift_y_translation.base = 0;
u_drift_y_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_y_translation = u_drift_y_translation.real;
offset += sizeof(this->drift_y_translation);
union {
bool real;
uint8_t base;
} u_drift_z_translation;
u_drift_z_translation.base = 0;
u_drift_z_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_z_translation = u_drift_z_translation.real;
offset += sizeof(this->drift_z_translation);
union {
bool real;
uint8_t base;
} u_drift_x_rotation;
u_drift_x_rotation.base = 0;
u_drift_x_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_x_rotation = u_drift_x_rotation.real;
offset += sizeof(this->drift_x_rotation);
union {
bool real;
uint8_t base;
} u_drift_y_rotation;
u_drift_y_rotation.base = 0;
u_drift_y_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_y_rotation = u_drift_y_rotation.real;
offset += sizeof(this->drift_y_rotation);
union {
bool real;
uint8_t base;
} u_drift_z_rotation;
u_drift_z_rotation.base = 0;
u_drift_z_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->drift_z_rotation = u_drift_z_rotation.real;
offset += sizeof(this->drift_z_rotation);
offset += this->transform_jog_frame_to_drift_frame.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return CHANGEDRIFTDIMENSIONS; };
const char * getMD5(){ return "4a5ce44f94cdee672e699df89b1ebaf1"; };
};
class ChangeDriftDimensionsResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
ChangeDriftDimensionsResponse():
success(0)
{
}
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);
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);
return offset;
}
const char * getType(){ return CHANGEDRIFTDIMENSIONS; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class ChangeDriftDimensions {
public:
typedef ChangeDriftDimensionsRequest Request;
typedef ChangeDriftDimensionsResponse Response;
};
}
#endif
| 6,653 | C | 31.778325 | 88 | 0.603337 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPositionFK.h | #ifndef _ROS_SERVICE_GetPositionFK_h
#define _ROS_SERVICE_GetPositionFK_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "geometry_msgs/PoseStamped.h"
#include "std_msgs/Header.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
static const char GETPOSITIONFK[] = "moveit_msgs/GetPositionFK";
class GetPositionFKRequest : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t fk_link_names_length;
typedef char* _fk_link_names_type;
_fk_link_names_type st_fk_link_names;
_fk_link_names_type * fk_link_names;
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
GetPositionFKRequest():
header(),
fk_link_names_length(0), fk_link_names(NULL),
robot_state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->fk_link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fk_link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fk_link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fk_link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fk_link_names_length);
for( uint32_t i = 0; i < fk_link_names_length; i++){
uint32_t length_fk_link_namesi = strlen(this->fk_link_names[i]);
varToArr(outbuffer + offset, length_fk_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->fk_link_names[i], length_fk_link_namesi);
offset += length_fk_link_namesi;
}
offset += this->robot_state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t fk_link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fk_link_names_length);
if(fk_link_names_lengthT > fk_link_names_length)
this->fk_link_names = (char**)realloc(this->fk_link_names, fk_link_names_lengthT * sizeof(char*));
fk_link_names_length = fk_link_names_lengthT;
for( uint32_t i = 0; i < fk_link_names_length; i++){
uint32_t length_st_fk_link_names;
arrToVar(length_st_fk_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_fk_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_fk_link_names-1]=0;
this->st_fk_link_names = (char *)(inbuffer + offset-1);
offset += length_st_fk_link_names;
memcpy( &(this->fk_link_names[i]), &(this->st_fk_link_names), sizeof(char*));
}
offset += this->robot_state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONFK; };
const char * getMD5(){ return "1d1ed72044ed56f6246c31b522781797"; };
};
class GetPositionFKResponse : public ros::Msg
{
public:
uint32_t pose_stamped_length;
typedef geometry_msgs::PoseStamped _pose_stamped_type;
_pose_stamped_type st_pose_stamped;
_pose_stamped_type * pose_stamped;
uint32_t fk_link_names_length;
typedef char* _fk_link_names_type;
_fk_link_names_type st_fk_link_names;
_fk_link_names_type * fk_link_names;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GetPositionFKResponse():
pose_stamped_length(0), pose_stamped(NULL),
fk_link_names_length(0), fk_link_names(NULL),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->pose_stamped_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_stamped_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_stamped_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_stamped_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_stamped_length);
for( uint32_t i = 0; i < pose_stamped_length; i++){
offset += this->pose_stamped[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->fk_link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fk_link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fk_link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fk_link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fk_link_names_length);
for( uint32_t i = 0; i < fk_link_names_length; i++){
uint32_t length_fk_link_namesi = strlen(this->fk_link_names[i]);
varToArr(outbuffer + offset, length_fk_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->fk_link_names[i], length_fk_link_namesi);
offset += length_fk_link_namesi;
}
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t pose_stamped_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_stamped_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_stamped_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_stamped_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_stamped_length);
if(pose_stamped_lengthT > pose_stamped_length)
this->pose_stamped = (geometry_msgs::PoseStamped*)realloc(this->pose_stamped, pose_stamped_lengthT * sizeof(geometry_msgs::PoseStamped));
pose_stamped_length = pose_stamped_lengthT;
for( uint32_t i = 0; i < pose_stamped_length; i++){
offset += this->st_pose_stamped.deserialize(inbuffer + offset);
memcpy( &(this->pose_stamped[i]), &(this->st_pose_stamped), sizeof(geometry_msgs::PoseStamped));
}
uint32_t fk_link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fk_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fk_link_names_length);
if(fk_link_names_lengthT > fk_link_names_length)
this->fk_link_names = (char**)realloc(this->fk_link_names, fk_link_names_lengthT * sizeof(char*));
fk_link_names_length = fk_link_names_lengthT;
for( uint32_t i = 0; i < fk_link_names_length; i++){
uint32_t length_st_fk_link_names;
arrToVar(length_st_fk_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_fk_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_fk_link_names-1]=0;
this->st_fk_link_names = (char *)(inbuffer + offset-1);
offset += length_st_fk_link_names;
memcpy( &(this->fk_link_names[i]), &(this->st_fk_link_names), sizeof(char*));
}
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONFK; };
const char * getMD5(){ return "297215cf4fdfe0008356995ae621dae6"; };
};
class GetPositionFK {
public:
typedef GetPositionFKRequest Request;
typedef GetPositionFKResponse Response;
};
}
#endif
| 7,911 | C | 40.862434 | 145 | 0.608393 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CheckIfRobotStateExistsInWarehouse.h | #ifndef _ROS_SERVICE_CheckIfRobotStateExistsInWarehouse_h
#define _ROS_SERVICE_CheckIfRobotStateExistsInWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char CHECKIFROBOTSTATEEXISTSINWAREHOUSE[] = "moveit_msgs/CheckIfRobotStateExistsInWarehouse";
class CheckIfRobotStateExistsInWarehouseRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _robot_type;
_robot_type robot;
CheckIfRobotStateExistsInWarehouseRequest():
name(""),
robot("")
{
}
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_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
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_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return CHECKIFROBOTSTATEEXISTSINWAREHOUSE; };
const char * getMD5(){ return "dab44354403f811c40b84964e068219c"; };
};
class CheckIfRobotStateExistsInWarehouseResponse : public ros::Msg
{
public:
typedef bool _exists_type;
_exists_type exists;
CheckIfRobotStateExistsInWarehouseResponse():
exists(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_exists;
u_exists.real = this->exists;
*(outbuffer + offset + 0) = (u_exists.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->exists);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_exists;
u_exists.base = 0;
u_exists.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->exists = u_exists.real;
offset += sizeof(this->exists);
return offset;
}
const char * getType(){ return CHECKIFROBOTSTATEEXISTSINWAREHOUSE; };
const char * getMD5(){ return "e8c90de4adc1219c86af9c2874c0c1b5"; };
};
class CheckIfRobotStateExistsInWarehouse {
public:
typedef CheckIfRobotStateExistsInWarehouseRequest Request;
typedef CheckIfRobotStateExistsInWarehouseResponse Response;
};
}
#endif
| 3,344 | C | 26.195122 | 106 | 0.629486 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DeleteRobotStateFromWarehouse.h | #ifndef _ROS_SERVICE_DeleteRobotStateFromWarehouse_h
#define _ROS_SERVICE_DeleteRobotStateFromWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char DELETEROBOTSTATEFROMWAREHOUSE[] = "moveit_msgs/DeleteRobotStateFromWarehouse";
class DeleteRobotStateFromWarehouseRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _robot_type;
_robot_type robot;
DeleteRobotStateFromWarehouseRequest():
name(""),
robot("")
{
}
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_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
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_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return DELETEROBOTSTATEFROMWAREHOUSE; };
const char * getMD5(){ return "dab44354403f811c40b84964e068219c"; };
};
class DeleteRobotStateFromWarehouseResponse : public ros::Msg
{
public:
DeleteRobotStateFromWarehouseResponse()
{
}
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 DELETEROBOTSTATEFROMWAREHOUSE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class DeleteRobotStateFromWarehouse {
public:
typedef DeleteRobotStateFromWarehouseRequest Request;
typedef DeleteRobotStateFromWarehouseResponse Response;
};
}
#endif
| 2,740 | C | 25.104762 | 96 | 0.64635 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupGoal.h | #ifndef _ROS_moveit_msgs_PickupGoal_h
#define _ROS_moveit_msgs_PickupGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/Grasp.h"
#include "moveit_msgs/Constraints.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class PickupGoal : public ros::Msg
{
public:
typedef const char* _target_name_type;
_target_name_type target_name;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef const char* _end_effector_type;
_end_effector_type end_effector;
uint32_t possible_grasps_length;
typedef moveit_msgs::Grasp _possible_grasps_type;
_possible_grasps_type st_possible_grasps;
_possible_grasps_type * possible_grasps;
typedef const char* _support_surface_name_type;
_support_surface_name_type support_surface_name;
typedef bool _allow_gripper_support_collision_type;
_allow_gripper_support_collision_type allow_gripper_support_collision;
uint32_t attached_object_touch_links_length;
typedef char* _attached_object_touch_links_type;
_attached_object_touch_links_type st_attached_object_touch_links;
_attached_object_touch_links_type * attached_object_touch_links;
typedef bool _minimize_object_distance_type;
_minimize_object_distance_type minimize_object_distance;
typedef moveit_msgs::Constraints _path_constraints_type;
_path_constraints_type path_constraints;
typedef const char* _planner_id_type;
_planner_id_type planner_id;
uint32_t allowed_touch_objects_length;
typedef char* _allowed_touch_objects_type;
_allowed_touch_objects_type st_allowed_touch_objects;
_allowed_touch_objects_type * allowed_touch_objects;
typedef double _allowed_planning_time_type;
_allowed_planning_time_type allowed_planning_time;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
PickupGoal():
target_name(""),
group_name(""),
end_effector(""),
possible_grasps_length(0), possible_grasps(NULL),
support_surface_name(""),
allow_gripper_support_collision(0),
attached_object_touch_links_length(0), attached_object_touch_links(NULL),
minimize_object_distance(0),
path_constraints(),
planner_id(""),
allowed_touch_objects_length(0), allowed_touch_objects(NULL),
allowed_planning_time(0),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_target_name = strlen(this->target_name);
varToArr(outbuffer + offset, length_target_name);
offset += 4;
memcpy(outbuffer + offset, this->target_name, length_target_name);
offset += length_target_name;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
uint32_t length_end_effector = strlen(this->end_effector);
varToArr(outbuffer + offset, length_end_effector);
offset += 4;
memcpy(outbuffer + offset, this->end_effector, length_end_effector);
offset += length_end_effector;
*(outbuffer + offset + 0) = (this->possible_grasps_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->possible_grasps_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->possible_grasps_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->possible_grasps_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->possible_grasps_length);
for( uint32_t i = 0; i < possible_grasps_length; i++){
offset += this->possible_grasps[i].serialize(outbuffer + offset);
}
uint32_t length_support_surface_name = strlen(this->support_surface_name);
varToArr(outbuffer + offset, length_support_surface_name);
offset += 4;
memcpy(outbuffer + offset, this->support_surface_name, length_support_surface_name);
offset += length_support_surface_name;
union {
bool real;
uint8_t base;
} u_allow_gripper_support_collision;
u_allow_gripper_support_collision.real = this->allow_gripper_support_collision;
*(outbuffer + offset + 0) = (u_allow_gripper_support_collision.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->allow_gripper_support_collision);
*(outbuffer + offset + 0) = (this->attached_object_touch_links_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->attached_object_touch_links_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->attached_object_touch_links_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->attached_object_touch_links_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->attached_object_touch_links_length);
for( uint32_t i = 0; i < attached_object_touch_links_length; i++){
uint32_t length_attached_object_touch_linksi = strlen(this->attached_object_touch_links[i]);
varToArr(outbuffer + offset, length_attached_object_touch_linksi);
offset += 4;
memcpy(outbuffer + offset, this->attached_object_touch_links[i], length_attached_object_touch_linksi);
offset += length_attached_object_touch_linksi;
}
union {
bool real;
uint8_t base;
} u_minimize_object_distance;
u_minimize_object_distance.real = this->minimize_object_distance;
*(outbuffer + offset + 0) = (u_minimize_object_distance.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->minimize_object_distance);
offset += this->path_constraints.serialize(outbuffer + offset);
uint32_t length_planner_id = strlen(this->planner_id);
varToArr(outbuffer + offset, length_planner_id);
offset += 4;
memcpy(outbuffer + offset, this->planner_id, length_planner_id);
offset += length_planner_id;
*(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->allowed_touch_objects_length);
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]);
varToArr(outbuffer + offset, length_allowed_touch_objectsi);
offset += 4;
memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi);
offset += length_allowed_touch_objectsi;
}
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.real = this->allowed_planning_time;
*(outbuffer + offset + 0) = (u_allowed_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_allowed_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_allowed_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_allowed_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_allowed_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_allowed_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_allowed_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_allowed_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->allowed_planning_time);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_target_name;
arrToVar(length_target_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_target_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_target_name-1]=0;
this->target_name = (char *)(inbuffer + offset-1);
offset += length_target_name;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
uint32_t length_end_effector;
arrToVar(length_end_effector, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_end_effector; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_end_effector-1]=0;
this->end_effector = (char *)(inbuffer + offset-1);
offset += length_end_effector;
uint32_t possible_grasps_lengthT = ((uint32_t) (*(inbuffer + offset)));
possible_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
possible_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
possible_grasps_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->possible_grasps_length);
if(possible_grasps_lengthT > possible_grasps_length)
this->possible_grasps = (moveit_msgs::Grasp*)realloc(this->possible_grasps, possible_grasps_lengthT * sizeof(moveit_msgs::Grasp));
possible_grasps_length = possible_grasps_lengthT;
for( uint32_t i = 0; i < possible_grasps_length; i++){
offset += this->st_possible_grasps.deserialize(inbuffer + offset);
memcpy( &(this->possible_grasps[i]), &(this->st_possible_grasps), sizeof(moveit_msgs::Grasp));
}
uint32_t length_support_surface_name;
arrToVar(length_support_surface_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_support_surface_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_support_surface_name-1]=0;
this->support_surface_name = (char *)(inbuffer + offset-1);
offset += length_support_surface_name;
union {
bool real;
uint8_t base;
} u_allow_gripper_support_collision;
u_allow_gripper_support_collision.base = 0;
u_allow_gripper_support_collision.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->allow_gripper_support_collision = u_allow_gripper_support_collision.real;
offset += sizeof(this->allow_gripper_support_collision);
uint32_t attached_object_touch_links_lengthT = ((uint32_t) (*(inbuffer + offset)));
attached_object_touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
attached_object_touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
attached_object_touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->attached_object_touch_links_length);
if(attached_object_touch_links_lengthT > attached_object_touch_links_length)
this->attached_object_touch_links = (char**)realloc(this->attached_object_touch_links, attached_object_touch_links_lengthT * sizeof(char*));
attached_object_touch_links_length = attached_object_touch_links_lengthT;
for( uint32_t i = 0; i < attached_object_touch_links_length; i++){
uint32_t length_st_attached_object_touch_links;
arrToVar(length_st_attached_object_touch_links, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_attached_object_touch_links; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_attached_object_touch_links-1]=0;
this->st_attached_object_touch_links = (char *)(inbuffer + offset-1);
offset += length_st_attached_object_touch_links;
memcpy( &(this->attached_object_touch_links[i]), &(this->st_attached_object_touch_links), sizeof(char*));
}
union {
bool real;
uint8_t base;
} u_minimize_object_distance;
u_minimize_object_distance.base = 0;
u_minimize_object_distance.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->minimize_object_distance = u_minimize_object_distance.real;
offset += sizeof(this->minimize_object_distance);
offset += this->path_constraints.deserialize(inbuffer + offset);
uint32_t length_planner_id;
arrToVar(length_planner_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_id-1]=0;
this->planner_id = (char *)(inbuffer + offset-1);
offset += length_planner_id;
uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->allowed_touch_objects_length);
if(allowed_touch_objects_lengthT > allowed_touch_objects_length)
this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*));
allowed_touch_objects_length = allowed_touch_objects_lengthT;
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_st_allowed_touch_objects;
arrToVar(length_st_allowed_touch_objects, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_allowed_touch_objects-1]=0;
this->st_allowed_touch_objects = (char *)(inbuffer + offset-1);
offset += length_st_allowed_touch_objects;
memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*));
}
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.base = 0;
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->allowed_planning_time = u_allowed_planning_time.real;
offset += sizeof(this->allowed_planning_time);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupGoal"; };
const char * getMD5(){ return "458c6ab3761d73e99b070063f7b74c2a"; };
};
}
#endif
| 15,465 | C | 49.875 | 148 | 0.632008 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryAction.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryAction_h
#define _ROS_moveit_msgs_ExecuteTrajectoryAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/ExecuteTrajectoryActionGoal.h"
#include "moveit_msgs/ExecuteTrajectoryActionResult.h"
#include "moveit_msgs/ExecuteTrajectoryActionFeedback.h"
namespace moveit_msgs
{
class ExecuteTrajectoryAction : public ros::Msg
{
public:
typedef moveit_msgs::ExecuteTrajectoryActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::ExecuteTrajectoryActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::ExecuteTrajectoryActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
ExecuteTrajectoryAction():
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 "moveit_msgs/ExecuteTrajectoryAction"; };
const char * getMD5(){ return "24e882ecd7f84f3e3299d504b8e3deae"; };
};
}
#endif
| 1,704 | C | 28.91228 | 81 | 0.703638 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceAction.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceAction_h
#define _ROS_moveit_msgs_MoveGroupSequenceAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveGroupSequenceActionGoal.h"
#include "moveit_msgs/MoveGroupSequenceActionResult.h"
#include "moveit_msgs/MoveGroupSequenceActionFeedback.h"
namespace moveit_msgs
{
class MoveGroupSequenceAction : public ros::Msg
{
public:
typedef moveit_msgs::MoveGroupSequenceActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::MoveGroupSequenceActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::MoveGroupSequenceActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
MoveGroupSequenceAction():
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 "moveit_msgs/MoveGroupSequenceAction"; };
const char * getMD5(){ return "146b2ccf95324a792cf72761e640ab31"; };
};
}
#endif
| 1,704 | C | 28.91228 | 81 | 0.703638 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/RobotState.h | #ifndef _ROS_moveit_msgs_RobotState_h
#define _ROS_moveit_msgs_RobotState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/JointState.h"
#include "sensor_msgs/MultiDOFJointState.h"
#include "moveit_msgs/AttachedCollisionObject.h"
namespace moveit_msgs
{
class RobotState : public ros::Msg
{
public:
typedef sensor_msgs::JointState _joint_state_type;
_joint_state_type joint_state;
typedef sensor_msgs::MultiDOFJointState _multi_dof_joint_state_type;
_multi_dof_joint_state_type multi_dof_joint_state;
uint32_t attached_collision_objects_length;
typedef moveit_msgs::AttachedCollisionObject _attached_collision_objects_type;
_attached_collision_objects_type st_attached_collision_objects;
_attached_collision_objects_type * attached_collision_objects;
typedef bool _is_diff_type;
_is_diff_type is_diff;
RobotState():
joint_state(),
multi_dof_joint_state(),
attached_collision_objects_length(0), attached_collision_objects(NULL),
is_diff(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->joint_state.serialize(outbuffer + offset);
offset += this->multi_dof_joint_state.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->attached_collision_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->attached_collision_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->attached_collision_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->attached_collision_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->attached_collision_objects_length);
for( uint32_t i = 0; i < attached_collision_objects_length; i++){
offset += this->attached_collision_objects[i].serialize(outbuffer + offset);
}
union {
bool real;
uint8_t base;
} u_is_diff;
u_is_diff.real = this->is_diff;
*(outbuffer + offset + 0) = (u_is_diff.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_diff);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->joint_state.deserialize(inbuffer + offset);
offset += this->multi_dof_joint_state.deserialize(inbuffer + offset);
uint32_t attached_collision_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
attached_collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
attached_collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
attached_collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->attached_collision_objects_length);
if(attached_collision_objects_lengthT > attached_collision_objects_length)
this->attached_collision_objects = (moveit_msgs::AttachedCollisionObject*)realloc(this->attached_collision_objects, attached_collision_objects_lengthT * sizeof(moveit_msgs::AttachedCollisionObject));
attached_collision_objects_length = attached_collision_objects_lengthT;
for( uint32_t i = 0; i < attached_collision_objects_length; i++){
offset += this->st_attached_collision_objects.deserialize(inbuffer + offset);
memcpy( &(this->attached_collision_objects[i]), &(this->st_attached_collision_objects), sizeof(moveit_msgs::AttachedCollisionObject));
}
union {
bool real;
uint8_t base;
} u_is_diff;
u_is_diff.base = 0;
u_is_diff.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_diff = u_is_diff.real;
offset += sizeof(this->is_diff);
return offset;
}
const char * getType(){ return "moveit_msgs/RobotState"; };
const char * getMD5(){ return "217a2e8e5547f4162b13a37db9cb4da4"; };
};
}
#endif
| 3,966 | C | 40.757894 | 207 | 0.650025 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupResult.h | #ifndef _ROS_moveit_msgs_MoveGroupResult_h
#define _ROS_moveit_msgs_MoveGroupResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
namespace moveit_msgs
{
class MoveGroupResult : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
typedef moveit_msgs::RobotTrajectory _planned_trajectory_type;
_planned_trajectory_type planned_trajectory;
typedef moveit_msgs::RobotTrajectory _executed_trajectory_type;
_executed_trajectory_type executed_trajectory;
typedef double _planning_time_type;
_planning_time_type planning_time;
MoveGroupResult():
error_code(),
trajectory_start(),
planned_trajectory(),
executed_trajectory(),
planning_time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
offset += this->trajectory_start.serialize(outbuffer + offset);
offset += this->planned_trajectory.serialize(outbuffer + offset);
offset += this->executed_trajectory.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
offset += this->trajectory_start.deserialize(inbuffer + offset);
offset += this->planned_trajectory.deserialize(inbuffer + offset);
offset += this->executed_trajectory.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupResult"; };
const char * getMD5(){ return "34098589d402fee7ae9c3fd413e5a6c6"; };
};
}
#endif
| 3,660 | C | 37.946808 | 81 | 0.612568 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceRequest.h | #ifndef _ROS_moveit_msgs_MotionSequenceRequest_h
#define _ROS_moveit_msgs_MotionSequenceRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionSequenceItem.h"
namespace moveit_msgs
{
class MotionSequenceRequest : public ros::Msg
{
public:
uint32_t items_length;
typedef moveit_msgs::MotionSequenceItem _items_type;
_items_type st_items;
_items_type * items;
MotionSequenceRequest():
items_length(0), items(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->items_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->items_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->items_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->items_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->items_length);
for( uint32_t i = 0; i < items_length; i++){
offset += this->items[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t items_lengthT = ((uint32_t) (*(inbuffer + offset)));
items_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
items_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
items_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->items_length);
if(items_lengthT > items_length)
this->items = (moveit_msgs::MotionSequenceItem*)realloc(this->items, items_lengthT * sizeof(moveit_msgs::MotionSequenceItem));
items_length = items_lengthT;
for( uint32_t i = 0; i < items_length; i++){
offset += this->st_items.deserialize(inbuffer + offset);
memcpy( &(this->items[i]), &(this->st_items), sizeof(moveit_msgs::MotionSequenceItem));
}
return offset;
}
const char * getType(){ return "moveit_msgs/MotionSequenceRequest"; };
const char * getMD5(){ return "c89266756409bea218f39a7f05ef21a1"; };
};
}
#endif
| 2,151 | C | 32.107692 | 134 | 0.6053 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryActionGoal.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryActionGoal_h
#define _ROS_moveit_msgs_ExecuteTrajectoryActionGoal_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 "moveit_msgs/ExecuteTrajectoryGoal.h"
namespace moveit_msgs
{
class ExecuteTrajectoryActionGoal : 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 moveit_msgs::ExecuteTrajectoryGoal _goal_type;
_goal_type goal;
ExecuteTrajectoryActionGoal():
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 "moveit_msgs/ExecuteTrajectoryActionGoal"; };
const char * getMD5(){ return "36f350977c67bc94e8cd408452bad0f0"; };
};
}
#endif
| 1,484 | C | 25.052631 | 80 | 0.66779 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceResult.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceResult_h
#define _ROS_moveit_msgs_MoveGroupSequenceResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionSequenceResponse.h"
namespace moveit_msgs
{
class MoveGroupSequenceResult : public ros::Msg
{
public:
typedef moveit_msgs::MotionSequenceResponse _response_type;
_response_type response;
MoveGroupSequenceResult():
response()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->response.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->response.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceResult"; };
const char * getMD5(){ return "039cee462ada3f0feb5f4e2e12baefae"; };
};
}
#endif
| 996 | C | 21.155555 | 76 | 0.679719 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPlanningScene.h | #ifndef _ROS_SERVICE_GetPlanningScene_h
#define _ROS_SERVICE_GetPlanningScene_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlanningScene.h"
#include "moveit_msgs/PlanningSceneComponents.h"
namespace moveit_msgs
{
static const char GETPLANNINGSCENE[] = "moveit_msgs/GetPlanningScene";
class GetPlanningSceneRequest : public ros::Msg
{
public:
typedef moveit_msgs::PlanningSceneComponents _components_type;
_components_type components;
GetPlanningSceneRequest():
components()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->components.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->components.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPLANNINGSCENE; };
const char * getMD5(){ return "d81da6c0e5e015646a4efe344f33d7dc"; };
};
class GetPlanningSceneResponse : public ros::Msg
{
public:
typedef moveit_msgs::PlanningScene _scene_type;
_scene_type scene;
GetPlanningSceneResponse():
scene()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->scene.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->scene.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPLANNINGSCENE; };
const char * getMD5(){ return "7bedc4871b1d0af6ec8b8996db347e7f"; };
};
class GetPlanningScene {
public:
typedef GetPlanningSceneRequest Request;
typedef GetPlanningSceneResponse Response;
};
}
#endif
| 1,897 | C | 21.86747 | 72 | 0.671587 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/JointConstraint.h | #ifndef _ROS_moveit_msgs_JointConstraint_h
#define _ROS_moveit_msgs_JointConstraint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class JointConstraint : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
typedef double _position_type;
_position_type position;
typedef double _tolerance_above_type;
_tolerance_above_type tolerance_above;
typedef double _tolerance_below_type;
_tolerance_below_type tolerance_below;
typedef double _weight_type;
_weight_type weight;
JointConstraint():
joint_name(""),
position(0),
tolerance_above(0),
tolerance_below(0),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_joint_name = strlen(this->joint_name);
varToArr(outbuffer + offset, length_joint_name);
offset += 4;
memcpy(outbuffer + offset, this->joint_name, length_joint_name);
offset += length_joint_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_tolerance_above;
u_tolerance_above.real = this->tolerance_above;
*(outbuffer + offset + 0) = (u_tolerance_above.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_tolerance_above.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_tolerance_above.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_tolerance_above.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_tolerance_above.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_tolerance_above.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_tolerance_above.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_tolerance_above.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->tolerance_above);
union {
double real;
uint64_t base;
} u_tolerance_below;
u_tolerance_below.real = this->tolerance_below;
*(outbuffer + offset + 0) = (u_tolerance_below.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_tolerance_below.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_tolerance_below.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_tolerance_below.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_tolerance_below.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_tolerance_below.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_tolerance_below.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_tolerance_below.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->tolerance_below);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_joint_name;
arrToVar(length_joint_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint_name-1]=0;
this->joint_name = (char *)(inbuffer + offset-1);
offset += length_joint_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_tolerance_above;
u_tolerance_above.base = 0;
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_tolerance_above.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->tolerance_above = u_tolerance_above.real;
offset += sizeof(this->tolerance_above);
union {
double real;
uint64_t base;
} u_tolerance_below;
u_tolerance_below.base = 0;
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_tolerance_below.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->tolerance_below = u_tolerance_below.real;
offset += sizeof(this->tolerance_below);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/JointConstraint"; };
const char * getMD5(){ return "c02a15146bec0ce13564807805b008f0"; };
};
}
#endif
| 8,174 | C | 43.429348 | 83 | 0.538292 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetStateValidity.h | #ifndef _ROS_SERVICE_GetStateValidity_h
#define _ROS_SERVICE_GetStateValidity_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/ConstraintEvalResult.h"
#include "moveit_msgs/CostSource.h"
#include "moveit_msgs/ContactInformation.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/Constraints.h"
namespace moveit_msgs
{
static const char GETSTATEVALIDITY[] = "moveit_msgs/GetStateValidity";
class GetStateValidityRequest : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::Constraints _constraints_type;
_constraints_type constraints;
GetStateValidityRequest():
robot_state(),
group_name(""),
constraints()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->robot_state.serialize(outbuffer + offset);
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
offset += this->constraints.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->robot_state.deserialize(inbuffer + offset);
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
offset += this->constraints.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETSTATEVALIDITY; };
const char * getMD5(){ return "b569c609cafad20ba7d0e46e70e7cab1"; };
};
class GetStateValidityResponse : public ros::Msg
{
public:
typedef bool _valid_type;
_valid_type valid;
uint32_t contacts_length;
typedef moveit_msgs::ContactInformation _contacts_type;
_contacts_type st_contacts;
_contacts_type * contacts;
uint32_t cost_sources_length;
typedef moveit_msgs::CostSource _cost_sources_type;
_cost_sources_type st_cost_sources;
_cost_sources_type * cost_sources;
uint32_t constraint_result_length;
typedef moveit_msgs::ConstraintEvalResult _constraint_result_type;
_constraint_result_type st_constraint_result;
_constraint_result_type * constraint_result;
GetStateValidityResponse():
valid(0),
contacts_length(0), contacts(NULL),
cost_sources_length(0), cost_sources(NULL),
constraint_result_length(0), constraint_result(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_valid;
u_valid.real = this->valid;
*(outbuffer + offset + 0) = (u_valid.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->valid);
*(outbuffer + offset + 0) = (this->contacts_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->contacts_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->contacts_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->contacts_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->contacts_length);
for( uint32_t i = 0; i < contacts_length; i++){
offset += this->contacts[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->cost_sources_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cost_sources_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cost_sources_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cost_sources_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cost_sources_length);
for( uint32_t i = 0; i < cost_sources_length; i++){
offset += this->cost_sources[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->constraint_result_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->constraint_result_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->constraint_result_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->constraint_result_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->constraint_result_length);
for( uint32_t i = 0; i < constraint_result_length; i++){
offset += this->constraint_result[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_valid;
u_valid.base = 0;
u_valid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->valid = u_valid.real;
offset += sizeof(this->valid);
uint32_t contacts_lengthT = ((uint32_t) (*(inbuffer + offset)));
contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->contacts_length);
if(contacts_lengthT > contacts_length)
this->contacts = (moveit_msgs::ContactInformation*)realloc(this->contacts, contacts_lengthT * sizeof(moveit_msgs::ContactInformation));
contacts_length = contacts_lengthT;
for( uint32_t i = 0; i < contacts_length; i++){
offset += this->st_contacts.deserialize(inbuffer + offset);
memcpy( &(this->contacts[i]), &(this->st_contacts), sizeof(moveit_msgs::ContactInformation));
}
uint32_t cost_sources_lengthT = ((uint32_t) (*(inbuffer + offset)));
cost_sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cost_sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cost_sources_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cost_sources_length);
if(cost_sources_lengthT > cost_sources_length)
this->cost_sources = (moveit_msgs::CostSource*)realloc(this->cost_sources, cost_sources_lengthT * sizeof(moveit_msgs::CostSource));
cost_sources_length = cost_sources_lengthT;
for( uint32_t i = 0; i < cost_sources_length; i++){
offset += this->st_cost_sources.deserialize(inbuffer + offset);
memcpy( &(this->cost_sources[i]), &(this->st_cost_sources), sizeof(moveit_msgs::CostSource));
}
uint32_t constraint_result_lengthT = ((uint32_t) (*(inbuffer + offset)));
constraint_result_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
constraint_result_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
constraint_result_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->constraint_result_length);
if(constraint_result_lengthT > constraint_result_length)
this->constraint_result = (moveit_msgs::ConstraintEvalResult*)realloc(this->constraint_result, constraint_result_lengthT * sizeof(moveit_msgs::ConstraintEvalResult));
constraint_result_length = constraint_result_lengthT;
for( uint32_t i = 0; i < constraint_result_length; i++){
offset += this->st_constraint_result.deserialize(inbuffer + offset);
memcpy( &(this->constraint_result[i]), &(this->st_constraint_result), sizeof(moveit_msgs::ConstraintEvalResult));
}
return offset;
}
const char * getType(){ return GETSTATEVALIDITY; };
const char * getMD5(){ return "e326fb22b7448f29c0e726d9270d9929"; };
};
class GetStateValidity {
public:
typedef GetStateValidityRequest Request;
typedef GetStateValidityResponse Response;
};
}
#endif
| 8,146 | C | 40.566326 | 174 | 0.622391 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/QueryPlannerInterfaces.h | #ifndef _ROS_SERVICE_QueryPlannerInterfaces_h
#define _ROS_SERVICE_QueryPlannerInterfaces_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlannerInterfaceDescription.h"
namespace moveit_msgs
{
static const char QUERYPLANNERINTERFACES[] = "moveit_msgs/QueryPlannerInterfaces";
class QueryPlannerInterfacesRequest : public ros::Msg
{
public:
QueryPlannerInterfacesRequest()
{
}
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 QUERYPLANNERINTERFACES; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class QueryPlannerInterfacesResponse : public ros::Msg
{
public:
uint32_t planner_interfaces_length;
typedef moveit_msgs::PlannerInterfaceDescription _planner_interfaces_type;
_planner_interfaces_type st_planner_interfaces;
_planner_interfaces_type * planner_interfaces;
QueryPlannerInterfacesResponse():
planner_interfaces_length(0), planner_interfaces(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->planner_interfaces_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planner_interfaces_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planner_interfaces_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planner_interfaces_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planner_interfaces_length);
for( uint32_t i = 0; i < planner_interfaces_length; i++){
offset += this->planner_interfaces[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t planner_interfaces_lengthT = ((uint32_t) (*(inbuffer + offset)));
planner_interfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planner_interfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planner_interfaces_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planner_interfaces_length);
if(planner_interfaces_lengthT > planner_interfaces_length)
this->planner_interfaces = (moveit_msgs::PlannerInterfaceDescription*)realloc(this->planner_interfaces, planner_interfaces_lengthT * sizeof(moveit_msgs::PlannerInterfaceDescription));
planner_interfaces_length = planner_interfaces_lengthT;
for( uint32_t i = 0; i < planner_interfaces_length; i++){
offset += this->st_planner_interfaces.deserialize(inbuffer + offset);
memcpy( &(this->planner_interfaces[i]), &(this->st_planner_interfaces), sizeof(moveit_msgs::PlannerInterfaceDescription));
}
return offset;
}
const char * getType(){ return QUERYPLANNERINTERFACES; };
const char * getMD5(){ return "acd3317a4c5631f33127fb428209db05"; };
};
class QueryPlannerInterfaces {
public:
typedef QueryPlannerInterfacesRequest Request;
typedef QueryPlannerInterfacesResponse Response;
};
}
#endif
| 3,322 | C | 33.257732 | 191 | 0.668874 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/SetPlannerParams.h | #ifndef _ROS_SERVICE_SetPlannerParams_h
#define _ROS_SERVICE_SetPlannerParams_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlannerParams.h"
namespace moveit_msgs
{
static const char SETPLANNERPARAMS[] = "moveit_msgs/SetPlannerParams";
class SetPlannerParamsRequest : public ros::Msg
{
public:
typedef const char* _planner_config_type;
_planner_config_type planner_config;
typedef const char* _group_type;
_group_type group;
typedef moveit_msgs::PlannerParams _params_type;
_params_type params;
typedef bool _replace_type;
_replace_type replace;
SetPlannerParamsRequest():
planner_config(""),
group(""),
params(),
replace(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_planner_config = strlen(this->planner_config);
varToArr(outbuffer + offset, length_planner_config);
offset += 4;
memcpy(outbuffer + offset, this->planner_config, length_planner_config);
offset += length_planner_config;
uint32_t length_group = strlen(this->group);
varToArr(outbuffer + offset, length_group);
offset += 4;
memcpy(outbuffer + offset, this->group, length_group);
offset += length_group;
offset += this->params.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_replace;
u_replace.real = this->replace;
*(outbuffer + offset + 0) = (u_replace.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->replace);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_planner_config;
arrToVar(length_planner_config, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_config; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_config-1]=0;
this->planner_config = (char *)(inbuffer + offset-1);
offset += length_planner_config;
uint32_t length_group;
arrToVar(length_group, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group-1]=0;
this->group = (char *)(inbuffer + offset-1);
offset += length_group;
offset += this->params.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_replace;
u_replace.base = 0;
u_replace.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->replace = u_replace.real;
offset += sizeof(this->replace);
return offset;
}
const char * getType(){ return SETPLANNERPARAMS; };
const char * getMD5(){ return "86762d89189c5f52cda7680fdbceb1db"; };
};
class SetPlannerParamsResponse : public ros::Msg
{
public:
SetPlannerParamsResponse()
{
}
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 SETPLANNERPARAMS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetPlannerParams {
public:
typedef SetPlannerParamsRequest Request;
typedef SetPlannerParamsResponse Response;
};
}
#endif
| 3,543 | C | 26.472868 | 78 | 0.622072 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceActionGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceActionGoal_h
#define _ROS_moveit_msgs_MoveGroupSequenceActionGoal_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 "moveit_msgs/MoveGroupSequenceGoal.h"
namespace moveit_msgs
{
class MoveGroupSequenceActionGoal : 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 moveit_msgs::MoveGroupSequenceGoal _goal_type;
_goal_type goal;
MoveGroupSequenceActionGoal():
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 "moveit_msgs/MoveGroupSequenceActionGoal"; };
const char * getMD5(){ return "33db6638fb44f932dc55788fa9d72325"; };
};
}
#endif
| 1,484 | C | 25.052631 | 80 | 0.66779 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceLocation.h | #ifndef _ROS_moveit_msgs_PlaceLocation_h
#define _ROS_moveit_msgs_PlaceLocation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "geometry_msgs/PoseStamped.h"
#include "moveit_msgs/GripperTranslation.h"
namespace moveit_msgs
{
class PlaceLocation : public ros::Msg
{
public:
typedef const char* _id_type;
_id_type id;
typedef trajectory_msgs::JointTrajectory _post_place_posture_type;
_post_place_posture_type post_place_posture;
typedef geometry_msgs::PoseStamped _place_pose_type;
_place_pose_type place_pose;
typedef moveit_msgs::GripperTranslation _pre_place_approach_type;
_pre_place_approach_type pre_place_approach;
typedef moveit_msgs::GripperTranslation _post_place_retreat_type;
_post_place_retreat_type post_place_retreat;
uint32_t allowed_touch_objects_length;
typedef char* _allowed_touch_objects_type;
_allowed_touch_objects_type st_allowed_touch_objects;
_allowed_touch_objects_type * allowed_touch_objects;
PlaceLocation():
id(""),
post_place_posture(),
place_pose(),
pre_place_approach(),
post_place_retreat(),
allowed_touch_objects_length(0), allowed_touch_objects(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;
offset += this->post_place_posture.serialize(outbuffer + offset);
offset += this->place_pose.serialize(outbuffer + offset);
offset += this->pre_place_approach.serialize(outbuffer + offset);
offset += this->post_place_retreat.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->allowed_touch_objects_length);
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]);
varToArr(outbuffer + offset, length_allowed_touch_objectsi);
offset += 4;
memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi);
offset += length_allowed_touch_objectsi;
}
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;
offset += this->post_place_posture.deserialize(inbuffer + offset);
offset += this->place_pose.deserialize(inbuffer + offset);
offset += this->pre_place_approach.deserialize(inbuffer + offset);
offset += this->post_place_retreat.deserialize(inbuffer + offset);
uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->allowed_touch_objects_length);
if(allowed_touch_objects_lengthT > allowed_touch_objects_length)
this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*));
allowed_touch_objects_length = allowed_touch_objects_lengthT;
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_st_allowed_touch_objects;
arrToVar(length_st_allowed_touch_objects, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_allowed_touch_objects-1]=0;
this->st_allowed_touch_objects = (char *)(inbuffer + offset-1);
offset += length_st_allowed_touch_objects;
memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceLocation"; };
const char * getMD5(){ return "f3dbcaca40fb29ede2af78b3e1831128"; };
};
}
#endif
| 4,897 | C | 41.224138 | 130 | 0.646927 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/Constraints.h | #ifndef _ROS_moveit_msgs_Constraints_h
#define _ROS_moveit_msgs_Constraints_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/JointConstraint.h"
#include "moveit_msgs/PositionConstraint.h"
#include "moveit_msgs/OrientationConstraint.h"
#include "moveit_msgs/VisibilityConstraint.h"
namespace moveit_msgs
{
class Constraints : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
uint32_t joint_constraints_length;
typedef moveit_msgs::JointConstraint _joint_constraints_type;
_joint_constraints_type st_joint_constraints;
_joint_constraints_type * joint_constraints;
uint32_t position_constraints_length;
typedef moveit_msgs::PositionConstraint _position_constraints_type;
_position_constraints_type st_position_constraints;
_position_constraints_type * position_constraints;
uint32_t orientation_constraints_length;
typedef moveit_msgs::OrientationConstraint _orientation_constraints_type;
_orientation_constraints_type st_orientation_constraints;
_orientation_constraints_type * orientation_constraints;
uint32_t visibility_constraints_length;
typedef moveit_msgs::VisibilityConstraint _visibility_constraints_type;
_visibility_constraints_type st_visibility_constraints;
_visibility_constraints_type * visibility_constraints;
Constraints():
name(""),
joint_constraints_length(0), joint_constraints(NULL),
position_constraints_length(0), position_constraints(NULL),
orientation_constraints_length(0), orientation_constraints(NULL),
visibility_constraints_length(0), visibility_constraints(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;
*(outbuffer + offset + 0) = (this->joint_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_constraints_length);
for( uint32_t i = 0; i < joint_constraints_length; i++){
offset += this->joint_constraints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->position_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_constraints_length);
for( uint32_t i = 0; i < position_constraints_length; i++){
offset += this->position_constraints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->orientation_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->orientation_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->orientation_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->orientation_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->orientation_constraints_length);
for( uint32_t i = 0; i < orientation_constraints_length; i++){
offset += this->orientation_constraints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->visibility_constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->visibility_constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->visibility_constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->visibility_constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->visibility_constraints_length);
for( uint32_t i = 0; i < visibility_constraints_length; i++){
offset += this->visibility_constraints[i].serialize(outbuffer + offset);
}
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 joint_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_constraints_length);
if(joint_constraints_lengthT > joint_constraints_length)
this->joint_constraints = (moveit_msgs::JointConstraint*)realloc(this->joint_constraints, joint_constraints_lengthT * sizeof(moveit_msgs::JointConstraint));
joint_constraints_length = joint_constraints_lengthT;
for( uint32_t i = 0; i < joint_constraints_length; i++){
offset += this->st_joint_constraints.deserialize(inbuffer + offset);
memcpy( &(this->joint_constraints[i]), &(this->st_joint_constraints), sizeof(moveit_msgs::JointConstraint));
}
uint32_t position_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_constraints_length);
if(position_constraints_lengthT > position_constraints_length)
this->position_constraints = (moveit_msgs::PositionConstraint*)realloc(this->position_constraints, position_constraints_lengthT * sizeof(moveit_msgs::PositionConstraint));
position_constraints_length = position_constraints_lengthT;
for( uint32_t i = 0; i < position_constraints_length; i++){
offset += this->st_position_constraints.deserialize(inbuffer + offset);
memcpy( &(this->position_constraints[i]), &(this->st_position_constraints), sizeof(moveit_msgs::PositionConstraint));
}
uint32_t orientation_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
orientation_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
orientation_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
orientation_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->orientation_constraints_length);
if(orientation_constraints_lengthT > orientation_constraints_length)
this->orientation_constraints = (moveit_msgs::OrientationConstraint*)realloc(this->orientation_constraints, orientation_constraints_lengthT * sizeof(moveit_msgs::OrientationConstraint));
orientation_constraints_length = orientation_constraints_lengthT;
for( uint32_t i = 0; i < orientation_constraints_length; i++){
offset += this->st_orientation_constraints.deserialize(inbuffer + offset);
memcpy( &(this->orientation_constraints[i]), &(this->st_orientation_constraints), sizeof(moveit_msgs::OrientationConstraint));
}
uint32_t visibility_constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
visibility_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
visibility_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
visibility_constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->visibility_constraints_length);
if(visibility_constraints_lengthT > visibility_constraints_length)
this->visibility_constraints = (moveit_msgs::VisibilityConstraint*)realloc(this->visibility_constraints, visibility_constraints_lengthT * sizeof(moveit_msgs::VisibilityConstraint));
visibility_constraints_length = visibility_constraints_lengthT;
for( uint32_t i = 0; i < visibility_constraints_length; i++){
offset += this->st_visibility_constraints.deserialize(inbuffer + offset);
memcpy( &(this->visibility_constraints[i]), &(this->st_visibility_constraints), sizeof(moveit_msgs::VisibilityConstraint));
}
return offset;
}
const char * getType(){ return "moveit_msgs/Constraints"; };
const char * getMD5(){ return "8d5ce8d34ef26c65fb5d43c9e99bf6e0"; };
};
}
#endif
| 8,998 | C | 55.24375 | 194 | 0.658591 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupActionResult.h | #ifndef _ROS_moveit_msgs_MoveGroupActionResult_h
#define _ROS_moveit_msgs_MoveGroupActionResult_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 "moveit_msgs/MoveGroupResult.h"
namespace moveit_msgs
{
class MoveGroupActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::MoveGroupResult _result_type;
_result_type result;
MoveGroupActionResult():
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 "moveit_msgs/MoveGroupActionResult"; };
const char * getMD5(){ return "6ee8682a508d60603228accdc4a2b30b"; };
};
}
#endif
| 1,456 | C | 24.561403 | 74 | 0.665522 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteKnownTrajectory.h | #ifndef _ROS_SERVICE_ExecuteKnownTrajectory_h
#define _ROS_SERVICE_ExecuteKnownTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotTrajectory.h"
namespace moveit_msgs
{
static const char EXECUTEKNOWNTRAJECTORY[] = "moveit_msgs/ExecuteKnownTrajectory";
class ExecuteKnownTrajectoryRequest : public ros::Msg
{
public:
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type trajectory;
typedef bool _wait_for_execution_type;
_wait_for_execution_type wait_for_execution;
ExecuteKnownTrajectoryRequest():
trajectory(),
wait_for_execution(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_wait_for_execution;
u_wait_for_execution.real = this->wait_for_execution;
*(outbuffer + offset + 0) = (u_wait_for_execution.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->wait_for_execution);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_wait_for_execution;
u_wait_for_execution.base = 0;
u_wait_for_execution.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->wait_for_execution = u_wait_for_execution.real;
offset += sizeof(this->wait_for_execution);
return offset;
}
const char * getType(){ return EXECUTEKNOWNTRAJECTORY; };
const char * getMD5(){ return "2a3d2a0b337c6a27da4468bb351928e5"; };
};
class ExecuteKnownTrajectoryResponse : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
ExecuteKnownTrajectoryResponse():
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return EXECUTEKNOWNTRAJECTORY; };
const char * getMD5(){ return "1f7ab918f5d0c5312f25263d3d688122"; };
};
class ExecuteKnownTrajectory {
public:
typedef ExecuteKnownTrajectoryRequest Request;
typedef ExecuteKnownTrajectoryResponse Response;
};
}
#endif
| 2,714 | C | 25.881188 | 85 | 0.657701 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveItErrorCodes.h | #ifndef _ROS_moveit_msgs_MoveItErrorCodes_h
#define _ROS_moveit_msgs_MoveItErrorCodes_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class MoveItErrorCodes : public ros::Msg
{
public:
typedef int32_t _val_type;
_val_type val;
enum { SUCCESS = 1 };
enum { FAILURE = 99999 };
enum { PLANNING_FAILED = -1 };
enum { INVALID_MOTION_PLAN = -2 };
enum { MOTION_PLAN_INVALIDATED_BY_ENVIRONMENT_CHANGE = -3 };
enum { CONTROL_FAILED = -4 };
enum { UNABLE_TO_AQUIRE_SENSOR_DATA = -5 };
enum { TIMED_OUT = -6 };
enum { PREEMPTED = -7 };
enum { START_STATE_IN_COLLISION = -10 };
enum { START_STATE_VIOLATES_PATH_CONSTRAINTS = -11 };
enum { GOAL_IN_COLLISION = -12 };
enum { GOAL_VIOLATES_PATH_CONSTRAINTS = -13 };
enum { GOAL_CONSTRAINTS_VIOLATED = -14 };
enum { INVALID_GROUP_NAME = -15 };
enum { INVALID_GOAL_CONSTRAINTS = -16 };
enum { INVALID_ROBOT_STATE = -17 };
enum { INVALID_LINK_NAME = -18 };
enum { INVALID_OBJECT_NAME = -19 };
enum { FRAME_TRANSFORM_FAILURE = -21 };
enum { COLLISION_CHECKING_UNAVAILABLE = -22 };
enum { ROBOT_STATE_STALE = -23 };
enum { SENSOR_INFO_STALE = -24 };
enum { NO_IK_SOLUTION = -31 };
MoveItErrorCodes():
val(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_val;
u_val.real = this->val;
*(outbuffer + offset + 0) = (u_val.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_val.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_val.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_val.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->val);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_val;
u_val.base = 0;
u_val.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_val.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_val.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_val.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->val = u_val.real;
offset += sizeof(this->val);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveItErrorCodes"; };
const char * getMD5(){ return "aa336b18d80531f66439810112c0a43e"; };
};
}
#endif
| 2,622 | C | 29.149425 | 72 | 0.546148 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ConstraintEvalResult.h | #ifndef _ROS_moveit_msgs_ConstraintEvalResult_h
#define _ROS_moveit_msgs_ConstraintEvalResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class ConstraintEvalResult : public ros::Msg
{
public:
typedef bool _result_type;
_result_type result;
typedef double _distance_type;
_distance_type distance;
ConstraintEvalResult():
result(0),
distance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_result;
u_result.real = this->result;
*(outbuffer + offset + 0) = (u_result.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->result);
union {
double real;
uint64_t base;
} u_distance;
u_distance.real = this->distance;
*(outbuffer + offset + 0) = (u_distance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_distance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_distance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_distance.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_distance.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_distance.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_distance.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_distance.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->distance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_result;
u_result.base = 0;
u_result.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->result = u_result.real;
offset += sizeof(this->result);
union {
double real;
uint64_t base;
} u_distance;
u_distance.base = 0;
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_distance.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->distance = u_distance.real;
offset += sizeof(this->distance);
return offset;
}
const char * getType(){ return "moveit_msgs/ConstraintEvalResult"; };
const char * getMD5(){ return "093643083d24f6488cb5a868bd47c090"; };
};
}
#endif
| 2,846 | C | 30.988764 | 76 | 0.540759 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AllowedCollisionEntry.h | #ifndef _ROS_moveit_msgs_AllowedCollisionEntry_h
#define _ROS_moveit_msgs_AllowedCollisionEntry_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class AllowedCollisionEntry : public ros::Msg
{
public:
uint32_t enabled_length;
typedef bool _enabled_type;
_enabled_type st_enabled;
_enabled_type * enabled;
AllowedCollisionEntry():
enabled_length(0), enabled(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->enabled_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->enabled_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->enabled_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->enabled_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->enabled_length);
for( uint32_t i = 0; i < enabled_length; i++){
union {
bool real;
uint8_t base;
} u_enabledi;
u_enabledi.real = this->enabled[i];
*(outbuffer + offset + 0) = (u_enabledi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->enabled[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t enabled_lengthT = ((uint32_t) (*(inbuffer + offset)));
enabled_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
enabled_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
enabled_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->enabled_length);
if(enabled_lengthT > enabled_length)
this->enabled = (bool*)realloc(this->enabled, enabled_lengthT * sizeof(bool));
enabled_length = enabled_lengthT;
for( uint32_t i = 0; i < enabled_length; i++){
union {
bool real;
uint8_t base;
} u_st_enabled;
u_st_enabled.base = 0;
u_st_enabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_enabled = u_st_enabled.real;
offset += sizeof(this->st_enabled);
memcpy( &(this->enabled[i]), &(this->st_enabled), sizeof(bool));
}
return offset;
}
const char * getType(){ return "moveit_msgs/AllowedCollisionEntry"; };
const char * getMD5(){ return "90d1ae1850840724bb043562fe3285fc"; };
};
}
#endif
| 2,432 | C | 30.597402 | 86 | 0.575247 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ApplyPlanningScene.h | #ifndef _ROS_SERVICE_ApplyPlanningScene_h
#define _ROS_SERVICE_ApplyPlanningScene_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlanningScene.h"
namespace moveit_msgs
{
static const char APPLYPLANNINGSCENE[] = "moveit_msgs/ApplyPlanningScene";
class ApplyPlanningSceneRequest : public ros::Msg
{
public:
typedef moveit_msgs::PlanningScene _scene_type;
_scene_type scene;
ApplyPlanningSceneRequest():
scene()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->scene.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->scene.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return APPLYPLANNINGSCENE; };
const char * getMD5(){ return "7bedc4871b1d0af6ec8b8996db347e7f"; };
};
class ApplyPlanningSceneResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
ApplyPlanningSceneResponse():
success(0)
{
}
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);
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);
return offset;
}
const char * getType(){ return APPLYPLANNINGSCENE; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class ApplyPlanningScene {
public:
typedef ApplyPlanningSceneRequest Request;
typedef ApplyPlanningSceneResponse Response;
};
}
#endif
| 2,175 | C | 21.905263 | 74 | 0.628046 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CostSource.h | #ifndef _ROS_moveit_msgs_CostSource_h
#define _ROS_moveit_msgs_CostSource_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
namespace moveit_msgs
{
class CostSource : public ros::Msg
{
public:
typedef double _cost_density_type;
_cost_density_type cost_density;
typedef geometry_msgs::Vector3 _aabb_min_type;
_aabb_min_type aabb_min;
typedef geometry_msgs::Vector3 _aabb_max_type;
_aabb_max_type aabb_max;
CostSource():
cost_density(0),
aabb_min(),
aabb_max()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_cost_density;
u_cost_density.real = this->cost_density;
*(outbuffer + offset + 0) = (u_cost_density.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cost_density.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cost_density.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cost_density.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_cost_density.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_cost_density.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_cost_density.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_cost_density.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->cost_density);
offset += this->aabb_min.serialize(outbuffer + offset);
offset += this->aabb_max.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_cost_density;
u_cost_density.base = 0;
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_cost_density.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->cost_density = u_cost_density.real;
offset += sizeof(this->cost_density);
offset += this->aabb_min.deserialize(inbuffer + offset);
offset += this->aabb_max.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/CostSource"; };
const char * getMD5(){ return "abb7e013237dacaaa8b97e704102f908"; };
};
}
#endif
| 2,862 | C | 33.914634 | 80 | 0.567435 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LinkPadding.h | #ifndef _ROS_moveit_msgs_LinkPadding_h
#define _ROS_moveit_msgs_LinkPadding_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class LinkPadding : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef double _padding_type;
_padding_type padding;
LinkPadding():
link_name(""),
padding(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_padding;
u_padding.real = this->padding;
*(outbuffer + offset + 0) = (u_padding.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_padding.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_padding.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_padding.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_padding.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_padding.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_padding.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_padding.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->padding);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_padding;
u_padding.base = 0;
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_padding.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->padding = u_padding.real;
offset += sizeof(this->padding);
return offset;
}
const char * getType(){ return "moveit_msgs/LinkPadding"; };
const char * getMD5(){ return "b3ea75670df55c696fedee97774d5947"; };
};
}
#endif
| 2,919 | C | 32.181818 | 75 | 0.551216 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ObjectColor.h | #ifndef _ROS_moveit_msgs_ObjectColor_h
#define _ROS_moveit_msgs_ObjectColor_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/ColorRGBA.h"
namespace moveit_msgs
{
class ObjectColor : public ros::Msg
{
public:
typedef const char* _id_type;
_id_type id;
typedef std_msgs::ColorRGBA _color_type;
_color_type color;
ObjectColor():
id(""),
color()
{
}
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;
offset += this->color.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;
offset += this->color.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/ObjectColor"; };
const char * getMD5(){ return "ec3bd6f103430e64b2ae706a67d8488e"; };
};
}
#endif
| 1,460 | C | 22.564516 | 72 | 0.605479 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryActionFeedback.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryActionFeedback_h
#define _ROS_moveit_msgs_ExecuteTrajectoryActionFeedback_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 "moveit_msgs/ExecuteTrajectoryFeedback.h"
namespace moveit_msgs
{
class ExecuteTrajectoryActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::ExecuteTrajectoryFeedback _feedback_type;
_feedback_type feedback;
ExecuteTrajectoryActionFeedback():
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 "moveit_msgs/ExecuteTrajectoryActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
| 1,538 | C | 26 | 84 | 0.683355 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceGoal.h | #ifndef _ROS_moveit_msgs_PlaceGoal_h
#define _ROS_moveit_msgs_PlaceGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlaceLocation.h"
#include "moveit_msgs/Constraints.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class PlaceGoal : public ros::Msg
{
public:
typedef const char* _group_name_type;
_group_name_type group_name;
typedef const char* _attached_object_name_type;
_attached_object_name_type attached_object_name;
uint32_t place_locations_length;
typedef moveit_msgs::PlaceLocation _place_locations_type;
_place_locations_type st_place_locations;
_place_locations_type * place_locations;
typedef bool _place_eef_type;
_place_eef_type place_eef;
typedef const char* _support_surface_name_type;
_support_surface_name_type support_surface_name;
typedef bool _allow_gripper_support_collision_type;
_allow_gripper_support_collision_type allow_gripper_support_collision;
typedef moveit_msgs::Constraints _path_constraints_type;
_path_constraints_type path_constraints;
typedef const char* _planner_id_type;
_planner_id_type planner_id;
uint32_t allowed_touch_objects_length;
typedef char* _allowed_touch_objects_type;
_allowed_touch_objects_type st_allowed_touch_objects;
_allowed_touch_objects_type * allowed_touch_objects;
typedef double _allowed_planning_time_type;
_allowed_planning_time_type allowed_planning_time;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
PlaceGoal():
group_name(""),
attached_object_name(""),
place_locations_length(0), place_locations(NULL),
place_eef(0),
support_surface_name(""),
allow_gripper_support_collision(0),
path_constraints(),
planner_id(""),
allowed_touch_objects_length(0), allowed_touch_objects(NULL),
allowed_planning_time(0),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
uint32_t length_attached_object_name = strlen(this->attached_object_name);
varToArr(outbuffer + offset, length_attached_object_name);
offset += 4;
memcpy(outbuffer + offset, this->attached_object_name, length_attached_object_name);
offset += length_attached_object_name;
*(outbuffer + offset + 0) = (this->place_locations_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->place_locations_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->place_locations_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->place_locations_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->place_locations_length);
for( uint32_t i = 0; i < place_locations_length; i++){
offset += this->place_locations[i].serialize(outbuffer + offset);
}
union {
bool real;
uint8_t base;
} u_place_eef;
u_place_eef.real = this->place_eef;
*(outbuffer + offset + 0) = (u_place_eef.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->place_eef);
uint32_t length_support_surface_name = strlen(this->support_surface_name);
varToArr(outbuffer + offset, length_support_surface_name);
offset += 4;
memcpy(outbuffer + offset, this->support_surface_name, length_support_surface_name);
offset += length_support_surface_name;
union {
bool real;
uint8_t base;
} u_allow_gripper_support_collision;
u_allow_gripper_support_collision.real = this->allow_gripper_support_collision;
*(outbuffer + offset + 0) = (u_allow_gripper_support_collision.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->allow_gripper_support_collision);
offset += this->path_constraints.serialize(outbuffer + offset);
uint32_t length_planner_id = strlen(this->planner_id);
varToArr(outbuffer + offset, length_planner_id);
offset += 4;
memcpy(outbuffer + offset, this->planner_id, length_planner_id);
offset += length_planner_id;
*(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->allowed_touch_objects_length);
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]);
varToArr(outbuffer + offset, length_allowed_touch_objectsi);
offset += 4;
memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi);
offset += length_allowed_touch_objectsi;
}
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.real = this->allowed_planning_time;
*(outbuffer + offset + 0) = (u_allowed_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_allowed_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_allowed_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_allowed_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_allowed_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_allowed_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_allowed_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_allowed_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->allowed_planning_time);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
uint32_t length_attached_object_name;
arrToVar(length_attached_object_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_attached_object_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_attached_object_name-1]=0;
this->attached_object_name = (char *)(inbuffer + offset-1);
offset += length_attached_object_name;
uint32_t place_locations_lengthT = ((uint32_t) (*(inbuffer + offset)));
place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->place_locations_length);
if(place_locations_lengthT > place_locations_length)
this->place_locations = (moveit_msgs::PlaceLocation*)realloc(this->place_locations, place_locations_lengthT * sizeof(moveit_msgs::PlaceLocation));
place_locations_length = place_locations_lengthT;
for( uint32_t i = 0; i < place_locations_length; i++){
offset += this->st_place_locations.deserialize(inbuffer + offset);
memcpy( &(this->place_locations[i]), &(this->st_place_locations), sizeof(moveit_msgs::PlaceLocation));
}
union {
bool real;
uint8_t base;
} u_place_eef;
u_place_eef.base = 0;
u_place_eef.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->place_eef = u_place_eef.real;
offset += sizeof(this->place_eef);
uint32_t length_support_surface_name;
arrToVar(length_support_surface_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_support_surface_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_support_surface_name-1]=0;
this->support_surface_name = (char *)(inbuffer + offset-1);
offset += length_support_surface_name;
union {
bool real;
uint8_t base;
} u_allow_gripper_support_collision;
u_allow_gripper_support_collision.base = 0;
u_allow_gripper_support_collision.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->allow_gripper_support_collision = u_allow_gripper_support_collision.real;
offset += sizeof(this->allow_gripper_support_collision);
offset += this->path_constraints.deserialize(inbuffer + offset);
uint32_t length_planner_id;
arrToVar(length_planner_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_id-1]=0;
this->planner_id = (char *)(inbuffer + offset-1);
offset += length_planner_id;
uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->allowed_touch_objects_length);
if(allowed_touch_objects_lengthT > allowed_touch_objects_length)
this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*));
allowed_touch_objects_length = allowed_touch_objects_lengthT;
for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
uint32_t length_st_allowed_touch_objects;
arrToVar(length_st_allowed_touch_objects, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_allowed_touch_objects-1]=0;
this->st_allowed_touch_objects = (char *)(inbuffer + offset-1);
offset += length_st_allowed_touch_objects;
memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*));
}
union {
double real;
uint64_t base;
} u_allowed_planning_time;
u_allowed_planning_time.base = 0;
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_allowed_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->allowed_planning_time = u_allowed_planning_time.real;
offset += sizeof(this->allowed_planning_time);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceGoal"; };
const char * getMD5(){ return "e3f3e956e536ccd313fd8f23023f0a94"; };
};
}
#endif
| 12,034 | C | 47.14 | 154 | 0.625145 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ExecuteTrajectoryActionResult.h | #ifndef _ROS_moveit_msgs_ExecuteTrajectoryActionResult_h
#define _ROS_moveit_msgs_ExecuteTrajectoryActionResult_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 "moveit_msgs/ExecuteTrajectoryResult.h"
namespace moveit_msgs
{
class ExecuteTrajectoryActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::ExecuteTrajectoryResult _result_type;
_result_type result;
ExecuteTrajectoryActionResult():
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 "moveit_msgs/ExecuteTrajectoryActionResult"; };
const char * getMD5(){ return "8aaeab5c1cdb613e6a2913ebcc104c0d"; };
};
}
#endif
| 1,512 | C | 25.543859 | 82 | 0.67791 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/JointLimits.h | #ifndef _ROS_moveit_msgs_JointLimits_h
#define _ROS_moveit_msgs_JointLimits_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class JointLimits : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
typedef bool _has_position_limits_type;
_has_position_limits_type has_position_limits;
typedef double _min_position_type;
_min_position_type min_position;
typedef double _max_position_type;
_max_position_type max_position;
typedef bool _has_velocity_limits_type;
_has_velocity_limits_type has_velocity_limits;
typedef double _max_velocity_type;
_max_velocity_type max_velocity;
typedef bool _has_acceleration_limits_type;
_has_acceleration_limits_type has_acceleration_limits;
typedef double _max_acceleration_type;
_max_acceleration_type max_acceleration;
JointLimits():
joint_name(""),
has_position_limits(0),
min_position(0),
max_position(0),
has_velocity_limits(0),
max_velocity(0),
has_acceleration_limits(0),
max_acceleration(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_joint_name = strlen(this->joint_name);
varToArr(outbuffer + offset, length_joint_name);
offset += 4;
memcpy(outbuffer + offset, this->joint_name, length_joint_name);
offset += length_joint_name;
union {
bool real;
uint8_t base;
} u_has_position_limits;
u_has_position_limits.real = this->has_position_limits;
*(outbuffer + offset + 0) = (u_has_position_limits.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->has_position_limits);
union {
double real;
uint64_t base;
} u_min_position;
u_min_position.real = this->min_position;
*(outbuffer + offset + 0) = (u_min_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_position);
union {
double real;
uint64_t base;
} u_max_position;
u_max_position.real = this->max_position;
*(outbuffer + offset + 0) = (u_max_position.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_position.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_position.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_position.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_position.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_position.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_position.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_position.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_position);
union {
bool real;
uint8_t base;
} u_has_velocity_limits;
u_has_velocity_limits.real = this->has_velocity_limits;
*(outbuffer + offset + 0) = (u_has_velocity_limits.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->has_velocity_limits);
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);
union {
bool real;
uint8_t base;
} u_has_acceleration_limits;
u_has_acceleration_limits.real = this->has_acceleration_limits;
*(outbuffer + offset + 0) = (u_has_acceleration_limits.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->has_acceleration_limits);
union {
double real;
uint64_t base;
} u_max_acceleration;
u_max_acceleration.real = this->max_acceleration;
*(outbuffer + offset + 0) = (u_max_acceleration.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_acceleration.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_acceleration.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_acceleration.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_acceleration.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_acceleration.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_acceleration.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_acceleration.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_acceleration);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_joint_name;
arrToVar(length_joint_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint_name-1]=0;
this->joint_name = (char *)(inbuffer + offset-1);
offset += length_joint_name;
union {
bool real;
uint8_t base;
} u_has_position_limits;
u_has_position_limits.base = 0;
u_has_position_limits.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->has_position_limits = u_has_position_limits.real;
offset += sizeof(this->has_position_limits);
union {
double real;
uint64_t base;
} u_min_position;
u_min_position.base = 0;
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_position = u_min_position.real;
offset += sizeof(this->min_position);
union {
double real;
uint64_t base;
} u_max_position;
u_max_position.base = 0;
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_position = u_max_position.real;
offset += sizeof(this->max_position);
union {
bool real;
uint8_t base;
} u_has_velocity_limits;
u_has_velocity_limits.base = 0;
u_has_velocity_limits.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->has_velocity_limits = u_has_velocity_limits.real;
offset += sizeof(this->has_velocity_limits);
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);
union {
bool real;
uint8_t base;
} u_has_acceleration_limits;
u_has_acceleration_limits.base = 0;
u_has_acceleration_limits.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->has_acceleration_limits = u_has_acceleration_limits.real;
offset += sizeof(this->has_acceleration_limits);
union {
double real;
uint64_t base;
} u_max_acceleration;
u_max_acceleration.base = 0;
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_acceleration.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_acceleration = u_max_acceleration.real;
offset += sizeof(this->max_acceleration);
return offset;
}
const char * getType(){ return "moveit_msgs/JointLimits"; };
const char * getMD5(){ return "8ca618c7329ea46142cbc864a2efe856"; };
};
}
#endif
| 10,648 | C | 43.743697 | 90 | 0.555597 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningOptions.h | #ifndef _ROS_moveit_msgs_PlanningOptions_h
#define _ROS_moveit_msgs_PlanningOptions_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlanningScene.h"
namespace moveit_msgs
{
class PlanningOptions : public ros::Msg
{
public:
typedef moveit_msgs::PlanningScene _planning_scene_diff_type;
_planning_scene_diff_type planning_scene_diff;
typedef bool _plan_only_type;
_plan_only_type plan_only;
typedef bool _look_around_type;
_look_around_type look_around;
typedef int32_t _look_around_attempts_type;
_look_around_attempts_type look_around_attempts;
typedef double _max_safe_execution_cost_type;
_max_safe_execution_cost_type max_safe_execution_cost;
typedef bool _replan_type;
_replan_type replan;
typedef int32_t _replan_attempts_type;
_replan_attempts_type replan_attempts;
typedef double _replan_delay_type;
_replan_delay_type replan_delay;
PlanningOptions():
planning_scene_diff(),
plan_only(0),
look_around(0),
look_around_attempts(0),
max_safe_execution_cost(0),
replan(0),
replan_attempts(0),
replan_delay(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->planning_scene_diff.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_plan_only;
u_plan_only.real = this->plan_only;
*(outbuffer + offset + 0) = (u_plan_only.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->plan_only);
union {
bool real;
uint8_t base;
} u_look_around;
u_look_around.real = this->look_around;
*(outbuffer + offset + 0) = (u_look_around.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->look_around);
union {
int32_t real;
uint32_t base;
} u_look_around_attempts;
u_look_around_attempts.real = this->look_around_attempts;
*(outbuffer + offset + 0) = (u_look_around_attempts.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_look_around_attempts.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_look_around_attempts.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_look_around_attempts.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->look_around_attempts);
union {
double real;
uint64_t base;
} u_max_safe_execution_cost;
u_max_safe_execution_cost.real = this->max_safe_execution_cost;
*(outbuffer + offset + 0) = (u_max_safe_execution_cost.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_safe_execution_cost.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_safe_execution_cost.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_safe_execution_cost.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_safe_execution_cost.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_safe_execution_cost.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_safe_execution_cost.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_safe_execution_cost.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_safe_execution_cost);
union {
bool real;
uint8_t base;
} u_replan;
u_replan.real = this->replan;
*(outbuffer + offset + 0) = (u_replan.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->replan);
union {
int32_t real;
uint32_t base;
} u_replan_attempts;
u_replan_attempts.real = this->replan_attempts;
*(outbuffer + offset + 0) = (u_replan_attempts.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_replan_attempts.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_replan_attempts.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_replan_attempts.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->replan_attempts);
union {
double real;
uint64_t base;
} u_replan_delay;
u_replan_delay.real = this->replan_delay;
*(outbuffer + offset + 0) = (u_replan_delay.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_replan_delay.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_replan_delay.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_replan_delay.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_replan_delay.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_replan_delay.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_replan_delay.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_replan_delay.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->replan_delay);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->planning_scene_diff.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_plan_only;
u_plan_only.base = 0;
u_plan_only.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->plan_only = u_plan_only.real;
offset += sizeof(this->plan_only);
union {
bool real;
uint8_t base;
} u_look_around;
u_look_around.base = 0;
u_look_around.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->look_around = u_look_around.real;
offset += sizeof(this->look_around);
union {
int32_t real;
uint32_t base;
} u_look_around_attempts;
u_look_around_attempts.base = 0;
u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_look_around_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->look_around_attempts = u_look_around_attempts.real;
offset += sizeof(this->look_around_attempts);
union {
double real;
uint64_t base;
} u_max_safe_execution_cost;
u_max_safe_execution_cost.base = 0;
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_safe_execution_cost.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_safe_execution_cost = u_max_safe_execution_cost.real;
offset += sizeof(this->max_safe_execution_cost);
union {
bool real;
uint8_t base;
} u_replan;
u_replan.base = 0;
u_replan.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->replan = u_replan.real;
offset += sizeof(this->replan);
union {
int32_t real;
uint32_t base;
} u_replan_attempts;
u_replan_attempts.base = 0;
u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_replan_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->replan_attempts = u_replan_attempts.real;
offset += sizeof(this->replan_attempts);
union {
double real;
uint64_t base;
} u_replan_delay;
u_replan_delay.base = 0;
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_replan_delay.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->replan_delay = u_replan_delay.real;
offset += sizeof(this->replan_delay);
return offset;
}
const char * getType(){ return "moveit_msgs/PlanningOptions"; };
const char * getMD5(){ return "3934e50ede2ecea03e532aade900ab50"; };
};
}
#endif
| 8,969 | C | 41.511848 | 91 | 0.558925 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/VisibilityConstraint.h | #ifndef _ROS_moveit_msgs_VisibilityConstraint_h
#define _ROS_moveit_msgs_VisibilityConstraint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
namespace moveit_msgs
{
class VisibilityConstraint : public ros::Msg
{
public:
typedef double _target_radius_type;
_target_radius_type target_radius;
typedef geometry_msgs::PoseStamped _target_pose_type;
_target_pose_type target_pose;
typedef int32_t _cone_sides_type;
_cone_sides_type cone_sides;
typedef geometry_msgs::PoseStamped _sensor_pose_type;
_sensor_pose_type sensor_pose;
typedef double _max_view_angle_type;
_max_view_angle_type max_view_angle;
typedef double _max_range_angle_type;
_max_range_angle_type max_range_angle;
typedef uint8_t _sensor_view_direction_type;
_sensor_view_direction_type sensor_view_direction;
typedef double _weight_type;
_weight_type weight;
enum { SENSOR_Z = 0 };
enum { SENSOR_Y = 1 };
enum { SENSOR_X = 2 };
VisibilityConstraint():
target_radius(0),
target_pose(),
cone_sides(0),
sensor_pose(),
max_view_angle(0),
max_range_angle(0),
sensor_view_direction(0),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_target_radius;
u_target_radius.real = this->target_radius;
*(outbuffer + offset + 0) = (u_target_radius.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_target_radius.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_target_radius.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_target_radius.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_target_radius.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_target_radius.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_target_radius.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_target_radius.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->target_radius);
offset += this->target_pose.serialize(outbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_cone_sides;
u_cone_sides.real = this->cone_sides;
*(outbuffer + offset + 0) = (u_cone_sides.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cone_sides.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cone_sides.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cone_sides.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->cone_sides);
offset += this->sensor_pose.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_max_view_angle;
u_max_view_angle.real = this->max_view_angle;
*(outbuffer + offset + 0) = (u_max_view_angle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_view_angle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_view_angle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_view_angle.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_view_angle.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_view_angle.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_view_angle.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_view_angle.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_view_angle);
union {
double real;
uint64_t base;
} u_max_range_angle;
u_max_range_angle.real = this->max_range_angle;
*(outbuffer + offset + 0) = (u_max_range_angle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_range_angle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_range_angle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_range_angle.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_range_angle.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_range_angle.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_range_angle.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_range_angle.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_range_angle);
*(outbuffer + offset + 0) = (this->sensor_view_direction >> (8 * 0)) & 0xFF;
offset += sizeof(this->sensor_view_direction);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_target_radius;
u_target_radius.base = 0;
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_target_radius.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->target_radius = u_target_radius.real;
offset += sizeof(this->target_radius);
offset += this->target_pose.deserialize(inbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_cone_sides;
u_cone_sides.base = 0;
u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cone_sides.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->cone_sides = u_cone_sides.real;
offset += sizeof(this->cone_sides);
offset += this->sensor_pose.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_max_view_angle;
u_max_view_angle.base = 0;
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_view_angle.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_view_angle = u_max_view_angle.real;
offset += sizeof(this->max_view_angle);
union {
double real;
uint64_t base;
} u_max_range_angle;
u_max_range_angle.base = 0;
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_range_angle.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_range_angle = u_max_range_angle.real;
offset += sizeof(this->max_range_angle);
this->sensor_view_direction = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->sensor_view_direction);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/VisibilityConstraint"; };
const char * getMD5(){ return "62cda903bfe31ff2e5fcdc3810d577ad"; };
};
}
#endif
| 9,706 | C | 44.787736 | 83 | 0.538533 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PositionConstraint.h | #ifndef _ROS_moveit_msgs_PositionConstraint_h
#define _ROS_moveit_msgs_PositionConstraint_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Vector3.h"
#include "moveit_msgs/BoundingVolume.h"
namespace moveit_msgs
{
class PositionConstraint : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _link_name_type;
_link_name_type link_name;
typedef geometry_msgs::Vector3 _target_point_offset_type;
_target_point_offset_type target_point_offset;
typedef moveit_msgs::BoundingVolume _constraint_region_type;
_constraint_region_type constraint_region;
typedef double _weight_type;
_weight_type weight;
PositionConstraint():
header(),
link_name(""),
target_point_offset(),
constraint_region(),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
offset += this->target_point_offset.serialize(outbuffer + offset);
offset += this->constraint_region.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
offset += this->target_point_offset.deserialize(inbuffer + offset);
offset += this->constraint_region.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/PositionConstraint"; };
const char * getMD5(){ return "c83edf208d87d3aa3169f47775a58e6a"; };
};
}
#endif
| 3,817 | C | 35.018868 | 74 | 0.586062 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceAction.h | #ifndef _ROS_moveit_msgs_PlaceAction_h
#define _ROS_moveit_msgs_PlaceAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlaceActionGoal.h"
#include "moveit_msgs/PlaceActionResult.h"
#include "moveit_msgs/PlaceActionFeedback.h"
namespace moveit_msgs
{
class PlaceAction : public ros::Msg
{
public:
typedef moveit_msgs::PlaceActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::PlaceActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::PlaceActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
PlaceAction():
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 "moveit_msgs/PlaceAction"; };
const char * getMD5(){ return "75889272b1933a2dc1af2de3bb645a64"; };
};
}
#endif
| 1,572 | C | 26.596491 | 72 | 0.678753 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningSceneWorld.h | #ifndef _ROS_moveit_msgs_PlanningSceneWorld_h
#define _ROS_moveit_msgs_PlanningSceneWorld_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/CollisionObject.h"
#include "octomap_msgs/OctomapWithPose.h"
namespace moveit_msgs
{
class PlanningSceneWorld : public ros::Msg
{
public:
uint32_t collision_objects_length;
typedef moveit_msgs::CollisionObject _collision_objects_type;
_collision_objects_type st_collision_objects;
_collision_objects_type * collision_objects;
typedef octomap_msgs::OctomapWithPose _octomap_type;
_octomap_type octomap;
PlanningSceneWorld():
collision_objects_length(0), collision_objects(NULL),
octomap()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->collision_objects_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->collision_objects_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->collision_objects_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->collision_objects_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->collision_objects_length);
for( uint32_t i = 0; i < collision_objects_length; i++){
offset += this->collision_objects[i].serialize(outbuffer + offset);
}
offset += this->octomap.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t collision_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
collision_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->collision_objects_length);
if(collision_objects_lengthT > collision_objects_length)
this->collision_objects = (moveit_msgs::CollisionObject*)realloc(this->collision_objects, collision_objects_lengthT * sizeof(moveit_msgs::CollisionObject));
collision_objects_length = collision_objects_lengthT;
for( uint32_t i = 0; i < collision_objects_length; i++){
offset += this->st_collision_objects.deserialize(inbuffer + offset);
memcpy( &(this->collision_objects[i]), &(this->st_collision_objects), sizeof(moveit_msgs::CollisionObject));
}
offset += this->octomap.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlanningSceneWorld"; };
const char * getMD5(){ return "373d88390d1db385335639f687723ee6"; };
};
}
#endif
| 2,763 | C | 37.929577 | 164 | 0.651104 |
Subsets and Splits