file_path
stringlengths 21
202
| content
stringlengths 12
1.02M
| size
int64 12
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 3.33
100
| max_line_length
int64 10
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/mini_ros/JoyButtons.h | #ifndef _ROS_mini_ros_JoyButtons_h
#define _ROS_mini_ros_JoyButtons_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class JoyButtons : public ros::Msg
{
public:
typedef int8_t _updown_type;
_updown_type updown;
typedef int8_t _leftright_type;
_leftright_type leftright;
typedef int8_t _left_bump_type;
_left_bump_type left_bump;
typedef int8_t _right_bump_type;
_right_bump_type right_bump;
JoyButtons():
updown(0),
leftright(0),
left_bump(0),
right_bump(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_updown;
u_updown.real = this->updown;
*(outbuffer + offset + 0) = (u_updown.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->updown);
union {
int8_t real;
uint8_t base;
} u_leftright;
u_leftright.real = this->leftright;
*(outbuffer + offset + 0) = (u_leftright.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->leftright);
union {
int8_t real;
uint8_t base;
} u_left_bump;
u_left_bump.real = this->left_bump;
*(outbuffer + offset + 0) = (u_left_bump.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->left_bump);
union {
int8_t real;
uint8_t base;
} u_right_bump;
u_right_bump.real = this->right_bump;
*(outbuffer + offset + 0) = (u_right_bump.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->right_bump);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_updown;
u_updown.base = 0;
u_updown.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->updown = u_updown.real;
offset += sizeof(this->updown);
union {
int8_t real;
uint8_t base;
} u_leftright;
u_leftright.base = 0;
u_leftright.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->leftright = u_leftright.real;
offset += sizeof(this->leftright);
union {
int8_t real;
uint8_t base;
} u_left_bump;
u_left_bump.base = 0;
u_left_bump.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->left_bump = u_left_bump.real;
offset += sizeof(this->left_bump);
union {
int8_t real;
uint8_t base;
} u_right_bump;
u_right_bump.base = 0;
u_right_bump.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->right_bump = u_right_bump.real;
offset += sizeof(this->right_bump);
return offset;
}
const char * getType(){ return "mini_ros/JoyButtons"; };
const char * getMD5(){ return "be1de48c3b52ec87587be0e78c2cb8cd"; };
};
}
#endif
| 2,961 | C | 25.684684 | 77 | 0.541709 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/MiniCmd.h | #ifndef _ROS_mini_ros_MiniCmd_h
#define _ROS_mini_ros_MiniCmd_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class MiniCmd : public ros::Msg
{
public:
typedef const char* _motion_type;
_motion_type motion;
typedef const char* _movement_type;
_movement_type movement;
typedef float _x_velocity_type;
_x_velocity_type x_velocity;
typedef float _y_velocity_type;
_y_velocity_type y_velocity;
typedef float _rate_type;
_rate_type rate;
typedef float _roll_type;
_roll_type roll;
typedef float _pitch_type;
_pitch_type pitch;
typedef float _yaw_type;
_yaw_type yaw;
typedef float _z_type;
_z_type z;
typedef float _faster_type;
_faster_type faster;
typedef float _slower_type;
_slower_type slower;
MiniCmd():
motion(""),
movement(""),
x_velocity(0),
y_velocity(0),
rate(0),
roll(0),
pitch(0),
yaw(0),
z(0),
faster(0),
slower(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_motion = strlen(this->motion);
varToArr(outbuffer + offset, length_motion);
offset += 4;
memcpy(outbuffer + offset, this->motion, length_motion);
offset += length_motion;
uint32_t length_movement = strlen(this->movement);
varToArr(outbuffer + offset, length_movement);
offset += 4;
memcpy(outbuffer + offset, this->movement, length_movement);
offset += length_movement;
union {
float real;
uint32_t base;
} u_x_velocity;
u_x_velocity.real = this->x_velocity;
*(outbuffer + offset + 0) = (u_x_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x_velocity);
union {
float real;
uint32_t base;
} u_y_velocity;
u_y_velocity.real = this->y_velocity;
*(outbuffer + offset + 0) = (u_y_velocity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y_velocity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y_velocity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y_velocity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y_velocity);
union {
float real;
uint32_t base;
} u_rate;
u_rate.real = this->rate;
*(outbuffer + offset + 0) = (u_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_rate.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->rate);
union {
float real;
uint32_t base;
} u_roll;
u_roll.real = this->roll;
*(outbuffer + offset + 0) = (u_roll.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_roll.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_roll.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_roll.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->roll);
union {
float real;
uint32_t base;
} u_pitch;
u_pitch.real = this->pitch;
*(outbuffer + offset + 0) = (u_pitch.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_pitch.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_pitch.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_pitch.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->pitch);
union {
float real;
uint32_t base;
} u_yaw;
u_yaw.real = this->yaw;
*(outbuffer + offset + 0) = (u_yaw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_yaw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_yaw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_yaw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->yaw);
union {
float real;
uint32_t base;
} u_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->z);
union {
float real;
uint32_t base;
} u_faster;
u_faster.real = this->faster;
*(outbuffer + offset + 0) = (u_faster.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_faster.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_faster.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_faster.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->faster);
union {
float real;
uint32_t base;
} u_slower;
u_slower.real = this->slower;
*(outbuffer + offset + 0) = (u_slower.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_slower.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_slower.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_slower.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->slower);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_motion;
arrToVar(length_motion, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_motion; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_motion-1]=0;
this->motion = (char *)(inbuffer + offset-1);
offset += length_motion;
uint32_t length_movement;
arrToVar(length_movement, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_movement; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_movement-1]=0;
this->movement = (char *)(inbuffer + offset-1);
offset += length_movement;
union {
float real;
uint32_t base;
} u_x_velocity;
u_x_velocity.base = 0;
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x_velocity = u_x_velocity.real;
offset += sizeof(this->x_velocity);
union {
float real;
uint32_t base;
} u_y_velocity;
u_y_velocity.base = 0;
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y_velocity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y_velocity = u_y_velocity.real;
offset += sizeof(this->y_velocity);
union {
float real;
uint32_t base;
} u_rate;
u_rate.base = 0;
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_rate.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->rate = u_rate.real;
offset += sizeof(this->rate);
union {
float real;
uint32_t base;
} u_roll;
u_roll.base = 0;
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_roll.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->roll = u_roll.real;
offset += sizeof(this->roll);
union {
float real;
uint32_t base;
} u_pitch;
u_pitch.base = 0;
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_pitch.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->pitch = u_pitch.real;
offset += sizeof(this->pitch);
union {
float real;
uint32_t base;
} u_yaw;
u_yaw.base = 0;
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_yaw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->yaw = u_yaw.real;
offset += sizeof(this->yaw);
union {
float real;
uint32_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->z = u_z.real;
offset += sizeof(this->z);
union {
float real;
uint32_t base;
} u_faster;
u_faster.base = 0;
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_faster.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->faster = u_faster.real;
offset += sizeof(this->faster);
union {
float real;
uint32_t base;
} u_slower;
u_slower.base = 0;
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_slower.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->slower = u_slower.real;
offset += sizeof(this->slower);
return offset;
}
const char * getType(){ return "mini_ros/MiniCmd"; };
const char * getMD5(){ return "83510b9a5f454bd3ceb898b52e349406"; };
};
}
#endif
| 10,612 | C | 35.723183 | 78 | 0.50311 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/mini_ros/JointAngles.h | #ifndef _ROS_mini_ros_JointAngles_h
#define _ROS_mini_ros_JointAngles_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace mini_ros
{
class JointAngles : public ros::Msg
{
public:
typedef float _fls_type;
_fls_type fls;
typedef float _fle_type;
_fle_type fle;
typedef float _flw_type;
_flw_type flw;
typedef float _frs_type;
_frs_type frs;
typedef float _fre_type;
_fre_type fre;
typedef float _frw_type;
_frw_type frw;
typedef float _bls_type;
_bls_type bls;
typedef float _ble_type;
_ble_type ble;
typedef float _blw_type;
_blw_type blw;
typedef float _brs_type;
_brs_type brs;
typedef float _bre_type;
_bre_type bre;
typedef float _brw_type;
_brw_type brw;
typedef bool _step_or_view_type;
_step_or_view_type step_or_view;
JointAngles():
fls(0),
fle(0),
flw(0),
frs(0),
fre(0),
frw(0),
bls(0),
ble(0),
blw(0),
brs(0),
bre(0),
brw(0),
step_or_view(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_fls;
u_fls.real = this->fls;
*(outbuffer + offset + 0) = (u_fls.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fls.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fls.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fls.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fls);
union {
float real;
uint32_t base;
} u_fle;
u_fle.real = this->fle;
*(outbuffer + offset + 0) = (u_fle.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fle.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fle.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fle.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fle);
union {
float real;
uint32_t base;
} u_flw;
u_flw.real = this->flw;
*(outbuffer + offset + 0) = (u_flw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_flw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_flw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_flw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->flw);
union {
float real;
uint32_t base;
} u_frs;
u_frs.real = this->frs;
*(outbuffer + offset + 0) = (u_frs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_frs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_frs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_frs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->frs);
union {
float real;
uint32_t base;
} u_fre;
u_fre.real = this->fre;
*(outbuffer + offset + 0) = (u_fre.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fre.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fre.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fre.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->fre);
union {
float real;
uint32_t base;
} u_frw;
u_frw.real = this->frw;
*(outbuffer + offset + 0) = (u_frw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_frw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_frw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_frw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->frw);
union {
float real;
uint32_t base;
} u_bls;
u_bls.real = this->bls;
*(outbuffer + offset + 0) = (u_bls.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_bls.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_bls.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_bls.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->bls);
union {
float real;
uint32_t base;
} u_ble;
u_ble.real = this->ble;
*(outbuffer + offset + 0) = (u_ble.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ble.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ble.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ble.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->ble);
union {
float real;
uint32_t base;
} u_blw;
u_blw.real = this->blw;
*(outbuffer + offset + 0) = (u_blw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_blw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_blw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_blw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->blw);
union {
float real;
uint32_t base;
} u_brs;
u_brs.real = this->brs;
*(outbuffer + offset + 0) = (u_brs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_brs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_brs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_brs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->brs);
union {
float real;
uint32_t base;
} u_bre;
u_bre.real = this->bre;
*(outbuffer + offset + 0) = (u_bre.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_bre.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_bre.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_bre.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->bre);
union {
float real;
uint32_t base;
} u_brw;
u_brw.real = this->brw;
*(outbuffer + offset + 0) = (u_brw.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_brw.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_brw.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_brw.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->brw);
union {
bool real;
uint8_t base;
} u_step_or_view;
u_step_or_view.real = this->step_or_view;
*(outbuffer + offset + 0) = (u_step_or_view.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->step_or_view);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_fls;
u_fls.base = 0;
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fls.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fls = u_fls.real;
offset += sizeof(this->fls);
union {
float real;
uint32_t base;
} u_fle;
u_fle.base = 0;
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fle.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fle = u_fle.real;
offset += sizeof(this->fle);
union {
float real;
uint32_t base;
} u_flw;
u_flw.base = 0;
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_flw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->flw = u_flw.real;
offset += sizeof(this->flw);
union {
float real;
uint32_t base;
} u_frs;
u_frs.base = 0;
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_frs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->frs = u_frs.real;
offset += sizeof(this->frs);
union {
float real;
uint32_t base;
} u_fre;
u_fre.base = 0;
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fre.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->fre = u_fre.real;
offset += sizeof(this->fre);
union {
float real;
uint32_t base;
} u_frw;
u_frw.base = 0;
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_frw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->frw = u_frw.real;
offset += sizeof(this->frw);
union {
float real;
uint32_t base;
} u_bls;
u_bls.base = 0;
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_bls.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->bls = u_bls.real;
offset += sizeof(this->bls);
union {
float real;
uint32_t base;
} u_ble;
u_ble.base = 0;
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ble.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->ble = u_ble.real;
offset += sizeof(this->ble);
union {
float real;
uint32_t base;
} u_blw;
u_blw.base = 0;
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_blw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->blw = u_blw.real;
offset += sizeof(this->blw);
union {
float real;
uint32_t base;
} u_brs;
u_brs.base = 0;
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_brs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->brs = u_brs.real;
offset += sizeof(this->brs);
union {
float real;
uint32_t base;
} u_bre;
u_bre.base = 0;
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_bre.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->bre = u_bre.real;
offset += sizeof(this->bre);
union {
float real;
uint32_t base;
} u_brw;
u_brw.base = 0;
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_brw.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->brw = u_brw.real;
offset += sizeof(this->brw);
union {
bool real;
uint8_t base;
} u_step_or_view;
u_step_or_view.base = 0;
u_step_or_view.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->step_or_view = u_step_or_view.real;
offset += sizeof(this->step_or_view);
return offset;
}
const char * getType(){ return "mini_ros/JointAngles"; };
const char * getMD5(){ return "54bfcd55046a61d9df3827d322506389"; };
};
}
#endif
| 12,233 | C | 34.460869 | 79 | 0.467751 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/stereo_msgs/DisparityImage.h | #ifndef _ROS_stereo_msgs_DisparityImage_h
#define _ROS_stereo_msgs_DisparityImage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/Image.h"
#include "sensor_msgs/RegionOfInterest.h"
namespace stereo_msgs
{
class DisparityImage : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef sensor_msgs::Image _image_type;
_image_type image;
typedef float _f_type;
_f_type f;
typedef float _T_type;
_T_type T;
typedef sensor_msgs::RegionOfInterest _valid_window_type;
_valid_window_type valid_window;
typedef float _min_disparity_type;
_min_disparity_type min_disparity;
typedef float _max_disparity_type;
_max_disparity_type max_disparity;
typedef float _delta_d_type;
_delta_d_type delta_d;
DisparityImage():
header(),
image(),
f(0),
T(0),
valid_window(),
min_disparity(0),
max_disparity(0),
delta_d(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->image.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_f;
u_f.real = this->f;
*(outbuffer + offset + 0) = (u_f.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_f.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_f.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_f.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->f);
union {
float real;
uint32_t base;
} u_T;
u_T.real = this->T;
*(outbuffer + offset + 0) = (u_T.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_T.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_T.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_T.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->T);
offset += this->valid_window.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_min_disparity;
u_min_disparity.real = this->min_disparity;
*(outbuffer + offset + 0) = (u_min_disparity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_disparity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_disparity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_disparity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_disparity);
union {
float real;
uint32_t base;
} u_max_disparity;
u_max_disparity.real = this->max_disparity;
*(outbuffer + offset + 0) = (u_max_disparity.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_disparity.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_disparity.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_disparity.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_disparity);
union {
float real;
uint32_t base;
} u_delta_d;
u_delta_d.real = this->delta_d;
*(outbuffer + offset + 0) = (u_delta_d.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_delta_d.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_delta_d.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_delta_d.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->delta_d);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->image.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_f;
u_f.base = 0;
u_f.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_f.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_f.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_f.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->f = u_f.real;
offset += sizeof(this->f);
union {
float real;
uint32_t base;
} u_T;
u_T.base = 0;
u_T.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_T.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_T.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_T.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->T = u_T.real;
offset += sizeof(this->T);
offset += this->valid_window.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_min_disparity;
u_min_disparity.base = 0;
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->min_disparity = u_min_disparity.real;
offset += sizeof(this->min_disparity);
union {
float real;
uint32_t base;
} u_max_disparity;
u_max_disparity.base = 0;
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_disparity.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->max_disparity = u_max_disparity.real;
offset += sizeof(this->max_disparity);
union {
float real;
uint32_t base;
} u_delta_d;
u_delta_d.base = 0;
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_delta_d.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->delta_d = u_delta_d.real;
offset += sizeof(this->delta_d);
return offset;
}
const char * getType(){ return "stereo_msgs/DisparityImage"; };
const char * getMD5(){ return "04a177815f75271039fa21f16acad8c9"; };
};
}
#endif
| 6,427 | C | 35.316384 | 81 | 0.526062 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/RobustControllerStatus.h | #ifndef _ROS_baxter_core_msgs_RobustControllerStatus_h
#define _ROS_baxter_core_msgs_RobustControllerStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class RobustControllerStatus : public ros::Msg
{
public:
typedef bool _isEnabled_type;
_isEnabled_type isEnabled;
typedef int32_t _complete_type;
_complete_type complete;
typedef const char* _controlUid_type;
_controlUid_type controlUid;
typedef bool _timedOut_type;
_timedOut_type timedOut;
uint32_t errorCodes_length;
typedef char* _errorCodes_type;
_errorCodes_type st_errorCodes;
_errorCodes_type * errorCodes;
uint32_t labels_length;
typedef char* _labels_type;
_labels_type st_labels;
_labels_type * labels;
enum { NOT_COMPLETE = 0 };
enum { COMPLETE_W_FAILURE = 1 };
enum { COMPLETE_W_SUCCESS = 2 };
RobustControllerStatus():
isEnabled(0),
complete(0),
controlUid(""),
timedOut(0),
errorCodes_length(0), errorCodes(NULL),
labels_length(0), labels(NULL)
{
}
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);
union {
int32_t real;
uint32_t base;
} u_complete;
u_complete.real = this->complete;
*(outbuffer + offset + 0) = (u_complete.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_complete.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_complete.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_complete.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->complete);
uint32_t length_controlUid = strlen(this->controlUid);
varToArr(outbuffer + offset, length_controlUid);
offset += 4;
memcpy(outbuffer + offset, this->controlUid, length_controlUid);
offset += length_controlUid;
union {
bool real;
uint8_t base;
} u_timedOut;
u_timedOut.real = this->timedOut;
*(outbuffer + offset + 0) = (u_timedOut.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->timedOut);
*(outbuffer + offset + 0) = (this->errorCodes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->errorCodes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->errorCodes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->errorCodes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->errorCodes_length);
for( uint32_t i = 0; i < errorCodes_length; i++){
uint32_t length_errorCodesi = strlen(this->errorCodes[i]);
varToArr(outbuffer + offset, length_errorCodesi);
offset += 4;
memcpy(outbuffer + offset, this->errorCodes[i], length_errorCodesi);
offset += length_errorCodesi;
}
*(outbuffer + offset + 0) = (this->labels_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->labels_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->labels_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->labels_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->labels_length);
for( uint32_t i = 0; i < labels_length; i++){
uint32_t length_labelsi = strlen(this->labels[i]);
varToArr(outbuffer + offset, length_labelsi);
offset += 4;
memcpy(outbuffer + offset, this->labels[i], length_labelsi);
offset += length_labelsi;
}
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);
union {
int32_t real;
uint32_t base;
} u_complete;
u_complete.base = 0;
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_complete.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->complete = u_complete.real;
offset += sizeof(this->complete);
uint32_t length_controlUid;
arrToVar(length_controlUid, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_controlUid; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_controlUid-1]=0;
this->controlUid = (char *)(inbuffer + offset-1);
offset += length_controlUid;
union {
bool real;
uint8_t base;
} u_timedOut;
u_timedOut.base = 0;
u_timedOut.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->timedOut = u_timedOut.real;
offset += sizeof(this->timedOut);
uint32_t errorCodes_lengthT = ((uint32_t) (*(inbuffer + offset)));
errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
errorCodes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->errorCodes_length);
if(errorCodes_lengthT > errorCodes_length)
this->errorCodes = (char**)realloc(this->errorCodes, errorCodes_lengthT * sizeof(char*));
errorCodes_length = errorCodes_lengthT;
for( uint32_t i = 0; i < errorCodes_length; i++){
uint32_t length_st_errorCodes;
arrToVar(length_st_errorCodes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_errorCodes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_errorCodes-1]=0;
this->st_errorCodes = (char *)(inbuffer + offset-1);
offset += length_st_errorCodes;
memcpy( &(this->errorCodes[i]), &(this->st_errorCodes), sizeof(char*));
}
uint32_t labels_lengthT = ((uint32_t) (*(inbuffer + offset)));
labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->labels_length);
if(labels_lengthT > labels_length)
this->labels = (char**)realloc(this->labels, labels_lengthT * sizeof(char*));
labels_length = labels_lengthT;
for( uint32_t i = 0; i < labels_length; i++){
uint32_t length_st_labels;
arrToVar(length_st_labels, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_labels; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_labels-1]=0;
this->st_labels = (char *)(inbuffer + offset-1);
offset += length_st_labels;
memcpy( &(this->labels[i]), &(this->st_labels), sizeof(char*));
}
return offset;
}
const char * getType(){ return "baxter_core_msgs/RobustControllerStatus"; };
const char * getMD5(){ return "2f15441b7285d915e7e59d3618e173f2"; };
};
}
#endif
| 7,461 | C | 37.663212 | 97 | 0.576062 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/CloseCamera.h | #ifndef _ROS_SERVICE_CloseCamera_h
#define _ROS_SERVICE_CloseCamera_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
static const char CLOSECAMERA[] = "baxter_core_msgs/CloseCamera";
class CloseCameraRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
CloseCameraRequest():
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 CLOSECAMERA; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class CloseCameraResponse : public ros::Msg
{
public:
typedef int32_t _err_type;
_err_type err;
CloseCameraResponse():
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 CLOSECAMERA; };
const char * getMD5(){ return "b6e094011a4dfaee5eddf447220446cf"; };
};
class CloseCamera {
public:
typedef CloseCameraRequest Request;
typedef CloseCameraResponse Response;
};
}
#endif
| 2,814 | C | 24.133928 | 72 | 0.56823 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/EndEffectorProperties.h | #ifndef _ROS_baxter_core_msgs_EndEffectorProperties_h
#define _ROS_baxter_core_msgs_EndEffectorProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace baxter_core_msgs
{
class EndEffectorProperties : public ros::Msg
{
public:
typedef uint32_t _id_type;
_id_type id;
typedef uint8_t _ui_type_type;
_ui_type_type ui_type;
typedef const char* _manufacturer_type;
_manufacturer_type manufacturer;
typedef const char* _product_type;
_product_type product;
typedef const char* _serial_number_type;
_serial_number_type serial_number;
typedef const char* _hardware_rev_type;
_hardware_rev_type hardware_rev;
typedef const char* _firmware_rev_type;
_firmware_rev_type firmware_rev;
typedef const char* _firmware_date_type;
_firmware_date_type firmware_date;
typedef bool _has_calibration_type;
_has_calibration_type has_calibration;
typedef bool _controls_grip_type;
_controls_grip_type controls_grip;
typedef bool _senses_grip_type;
_senses_grip_type senses_grip;
typedef bool _reverses_grip_type;
_reverses_grip_type reverses_grip;
typedef bool _controls_force_type;
_controls_force_type controls_force;
typedef bool _senses_force_type;
_senses_force_type senses_force;
typedef bool _controls_position_type;
_controls_position_type controls_position;
typedef bool _senses_position_type;
_senses_position_type senses_position;
typedef const char* _properties_type;
_properties_type properties;
enum { NO_GRIPPER = 0 };
enum { SUCTION_CUP_GRIPPER = 1 };
enum { ELECTRIC_GRIPPER = 2 };
enum { PASSIVE_GRIPPER = 3 };
EndEffectorProperties():
id(0),
ui_type(0),
manufacturer(""),
product(""),
serial_number(""),
hardware_rev(""),
firmware_rev(""),
firmware_date(""),
has_calibration(0),
controls_grip(0),
senses_grip(0),
reverses_grip(0),
controls_force(0),
senses_force(0),
controls_position(0),
senses_position(0),
properties("")
{
}
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);
*(outbuffer + offset + 0) = (this->ui_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->ui_type);
uint32_t length_manufacturer = strlen(this->manufacturer);
varToArr(outbuffer + offset, length_manufacturer);
offset += 4;
memcpy(outbuffer + offset, this->manufacturer, length_manufacturer);
offset += length_manufacturer;
uint32_t length_product = strlen(this->product);
varToArr(outbuffer + offset, length_product);
offset += 4;
memcpy(outbuffer + offset, this->product, length_product);
offset += length_product;
uint32_t length_serial_number = strlen(this->serial_number);
varToArr(outbuffer + offset, length_serial_number);
offset += 4;
memcpy(outbuffer + offset, this->serial_number, length_serial_number);
offset += length_serial_number;
uint32_t length_hardware_rev = strlen(this->hardware_rev);
varToArr(outbuffer + offset, length_hardware_rev);
offset += 4;
memcpy(outbuffer + offset, this->hardware_rev, length_hardware_rev);
offset += length_hardware_rev;
uint32_t length_firmware_rev = strlen(this->firmware_rev);
varToArr(outbuffer + offset, length_firmware_rev);
offset += 4;
memcpy(outbuffer + offset, this->firmware_rev, length_firmware_rev);
offset += length_firmware_rev;
uint32_t length_firmware_date = strlen(this->firmware_date);
varToArr(outbuffer + offset, length_firmware_date);
offset += 4;
memcpy(outbuffer + offset, this->firmware_date, length_firmware_date);
offset += length_firmware_date;
union {
bool real;
uint8_t base;
} u_has_calibration;
u_has_calibration.real = this->has_calibration;
*(outbuffer + offset + 0) = (u_has_calibration.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->has_calibration);
union {
bool real;
uint8_t base;
} u_controls_grip;
u_controls_grip.real = this->controls_grip;
*(outbuffer + offset + 0) = (u_controls_grip.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->controls_grip);
union {
bool real;
uint8_t base;
} u_senses_grip;
u_senses_grip.real = this->senses_grip;
*(outbuffer + offset + 0) = (u_senses_grip.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->senses_grip);
union {
bool real;
uint8_t base;
} u_reverses_grip;
u_reverses_grip.real = this->reverses_grip;
*(outbuffer + offset + 0) = (u_reverses_grip.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->reverses_grip);
union {
bool real;
uint8_t base;
} u_controls_force;
u_controls_force.real = this->controls_force;
*(outbuffer + offset + 0) = (u_controls_force.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->controls_force);
union {
bool real;
uint8_t base;
} u_senses_force;
u_senses_force.real = this->senses_force;
*(outbuffer + offset + 0) = (u_senses_force.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->senses_force);
union {
bool real;
uint8_t base;
} u_controls_position;
u_controls_position.real = this->controls_position;
*(outbuffer + offset + 0) = (u_controls_position.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->controls_position);
union {
bool real;
uint8_t base;
} u_senses_position;
u_senses_position.real = this->senses_position;
*(outbuffer + offset + 0) = (u_senses_position.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->senses_position);
uint32_t length_properties = strlen(this->properties);
varToArr(outbuffer + offset, length_properties);
offset += 4;
memcpy(outbuffer + offset, this->properties, length_properties);
offset += length_properties;
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);
this->ui_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->ui_type);
uint32_t length_manufacturer;
arrToVar(length_manufacturer, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_manufacturer; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_manufacturer-1]=0;
this->manufacturer = (char *)(inbuffer + offset-1);
offset += length_manufacturer;
uint32_t length_product;
arrToVar(length_product, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_product; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_product-1]=0;
this->product = (char *)(inbuffer + offset-1);
offset += length_product;
uint32_t length_serial_number;
arrToVar(length_serial_number, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_serial_number; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_serial_number-1]=0;
this->serial_number = (char *)(inbuffer + offset-1);
offset += length_serial_number;
uint32_t length_hardware_rev;
arrToVar(length_hardware_rev, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_hardware_rev; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_hardware_rev-1]=0;
this->hardware_rev = (char *)(inbuffer + offset-1);
offset += length_hardware_rev;
uint32_t length_firmware_rev;
arrToVar(length_firmware_rev, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_firmware_rev; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_firmware_rev-1]=0;
this->firmware_rev = (char *)(inbuffer + offset-1);
offset += length_firmware_rev;
uint32_t length_firmware_date;
arrToVar(length_firmware_date, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_firmware_date; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_firmware_date-1]=0;
this->firmware_date = (char *)(inbuffer + offset-1);
offset += length_firmware_date;
union {
bool real;
uint8_t base;
} u_has_calibration;
u_has_calibration.base = 0;
u_has_calibration.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->has_calibration = u_has_calibration.real;
offset += sizeof(this->has_calibration);
union {
bool real;
uint8_t base;
} u_controls_grip;
u_controls_grip.base = 0;
u_controls_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->controls_grip = u_controls_grip.real;
offset += sizeof(this->controls_grip);
union {
bool real;
uint8_t base;
} u_senses_grip;
u_senses_grip.base = 0;
u_senses_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->senses_grip = u_senses_grip.real;
offset += sizeof(this->senses_grip);
union {
bool real;
uint8_t base;
} u_reverses_grip;
u_reverses_grip.base = 0;
u_reverses_grip.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->reverses_grip = u_reverses_grip.real;
offset += sizeof(this->reverses_grip);
union {
bool real;
uint8_t base;
} u_controls_force;
u_controls_force.base = 0;
u_controls_force.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->controls_force = u_controls_force.real;
offset += sizeof(this->controls_force);
union {
bool real;
uint8_t base;
} u_senses_force;
u_senses_force.base = 0;
u_senses_force.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->senses_force = u_senses_force.real;
offset += sizeof(this->senses_force);
union {
bool real;
uint8_t base;
} u_controls_position;
u_controls_position.base = 0;
u_controls_position.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->controls_position = u_controls_position.real;
offset += sizeof(this->controls_position);
union {
bool real;
uint8_t base;
} u_senses_position;
u_senses_position.base = 0;
u_senses_position.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->senses_position = u_senses_position.real;
offset += sizeof(this->senses_position);
uint32_t length_properties;
arrToVar(length_properties, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_properties; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_properties-1]=0;
this->properties = (char *)(inbuffer + offset-1);
offset += length_properties;
return offset;
}
const char * getType(){ return "baxter_core_msgs/EndEffectorProperties"; };
const char * getMD5(){ return "21b83773ab9a35216d11e427573c76cc"; };
};
}
#endif
| 12,110 | C | 36.150307 | 84 | 0.591164 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/baxter_core_msgs/SolvePositionIK.h | #ifndef _ROS_SERVICE_SolvePositionIK_h
#define _ROS_SERVICE_SolvePositionIK_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/PoseStamped.h"
#include "sensor_msgs/JointState.h"
namespace baxter_core_msgs
{
static const char SOLVEPOSITIONIK[] = "baxter_core_msgs/SolvePositionIK";
class SolvePositionIKRequest : public ros::Msg
{
public:
uint32_t pose_stamp_length;
typedef geometry_msgs::PoseStamped _pose_stamp_type;
_pose_stamp_type st_pose_stamp;
_pose_stamp_type * pose_stamp;
uint32_t seed_angles_length;
typedef sensor_msgs::JointState _seed_angles_type;
_seed_angles_type st_seed_angles;
_seed_angles_type * seed_angles;
typedef uint8_t _seed_mode_type;
_seed_mode_type seed_mode;
enum { SEED_AUTO = 0 };
enum { SEED_USER = 1 };
enum { SEED_CURRENT = 2 };
enum { SEED_NS_MAP = 3 };
SolvePositionIKRequest():
pose_stamp_length(0), pose_stamp(NULL),
seed_angles_length(0), seed_angles(NULL),
seed_mode(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->pose_stamp_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_stamp_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_stamp_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_stamp_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_stamp_length);
for( uint32_t i = 0; i < pose_stamp_length; i++){
offset += this->pose_stamp[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->seed_angles_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->seed_angles_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->seed_angles_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->seed_angles_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->seed_angles_length);
for( uint32_t i = 0; i < seed_angles_length; i++){
offset += this->seed_angles[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->seed_mode >> (8 * 0)) & 0xFF;
offset += sizeof(this->seed_mode);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t pose_stamp_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_stamp_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_stamp_length);
if(pose_stamp_lengthT > pose_stamp_length)
this->pose_stamp = (geometry_msgs::PoseStamped*)realloc(this->pose_stamp, pose_stamp_lengthT * sizeof(geometry_msgs::PoseStamped));
pose_stamp_length = pose_stamp_lengthT;
for( uint32_t i = 0; i < pose_stamp_length; i++){
offset += this->st_pose_stamp.deserialize(inbuffer + offset);
memcpy( &(this->pose_stamp[i]), &(this->st_pose_stamp), sizeof(geometry_msgs::PoseStamped));
}
uint32_t seed_angles_lengthT = ((uint32_t) (*(inbuffer + offset)));
seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
seed_angles_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->seed_angles_length);
if(seed_angles_lengthT > seed_angles_length)
this->seed_angles = (sensor_msgs::JointState*)realloc(this->seed_angles, seed_angles_lengthT * sizeof(sensor_msgs::JointState));
seed_angles_length = seed_angles_lengthT;
for( uint32_t i = 0; i < seed_angles_length; i++){
offset += this->st_seed_angles.deserialize(inbuffer + offset);
memcpy( &(this->seed_angles[i]), &(this->st_seed_angles), sizeof(sensor_msgs::JointState));
}
this->seed_mode = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->seed_mode);
return offset;
}
const char * getType(){ return SOLVEPOSITIONIK; };
const char * getMD5(){ return "2587e42983d0081d0a2288230991073b"; };
};
class SolvePositionIKResponse : public ros::Msg
{
public:
uint32_t joints_length;
typedef sensor_msgs::JointState _joints_type;
_joints_type st_joints;
_joints_type * joints;
uint32_t isValid_length;
typedef bool _isValid_type;
_isValid_type st_isValid;
_isValid_type * isValid;
uint32_t result_type_length;
typedef uint8_t _result_type_type;
_result_type_type st_result_type;
_result_type_type * result_type;
enum { RESULT_INVALID = 0 };
SolvePositionIKResponse():
joints_length(0), joints(NULL),
isValid_length(0), isValid(NULL),
result_type_length(0), result_type(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joints_length);
for( uint32_t i = 0; i < joints_length; i++){
offset += this->joints[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->isValid_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->isValid_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->isValid_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->isValid_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->isValid_length);
for( uint32_t i = 0; i < isValid_length; i++){
union {
bool real;
uint8_t base;
} u_isValidi;
u_isValidi.real = this->isValid[i];
*(outbuffer + offset + 0) = (u_isValidi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->isValid[i]);
}
*(outbuffer + offset + 0) = (this->result_type_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->result_type_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->result_type_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->result_type_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->result_type_length);
for( uint32_t i = 0; i < result_type_length; i++){
*(outbuffer + offset + 0) = (this->result_type[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->result_type[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joints_lengthT = ((uint32_t) (*(inbuffer + offset)));
joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joints_length);
if(joints_lengthT > joints_length)
this->joints = (sensor_msgs::JointState*)realloc(this->joints, joints_lengthT * sizeof(sensor_msgs::JointState));
joints_length = joints_lengthT;
for( uint32_t i = 0; i < joints_length; i++){
offset += this->st_joints.deserialize(inbuffer + offset);
memcpy( &(this->joints[i]), &(this->st_joints), sizeof(sensor_msgs::JointState));
}
uint32_t isValid_lengthT = ((uint32_t) (*(inbuffer + offset)));
isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
isValid_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->isValid_length);
if(isValid_lengthT > isValid_length)
this->isValid = (bool*)realloc(this->isValid, isValid_lengthT * sizeof(bool));
isValid_length = isValid_lengthT;
for( uint32_t i = 0; i < isValid_length; i++){
union {
bool real;
uint8_t base;
} u_st_isValid;
u_st_isValid.base = 0;
u_st_isValid.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_isValid = u_st_isValid.real;
offset += sizeof(this->st_isValid);
memcpy( &(this->isValid[i]), &(this->st_isValid), sizeof(bool));
}
uint32_t result_type_lengthT = ((uint32_t) (*(inbuffer + offset)));
result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
result_type_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->result_type_length);
if(result_type_lengthT > result_type_length)
this->result_type = (uint8_t*)realloc(this->result_type, result_type_lengthT * sizeof(uint8_t));
result_type_length = result_type_lengthT;
for( uint32_t i = 0; i < result_type_length; i++){
this->st_result_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_result_type);
memcpy( &(this->result_type[i]), &(this->st_result_type), sizeof(uint8_t));
}
return offset;
}
const char * getType(){ return SOLVEPOSITIONIK; };
const char * getMD5(){ return "d9b0c2b3932e08421f5094cf62743b9f"; };
};
class SolvePositionIK {
public:
typedef SolvePositionIKRequest Request;
typedef SolvePositionIKResponse Response;
};
}
#endif
| 9,731 | C | 42.253333 | 139 | 0.581749 |
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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AttachedCollisionObject.h | #ifndef _ROS_moveit_msgs_AttachedCollisionObject_h
#define _ROS_moveit_msgs_AttachedCollisionObject_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/CollisionObject.h"
#include "trajectory_msgs/JointTrajectory.h"
namespace moveit_msgs
{
class AttachedCollisionObject : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef moveit_msgs::CollisionObject _object_type;
_object_type object;
uint32_t touch_links_length;
typedef char* _touch_links_type;
_touch_links_type st_touch_links;
_touch_links_type * touch_links;
typedef trajectory_msgs::JointTrajectory _detach_posture_type;
_detach_posture_type detach_posture;
typedef double _weight_type;
_weight_type weight;
AttachedCollisionObject():
link_name(""),
object(),
touch_links_length(0), touch_links(NULL),
detach_posture(),
weight(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;
offset += this->object.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->touch_links_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->touch_links_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->touch_links_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->touch_links_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->touch_links_length);
for( uint32_t i = 0; i < touch_links_length; i++){
uint32_t length_touch_linksi = strlen(this->touch_links[i]);
varToArr(outbuffer + offset, length_touch_linksi);
offset += 4;
memcpy(outbuffer + offset, this->touch_links[i], length_touch_linksi);
offset += length_touch_linksi;
}
offset += this->detach_posture.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;
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->object.deserialize(inbuffer + offset);
uint32_t touch_links_lengthT = ((uint32_t) (*(inbuffer + offset)));
touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->touch_links_length);
if(touch_links_lengthT > touch_links_length)
this->touch_links = (char**)realloc(this->touch_links, touch_links_lengthT * sizeof(char*));
touch_links_length = touch_links_lengthT;
for( uint32_t i = 0; i < touch_links_length; i++){
uint32_t length_st_touch_links;
arrToVar(length_st_touch_links, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_touch_links; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_touch_links-1]=0;
this->st_touch_links = (char *)(inbuffer + offset-1);
offset += length_st_touch_links;
memcpy( &(this->touch_links[i]), &(this->st_touch_links), sizeof(char*));
}
offset += this->detach_posture.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/AttachedCollisionObject"; };
const char * getMD5(){ return "3ceac60b21e85bbd6c5b0ab9d476b752"; };
};
}
#endif
| 5,525 | C | 39.335766 | 100 | 0.5819 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AllowedCollisionMatrix.h | #ifndef _ROS_moveit_msgs_AllowedCollisionMatrix_h
#define _ROS_moveit_msgs_AllowedCollisionMatrix_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/AllowedCollisionEntry.h"
namespace moveit_msgs
{
class AllowedCollisionMatrix : public ros::Msg
{
public:
uint32_t entry_names_length;
typedef char* _entry_names_type;
_entry_names_type st_entry_names;
_entry_names_type * entry_names;
uint32_t entry_values_length;
typedef moveit_msgs::AllowedCollisionEntry _entry_values_type;
_entry_values_type st_entry_values;
_entry_values_type * entry_values;
uint32_t default_entry_names_length;
typedef char* _default_entry_names_type;
_default_entry_names_type st_default_entry_names;
_default_entry_names_type * default_entry_names;
uint32_t default_entry_values_length;
typedef bool _default_entry_values_type;
_default_entry_values_type st_default_entry_values;
_default_entry_values_type * default_entry_values;
AllowedCollisionMatrix():
entry_names_length(0), entry_names(NULL),
entry_values_length(0), entry_values(NULL),
default_entry_names_length(0), default_entry_names(NULL),
default_entry_values_length(0), default_entry_values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->entry_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->entry_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->entry_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->entry_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->entry_names_length);
for( uint32_t i = 0; i < entry_names_length; i++){
uint32_t length_entry_namesi = strlen(this->entry_names[i]);
varToArr(outbuffer + offset, length_entry_namesi);
offset += 4;
memcpy(outbuffer + offset, this->entry_names[i], length_entry_namesi);
offset += length_entry_namesi;
}
*(outbuffer + offset + 0) = (this->entry_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->entry_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->entry_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->entry_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->entry_values_length);
for( uint32_t i = 0; i < entry_values_length; i++){
offset += this->entry_values[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->default_entry_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->default_entry_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->default_entry_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->default_entry_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->default_entry_names_length);
for( uint32_t i = 0; i < default_entry_names_length; i++){
uint32_t length_default_entry_namesi = strlen(this->default_entry_names[i]);
varToArr(outbuffer + offset, length_default_entry_namesi);
offset += 4;
memcpy(outbuffer + offset, this->default_entry_names[i], length_default_entry_namesi);
offset += length_default_entry_namesi;
}
*(outbuffer + offset + 0) = (this->default_entry_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->default_entry_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->default_entry_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->default_entry_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->default_entry_values_length);
for( uint32_t i = 0; i < default_entry_values_length; i++){
union {
bool real;
uint8_t base;
} u_default_entry_valuesi;
u_default_entry_valuesi.real = this->default_entry_values[i];
*(outbuffer + offset + 0) = (u_default_entry_valuesi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->default_entry_values[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t entry_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->entry_names_length);
if(entry_names_lengthT > entry_names_length)
this->entry_names = (char**)realloc(this->entry_names, entry_names_lengthT * sizeof(char*));
entry_names_length = entry_names_lengthT;
for( uint32_t i = 0; i < entry_names_length; i++){
uint32_t length_st_entry_names;
arrToVar(length_st_entry_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_entry_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_entry_names-1]=0;
this->st_entry_names = (char *)(inbuffer + offset-1);
offset += length_st_entry_names;
memcpy( &(this->entry_names[i]), &(this->st_entry_names), sizeof(char*));
}
uint32_t entry_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->entry_values_length);
if(entry_values_lengthT > entry_values_length)
this->entry_values = (moveit_msgs::AllowedCollisionEntry*)realloc(this->entry_values, entry_values_lengthT * sizeof(moveit_msgs::AllowedCollisionEntry));
entry_values_length = entry_values_lengthT;
for( uint32_t i = 0; i < entry_values_length; i++){
offset += this->st_entry_values.deserialize(inbuffer + offset);
memcpy( &(this->entry_values[i]), &(this->st_entry_values), sizeof(moveit_msgs::AllowedCollisionEntry));
}
uint32_t default_entry_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->default_entry_names_length);
if(default_entry_names_lengthT > default_entry_names_length)
this->default_entry_names = (char**)realloc(this->default_entry_names, default_entry_names_lengthT * sizeof(char*));
default_entry_names_length = default_entry_names_lengthT;
for( uint32_t i = 0; i < default_entry_names_length; i++){
uint32_t length_st_default_entry_names;
arrToVar(length_st_default_entry_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_default_entry_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_default_entry_names-1]=0;
this->st_default_entry_names = (char *)(inbuffer + offset-1);
offset += length_st_default_entry_names;
memcpy( &(this->default_entry_names[i]), &(this->st_default_entry_names), sizeof(char*));
}
uint32_t default_entry_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->default_entry_values_length);
if(default_entry_values_lengthT > default_entry_values_length)
this->default_entry_values = (bool*)realloc(this->default_entry_values, default_entry_values_lengthT * sizeof(bool));
default_entry_values_length = default_entry_values_lengthT;
for( uint32_t i = 0; i < default_entry_values_length; i++){
union {
bool real;
uint8_t base;
} u_st_default_entry_values;
u_st_default_entry_values.base = 0;
u_st_default_entry_values.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_default_entry_values = u_st_default_entry_values.real;
offset += sizeof(this->st_default_entry_values);
memcpy( &(this->default_entry_values[i]), &(this->st_default_entry_values), sizeof(bool));
}
return offset;
}
const char * getType(){ return "moveit_msgs/AllowedCollisionMatrix"; };
const char * getMD5(){ return "aedce13587eef0d79165a075659c1879"; };
};
}
#endif
| 8,960 | C | 49.627118 | 161 | 0.614844 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DisplayTrajectory.h | #ifndef _ROS_moveit_msgs_DisplayTrajectory_h
#define _ROS_moveit_msgs_DisplayTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
class DisplayTrajectory : public ros::Msg
{
public:
typedef const char* _model_id_type;
_model_id_type model_id;
uint32_t trajectory_length;
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type st_trajectory;
_trajectory_type * trajectory;
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
DisplayTrajectory():
model_id(""),
trajectory_length(0), trajectory(NULL),
trajectory_start()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_id = strlen(this->model_id);
varToArr(outbuffer + offset, length_model_id);
offset += 4;
memcpy(outbuffer + offset, this->model_id, length_model_id);
offset += length_model_id;
*(outbuffer + offset + 0) = (this->trajectory_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_length);
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->trajectory[i].serialize(outbuffer + offset);
}
offset += this->trajectory_start.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_id;
arrToVar(length_model_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_id-1]=0;
this->model_id = (char *)(inbuffer + offset-1);
offset += length_model_id;
uint32_t trajectory_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_length);
if(trajectory_lengthT > trajectory_length)
this->trajectory = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory, trajectory_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_length = trajectory_lengthT;
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->st_trajectory.deserialize(inbuffer + offset);
memcpy( &(this->trajectory[i]), &(this->st_trajectory), sizeof(moveit_msgs::RobotTrajectory));
}
offset += this->trajectory_start.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/DisplayTrajectory"; };
const char * getMD5(){ return "c3c039261ab9e8a11457dac56b6316c8"; };
};
}
#endif
| 3,253 | C | 35.977272 | 143 | 0.627421 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LinkScale.h | #ifndef _ROS_moveit_msgs_LinkScale_h
#define _ROS_moveit_msgs_LinkScale_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class LinkScale : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef double _scale_type;
_scale_type scale;
LinkScale():
link_name(""),
scale(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_scale;
u_scale.real = this->scale;
*(outbuffer + offset + 0) = (u_scale.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_scale.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_scale.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_scale.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_scale.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_scale.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_scale.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_scale.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->scale);
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_scale;
u_scale.base = 0;
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->scale = u_scale.real;
offset += sizeof(this->scale);
return offset;
}
const char * getType(){ return "moveit_msgs/LinkScale"; };
const char * getMD5(){ return "19faf226446bfb2f645a4da6f2a56166"; };
};
}
#endif
| 2,851 | C | 31.409091 | 73 | 0.540512 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPositionIK.h | #ifndef _ROS_SERVICE_GetPositionIK_h
#define _ROS_SERVICE_GetPositionIK_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/PositionIKRequest.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
static const char GETPOSITIONIK[] = "moveit_msgs/GetPositionIK";
class GetPositionIKRequest : public ros::Msg
{
public:
typedef moveit_msgs::PositionIKRequest _ik_request_type;
_ik_request_type ik_request;
GetPositionIKRequest():
ik_request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->ik_request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->ik_request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONIK; };
const char * getMD5(){ return "a67dc7e99d15c1dca32a77c22bc2d93b"; };
};
class GetPositionIKResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _solution_type;
_solution_type solution;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GetPositionIKResponse():
solution(),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->solution.serialize(outbuffer + offset);
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->solution.deserialize(inbuffer + offset);
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONIK; };
const char * getMD5(){ return "ad50fe5fa0ddb482909be313121ea148"; };
};
class GetPositionIK {
public:
typedef GetPositionIKRequest Request;
typedef GetPositionIKResponse Response;
};
}
#endif
| 2,146 | C | 23.123595 | 72 | 0.664958 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LoadMap.h | #ifndef _ROS_SERVICE_LoadMap_h
#define _ROS_SERVICE_LoadMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char LOADMAP[] = "moveit_msgs/LoadMap";
class LoadMapRequest : public ros::Msg
{
public:
typedef const char* _filename_type;
_filename_type filename;
LoadMapRequest():
filename("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_filename = strlen(this->filename);
varToArr(outbuffer + offset, length_filename);
offset += 4;
memcpy(outbuffer + offset, this->filename, length_filename);
offset += length_filename;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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;
return offset;
}
const char * getType(){ return LOADMAP; };
const char * getMD5(){ return "030824f52a0628ead956fb9d67e66ae9"; };
};
class LoadMapResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
LoadMapResponse():
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 LOADMAP; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class LoadMap {
public:
typedef LoadMapRequest Request;
typedef LoadMapResponse Response;
};
}
#endif
| 2,450 | C | 22.122641 | 74 | 0.599184 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceGoal_h
#define _ROS_moveit_msgs_MoveGroupSequenceGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionSequenceRequest.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class MoveGroupSequenceGoal : public ros::Msg
{
public:
typedef moveit_msgs::MotionSequenceRequest _request_type;
_request_type request;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
MoveGroupSequenceGoal():
request(),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceGoal"; };
const char * getMD5(){ return "12fc6281edcaf031de4783a58087ebf1"; };
};
}
#endif
| 1,300 | C | 24.509803 | 74 | 0.685385 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetCartesianPath.h | #ifndef _ROS_SERVICE_GetCartesianPath_h
#define _ROS_SERVICE_GetCartesianPath_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "geometry_msgs/Pose.h"
#include "moveit_msgs/Constraints.h"
namespace moveit_msgs
{
static const char GETCARTESIANPATH[] = "moveit_msgs/GetCartesianPath";
class GetCartesianPathRequest : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef moveit_msgs::RobotState _start_state_type;
_start_state_type start_state;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef const char* _link_name_type;
_link_name_type link_name;
uint32_t waypoints_length;
typedef geometry_msgs::Pose _waypoints_type;
_waypoints_type st_waypoints;
_waypoints_type * waypoints;
typedef double _max_step_type;
_max_step_type max_step;
typedef double _jump_threshold_type;
_jump_threshold_type jump_threshold;
typedef bool _avoid_collisions_type;
_avoid_collisions_type avoid_collisions;
typedef moveit_msgs::Constraints _path_constraints_type;
_path_constraints_type path_constraints;
GetCartesianPathRequest():
header(),
start_state(),
group_name(""),
link_name(""),
waypoints_length(0), waypoints(NULL),
max_step(0),
jump_threshold(0),
avoid_collisions(0),
path_constraints()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->start_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;
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;
*(outbuffer + offset + 0) = (this->waypoints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->waypoints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->waypoints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->waypoints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->waypoints_length);
for( uint32_t i = 0; i < waypoints_length; i++){
offset += this->waypoints[i].serialize(outbuffer + offset);
}
union {
double real;
uint64_t base;
} u_max_step;
u_max_step.real = this->max_step;
*(outbuffer + offset + 0) = (u_max_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_step);
union {
double real;
uint64_t base;
} u_jump_threshold;
u_jump_threshold.real = this->jump_threshold;
*(outbuffer + offset + 0) = (u_jump_threshold.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_jump_threshold.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_jump_threshold.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_jump_threshold.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_jump_threshold.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_jump_threshold.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_jump_threshold.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_jump_threshold.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->jump_threshold);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.real = this->avoid_collisions;
*(outbuffer + offset + 0) = (u_avoid_collisions.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->avoid_collisions);
offset += this->path_constraints.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->start_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;
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;
uint32_t waypoints_lengthT = ((uint32_t) (*(inbuffer + offset)));
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->waypoints_length);
if(waypoints_lengthT > waypoints_length)
this->waypoints = (geometry_msgs::Pose*)realloc(this->waypoints, waypoints_lengthT * sizeof(geometry_msgs::Pose));
waypoints_length = waypoints_lengthT;
for( uint32_t i = 0; i < waypoints_length; i++){
offset += this->st_waypoints.deserialize(inbuffer + offset);
memcpy( &(this->waypoints[i]), &(this->st_waypoints), sizeof(geometry_msgs::Pose));
}
union {
double real;
uint64_t base;
} u_max_step;
u_max_step.base = 0;
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_step = u_max_step.real;
offset += sizeof(this->max_step);
union {
double real;
uint64_t base;
} u_jump_threshold;
u_jump_threshold.base = 0;
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->jump_threshold = u_jump_threshold.real;
offset += sizeof(this->jump_threshold);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.base = 0;
u_avoid_collisions.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->avoid_collisions = u_avoid_collisions.real;
offset += sizeof(this->avoid_collisions);
offset += this->path_constraints.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETCARTESIANPATH; };
const char * getMD5(){ return "b37c16ad7ed838d811a270a8054276b6"; };
};
class GetCartesianPathResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _start_state_type;
_start_state_type start_state;
typedef moveit_msgs::RobotTrajectory _solution_type;
_solution_type solution;
typedef double _fraction_type;
_fraction_type fraction;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GetCartesianPathResponse():
start_state(),
solution(),
fraction(0),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->start_state.serialize(outbuffer + offset);
offset += this->solution.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_fraction;
u_fraction.real = this->fraction;
*(outbuffer + offset + 0) = (u_fraction.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fraction.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fraction.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fraction.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_fraction.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_fraction.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_fraction.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_fraction.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->fraction);
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->start_state.deserialize(inbuffer + offset);
offset += this->solution.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_fraction;
u_fraction.base = 0;
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->fraction = u_fraction.real;
offset += sizeof(this->fraction);
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETCARTESIANPATH; };
const char * getMD5(){ return "45414110461a45eb0e273e013924ce59"; };
};
class GetCartesianPath {
public:
typedef GetCartesianPathRequest Request;
typedef GetCartesianPathResponse Response;
};
}
#endif
| 11,595 | C | 40.414286 | 122 | 0.578784 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ListRobotStatesInWarehouse.h | #ifndef _ROS_SERVICE_ListRobotStatesInWarehouse_h
#define _ROS_SERVICE_ListRobotStatesInWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char LISTROBOTSTATESINWAREHOUSE[] = "moveit_msgs/ListRobotStatesInWarehouse";
class ListRobotStatesInWarehouseRequest : public ros::Msg
{
public:
typedef const char* _regex_type;
_regex_type regex;
typedef const char* _robot_type;
_robot_type robot;
ListRobotStatesInWarehouseRequest():
regex(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_regex = strlen(this->regex);
varToArr(outbuffer + offset, length_regex);
offset += 4;
memcpy(outbuffer + offset, this->regex, length_regex);
offset += length_regex;
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_regex;
arrToVar(length_regex, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_regex; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_regex-1]=0;
this->regex = (char *)(inbuffer + offset-1);
offset += length_regex;
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 LISTROBOTSTATESINWAREHOUSE; };
const char * getMD5(){ return "6f0970a3ca837e2fc3ed63e314b44b42"; };
};
class ListRobotStatesInWarehouseResponse : public ros::Msg
{
public:
uint32_t states_length;
typedef char* _states_type;
_states_type st_states;
_states_type * states;
ListRobotStatesInWarehouseResponse():
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(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++){
uint32_t length_statesi = strlen(this->states[i]);
varToArr(outbuffer + offset, length_statesi);
offset += 4;
memcpy(outbuffer + offset, this->states[i], length_statesi);
offset += length_statesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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 = (char**)realloc(this->states, states_lengthT * sizeof(char*));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
uint32_t length_st_states;
arrToVar(length_st_states, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_states; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_states-1]=0;
this->st_states = (char *)(inbuffer + offset-1);
offset += length_st_states;
memcpy( &(this->states[i]), &(this->st_states), sizeof(char*));
}
return offset;
}
const char * getType(){ return LISTROBOTSTATESINWAREHOUSE; };
const char * getMD5(){ return "a8656b247c0429bb79afe0ddb88eb2f5"; };
};
class ListRobotStatesInWarehouse {
public:
typedef ListRobotStatesInWarehouseRequest Request;
typedef ListRobotStatesInWarehouseResponse Response;
};
}
#endif
| 4,507 | C | 30.746479 | 90 | 0.610828 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DisplayRobotState.h | #ifndef _ROS_moveit_msgs_DisplayRobotState_h
#define _ROS_moveit_msgs_DisplayRobotState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/ObjectColor.h"
namespace moveit_msgs
{
class DisplayRobotState : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _state_type;
_state_type state;
uint32_t highlight_links_length;
typedef moveit_msgs::ObjectColor _highlight_links_type;
_highlight_links_type st_highlight_links;
_highlight_links_type * highlight_links;
DisplayRobotState():
state(),
highlight_links_length(0), highlight_links(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->state.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->highlight_links_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->highlight_links_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->highlight_links_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->highlight_links_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->highlight_links_length);
for( uint32_t i = 0; i < highlight_links_length; i++){
offset += this->highlight_links[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->state.deserialize(inbuffer + offset);
uint32_t highlight_links_lengthT = ((uint32_t) (*(inbuffer + offset)));
highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->highlight_links_length);
if(highlight_links_lengthT > highlight_links_length)
this->highlight_links = (moveit_msgs::ObjectColor*)realloc(this->highlight_links, highlight_links_lengthT * sizeof(moveit_msgs::ObjectColor));
highlight_links_length = highlight_links_lengthT;
for( uint32_t i = 0; i < highlight_links_length; i++){
offset += this->st_highlight_links.deserialize(inbuffer + offset);
memcpy( &(this->highlight_links[i]), &(this->st_highlight_links), sizeof(moveit_msgs::ObjectColor));
}
return offset;
}
const char * getType(){ return "moveit_msgs/DisplayRobotState"; };
const char * getMD5(){ return "6a3bab3a33a8c47aee24481a455a21aa"; };
};
}
#endif
| 2,652 | C | 36.366197 | 150 | 0.636501 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceItem.h | #ifndef _ROS_moveit_msgs_MotionSequenceItem_h
#define _ROS_moveit_msgs_MotionSequenceItem_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionPlanRequest.h"
namespace moveit_msgs
{
class MotionSequenceItem : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanRequest _req_type;
_req_type req;
typedef double _blend_radius_type;
_blend_radius_type blend_radius;
MotionSequenceItem():
req(),
blend_radius(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->req.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_blend_radius;
u_blend_radius.real = this->blend_radius;
*(outbuffer + offset + 0) = (u_blend_radius.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_blend_radius.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_blend_radius.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_blend_radius.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_blend_radius.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_blend_radius.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_blend_radius.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_blend_radius.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->blend_radius);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->req.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_blend_radius;
u_blend_radius.base = 0;
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->blend_radius = u_blend_radius.real;
offset += sizeof(this->blend_radius);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionSequenceItem"; };
const char * getMD5(){ return "932aef4280f479e42c693b8b285624bf"; };
};
}
#endif
| 2,661 | C | 33.571428 | 80 | 0.567832 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CollisionObject.h | #ifndef _ROS_moveit_msgs_CollisionObject_h
#define _ROS_moveit_msgs_CollisionObject_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "object_recognition_msgs/ObjectType.h"
#include "shape_msgs/SolidPrimitive.h"
#include "geometry_msgs/Pose.h"
#include "shape_msgs/Mesh.h"
#include "shape_msgs/Plane.h"
namespace moveit_msgs
{
class CollisionObject : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _id_type;
_id_type id;
typedef object_recognition_msgs::ObjectType _type_type;
_type_type type;
uint32_t primitives_length;
typedef shape_msgs::SolidPrimitive _primitives_type;
_primitives_type st_primitives;
_primitives_type * primitives;
uint32_t primitive_poses_length;
typedef geometry_msgs::Pose _primitive_poses_type;
_primitive_poses_type st_primitive_poses;
_primitive_poses_type * primitive_poses;
uint32_t meshes_length;
typedef shape_msgs::Mesh _meshes_type;
_meshes_type st_meshes;
_meshes_type * meshes;
uint32_t mesh_poses_length;
typedef geometry_msgs::Pose _mesh_poses_type;
_mesh_poses_type st_mesh_poses;
_mesh_poses_type * mesh_poses;
uint32_t planes_length;
typedef shape_msgs::Plane _planes_type;
_planes_type st_planes;
_planes_type * planes;
uint32_t plane_poses_length;
typedef geometry_msgs::Pose _plane_poses_type;
_plane_poses_type st_plane_poses;
_plane_poses_type * plane_poses;
typedef int8_t _operation_type;
_operation_type operation;
enum { ADD = 0 };
enum { REMOVE = 1 };
enum { APPEND = 2 };
enum { MOVE = 3 };
CollisionObject():
header(),
id(""),
type(),
primitives_length(0), primitives(NULL),
primitive_poses_length(0), primitive_poses(NULL),
meshes_length(0), meshes(NULL),
mesh_poses_length(0), mesh_poses(NULL),
planes_length(0), planes(NULL),
plane_poses_length(0), plane_poses(NULL),
operation(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;
offset += this->type.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->primitives_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitives_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitives_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitives_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitives_length);
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->primitives[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->primitive_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitive_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitive_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitive_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitive_poses_length);
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->primitive_poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->meshes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->meshes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->meshes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->meshes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->meshes_length);
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->meshes[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->mesh_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->mesh_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->mesh_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->mesh_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->mesh_poses_length);
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->mesh_poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->planes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planes_length);
for( uint32_t i = 0; i < planes_length; i++){
offset += this->planes[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->plane_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->plane_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->plane_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->plane_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->plane_poses_length);
for( uint32_t i = 0; i < plane_poses_length; i++){
offset += this->plane_poses[i].serialize(outbuffer + offset);
}
union {
int8_t real;
uint8_t base;
} u_operation;
u_operation.real = this->operation;
*(outbuffer + offset + 0) = (u_operation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->operation);
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;
offset += this->type.deserialize(inbuffer + offset);
uint32_t primitives_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitives_length);
if(primitives_lengthT > primitives_length)
this->primitives = (shape_msgs::SolidPrimitive*)realloc(this->primitives, primitives_lengthT * sizeof(shape_msgs::SolidPrimitive));
primitives_length = primitives_lengthT;
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->st_primitives.deserialize(inbuffer + offset);
memcpy( &(this->primitives[i]), &(this->st_primitives), sizeof(shape_msgs::SolidPrimitive));
}
uint32_t primitive_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitive_poses_length);
if(primitive_poses_lengthT > primitive_poses_length)
this->primitive_poses = (geometry_msgs::Pose*)realloc(this->primitive_poses, primitive_poses_lengthT * sizeof(geometry_msgs::Pose));
primitive_poses_length = primitive_poses_lengthT;
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->st_primitive_poses.deserialize(inbuffer + offset);
memcpy( &(this->primitive_poses[i]), &(this->st_primitive_poses), sizeof(geometry_msgs::Pose));
}
uint32_t meshes_lengthT = ((uint32_t) (*(inbuffer + offset)));
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->meshes_length);
if(meshes_lengthT > meshes_length)
this->meshes = (shape_msgs::Mesh*)realloc(this->meshes, meshes_lengthT * sizeof(shape_msgs::Mesh));
meshes_length = meshes_lengthT;
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->st_meshes.deserialize(inbuffer + offset);
memcpy( &(this->meshes[i]), &(this->st_meshes), sizeof(shape_msgs::Mesh));
}
uint32_t mesh_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->mesh_poses_length);
if(mesh_poses_lengthT > mesh_poses_length)
this->mesh_poses = (geometry_msgs::Pose*)realloc(this->mesh_poses, mesh_poses_lengthT * sizeof(geometry_msgs::Pose));
mesh_poses_length = mesh_poses_lengthT;
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->st_mesh_poses.deserialize(inbuffer + offset);
memcpy( &(this->mesh_poses[i]), &(this->st_mesh_poses), sizeof(geometry_msgs::Pose));
}
uint32_t planes_lengthT = ((uint32_t) (*(inbuffer + offset)));
planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planes_length);
if(planes_lengthT > planes_length)
this->planes = (shape_msgs::Plane*)realloc(this->planes, planes_lengthT * sizeof(shape_msgs::Plane));
planes_length = planes_lengthT;
for( uint32_t i = 0; i < planes_length; i++){
offset += this->st_planes.deserialize(inbuffer + offset);
memcpy( &(this->planes[i]), &(this->st_planes), sizeof(shape_msgs::Plane));
}
uint32_t plane_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->plane_poses_length);
if(plane_poses_lengthT > plane_poses_length)
this->plane_poses = (geometry_msgs::Pose*)realloc(this->plane_poses, plane_poses_lengthT * sizeof(geometry_msgs::Pose));
plane_poses_length = plane_poses_lengthT;
for( uint32_t i = 0; i < plane_poses_length; i++){
offset += this->st_plane_poses.deserialize(inbuffer + offset);
memcpy( &(this->plane_poses[i]), &(this->st_plane_poses), sizeof(geometry_msgs::Pose));
}
union {
int8_t real;
uint8_t base;
} u_operation;
u_operation.base = 0;
u_operation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->operation = u_operation.real;
offset += sizeof(this->operation);
return offset;
}
const char * getType(){ return "moveit_msgs/CollisionObject"; };
const char * getMD5(){ return "568a161b26dc46c54a5a07621ce82cf3"; };
};
}
#endif
| 11,609 | C | 46.581967 | 140 | 0.589973 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPlannerParams.h | #ifndef _ROS_SERVICE_GetPlannerParams_h
#define _ROS_SERVICE_GetPlannerParams_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 GETPLANNERPARAMS[] = "moveit_msgs/GetPlannerParams";
class GetPlannerParamsRequest : public ros::Msg
{
public:
typedef const char* _planner_config_type;
_planner_config_type planner_config;
typedef const char* _group_type;
_group_type group;
GetPlannerParamsRequest():
planner_config(""),
group("")
{
}
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;
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;
return offset;
}
const char * getType(){ return GETPLANNERPARAMS; };
const char * getMD5(){ return "f548a13784550d510d791867af53ef40"; };
};
class GetPlannerParamsResponse : public ros::Msg
{
public:
typedef moveit_msgs::PlannerParams _params_type;
_params_type params;
GetPlannerParamsResponse():
params()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->params.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->params.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPLANNERPARAMS; };
const char * getMD5(){ return "462b1bd59976ece800f6a48f2b0bf1a2"; };
};
class GetPlannerParams {
public:
typedef GetPlannerParamsRequest Request;
typedef GetPlannerParamsResponse Response;
};
}
#endif
| 2,989 | C | 25.936937 | 78 | 0.642355 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningScene.h | #ifndef _ROS_moveit_msgs_PlanningScene_h
#define _ROS_moveit_msgs_PlanningScene_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "geometry_msgs/TransformStamped.h"
#include "moveit_msgs/AllowedCollisionMatrix.h"
#include "moveit_msgs/LinkPadding.h"
#include "moveit_msgs/LinkScale.h"
#include "moveit_msgs/ObjectColor.h"
#include "moveit_msgs/PlanningSceneWorld.h"
namespace moveit_msgs
{
class PlanningScene : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
typedef const char* _robot_model_name_type;
_robot_model_name_type robot_model_name;
uint32_t fixed_frame_transforms_length;
typedef geometry_msgs::TransformStamped _fixed_frame_transforms_type;
_fixed_frame_transforms_type st_fixed_frame_transforms;
_fixed_frame_transforms_type * fixed_frame_transforms;
typedef moveit_msgs::AllowedCollisionMatrix _allowed_collision_matrix_type;
_allowed_collision_matrix_type allowed_collision_matrix;
uint32_t link_padding_length;
typedef moveit_msgs::LinkPadding _link_padding_type;
_link_padding_type st_link_padding;
_link_padding_type * link_padding;
uint32_t link_scale_length;
typedef moveit_msgs::LinkScale _link_scale_type;
_link_scale_type st_link_scale;
_link_scale_type * link_scale;
uint32_t object_colors_length;
typedef moveit_msgs::ObjectColor _object_colors_type;
_object_colors_type st_object_colors;
_object_colors_type * object_colors;
typedef moveit_msgs::PlanningSceneWorld _world_type;
_world_type world;
typedef bool _is_diff_type;
_is_diff_type is_diff;
PlanningScene():
name(""),
robot_state(),
robot_model_name(""),
fixed_frame_transforms_length(0), fixed_frame_transforms(NULL),
allowed_collision_matrix(),
link_padding_length(0), link_padding(NULL),
link_scale_length(0), link_scale(NULL),
object_colors_length(0), object_colors(NULL),
world(),
is_diff(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;
offset += this->robot_state.serialize(outbuffer + offset);
uint32_t length_robot_model_name = strlen(this->robot_model_name);
varToArr(outbuffer + offset, length_robot_model_name);
offset += 4;
memcpy(outbuffer + offset, this->robot_model_name, length_robot_model_name);
offset += length_robot_model_name;
*(outbuffer + offset + 0) = (this->fixed_frame_transforms_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fixed_frame_transforms_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fixed_frame_transforms_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fixed_frame_transforms_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fixed_frame_transforms_length);
for( uint32_t i = 0; i < fixed_frame_transforms_length; i++){
offset += this->fixed_frame_transforms[i].serialize(outbuffer + offset);
}
offset += this->allowed_collision_matrix.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->link_padding_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->link_padding_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->link_padding_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->link_padding_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->link_padding_length);
for( uint32_t i = 0; i < link_padding_length; i++){
offset += this->link_padding[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->link_scale_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->link_scale_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->link_scale_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->link_scale_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->link_scale_length);
for( uint32_t i = 0; i < link_scale_length; i++){
offset += this->link_scale[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->object_colors_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->object_colors_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->object_colors_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->object_colors_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->object_colors_length);
for( uint32_t i = 0; i < object_colors_length; i++){
offset += this->object_colors[i].serialize(outbuffer + offset);
}
offset += this->world.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;
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->robot_state.deserialize(inbuffer + offset);
uint32_t length_robot_model_name;
arrToVar(length_robot_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot_model_name-1]=0;
this->robot_model_name = (char *)(inbuffer + offset-1);
offset += length_robot_model_name;
uint32_t fixed_frame_transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fixed_frame_transforms_length);
if(fixed_frame_transforms_lengthT > fixed_frame_transforms_length)
this->fixed_frame_transforms = (geometry_msgs::TransformStamped*)realloc(this->fixed_frame_transforms, fixed_frame_transforms_lengthT * sizeof(geometry_msgs::TransformStamped));
fixed_frame_transforms_length = fixed_frame_transforms_lengthT;
for( uint32_t i = 0; i < fixed_frame_transforms_length; i++){
offset += this->st_fixed_frame_transforms.deserialize(inbuffer + offset);
memcpy( &(this->fixed_frame_transforms[i]), &(this->st_fixed_frame_transforms), sizeof(geometry_msgs::TransformStamped));
}
offset += this->allowed_collision_matrix.deserialize(inbuffer + offset);
uint32_t link_padding_lengthT = ((uint32_t) (*(inbuffer + offset)));
link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->link_padding_length);
if(link_padding_lengthT > link_padding_length)
this->link_padding = (moveit_msgs::LinkPadding*)realloc(this->link_padding, link_padding_lengthT * sizeof(moveit_msgs::LinkPadding));
link_padding_length = link_padding_lengthT;
for( uint32_t i = 0; i < link_padding_length; i++){
offset += this->st_link_padding.deserialize(inbuffer + offset);
memcpy( &(this->link_padding[i]), &(this->st_link_padding), sizeof(moveit_msgs::LinkPadding));
}
uint32_t link_scale_lengthT = ((uint32_t) (*(inbuffer + offset)));
link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->link_scale_length);
if(link_scale_lengthT > link_scale_length)
this->link_scale = (moveit_msgs::LinkScale*)realloc(this->link_scale, link_scale_lengthT * sizeof(moveit_msgs::LinkScale));
link_scale_length = link_scale_lengthT;
for( uint32_t i = 0; i < link_scale_length; i++){
offset += this->st_link_scale.deserialize(inbuffer + offset);
memcpy( &(this->link_scale[i]), &(this->st_link_scale), sizeof(moveit_msgs::LinkScale));
}
uint32_t object_colors_lengthT = ((uint32_t) (*(inbuffer + offset)));
object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->object_colors_length);
if(object_colors_lengthT > object_colors_length)
this->object_colors = (moveit_msgs::ObjectColor*)realloc(this->object_colors, object_colors_lengthT * sizeof(moveit_msgs::ObjectColor));
object_colors_length = object_colors_lengthT;
for( uint32_t i = 0; i < object_colors_length; i++){
offset += this->st_object_colors.deserialize(inbuffer + offset);
memcpy( &(this->object_colors[i]), &(this->st_object_colors), sizeof(moveit_msgs::ObjectColor));
}
offset += this->world.deserialize(inbuffer + offset);
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/PlanningScene"; };
const char * getMD5(){ return "89aac6d20db967ba716cba5a86b1b9d5"; };
};
}
#endif
| 10,388 | C | 47.774648 | 185 | 0.620042 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupGoal_h
#define _ROS_moveit_msgs_MoveGroupGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionPlanRequest.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class MoveGroupGoal : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanRequest _request_type;
_request_type request;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
MoveGroupGoal():
request(),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupGoal"; };
const char * getMD5(){ return "a6de2db49c561a49babce1a8172e8906"; };
};
}
#endif
| 1,252 | C | 23.568627 | 72 | 0.673323 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/RenameRobotStateInWarehouse.h | #ifndef _ROS_SERVICE_RenameRobotStateInWarehouse_h
#define _ROS_SERVICE_RenameRobotStateInWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char RENAMEROBOTSTATEINWAREHOUSE[] = "moveit_msgs/RenameRobotStateInWarehouse";
class RenameRobotStateInWarehouseRequest : public ros::Msg
{
public:
typedef const char* _old_name_type;
_old_name_type old_name;
typedef const char* _new_name_type;
_new_name_type new_name;
typedef const char* _robot_type;
_robot_type robot;
RenameRobotStateInWarehouseRequest():
old_name(""),
new_name(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_old_name = strlen(this->old_name);
varToArr(outbuffer + offset, length_old_name);
offset += 4;
memcpy(outbuffer + offset, this->old_name, length_old_name);
offset += length_old_name;
uint32_t length_new_name = strlen(this->new_name);
varToArr(outbuffer + offset, length_new_name);
offset += 4;
memcpy(outbuffer + offset, this->new_name, length_new_name);
offset += length_new_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_old_name;
arrToVar(length_old_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_old_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_old_name-1]=0;
this->old_name = (char *)(inbuffer + offset-1);
offset += length_old_name;
uint32_t length_new_name;
arrToVar(length_new_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_new_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_new_name-1]=0;
this->new_name = (char *)(inbuffer + offset-1);
offset += length_new_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 RENAMEROBOTSTATEINWAREHOUSE; };
const char * getMD5(){ return "073dc05c3fd313b947cea483c25c46b0"; };
};
class RenameRobotStateInWarehouseResponse : public ros::Msg
{
public:
RenameRobotStateInWarehouseResponse()
{
}
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 RENAMEROBOTSTATEINWAREHOUSE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class RenameRobotStateInWarehouse {
public:
typedef RenameRobotStateInWarehouseRequest Request;
typedef RenameRobotStateInWarehouseResponse Response;
};
}
#endif
| 3,448 | C | 27.270492 | 92 | 0.635151 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/KinematicSolverInfo.h | #ifndef _ROS_moveit_msgs_KinematicSolverInfo_h
#define _ROS_moveit_msgs_KinematicSolverInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/JointLimits.h"
namespace moveit_msgs
{
class KinematicSolverInfo : public ros::Msg
{
public:
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t limits_length;
typedef moveit_msgs::JointLimits _limits_type;
_limits_type st_limits;
_limits_type * limits;
uint32_t link_names_length;
typedef char* _link_names_type;
_link_names_type st_link_names;
_link_names_type * link_names;
KinematicSolverInfo():
joint_names_length(0), joint_names(NULL),
limits_length(0), limits(NULL),
link_names_length(0), link_names(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->limits_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->limits_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->limits_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->limits_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->limits_length);
for( uint32_t i = 0; i < limits_length; i++){
offset += this->limits[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->link_names_length);
for( uint32_t i = 0; i < link_names_length; i++){
uint32_t length_link_namesi = strlen(this->link_names[i]);
varToArr(outbuffer + offset, length_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->link_names[i], length_link_namesi);
offset += length_link_namesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t limits_lengthT = ((uint32_t) (*(inbuffer + offset)));
limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->limits_length);
if(limits_lengthT > limits_length)
this->limits = (moveit_msgs::JointLimits*)realloc(this->limits, limits_lengthT * sizeof(moveit_msgs::JointLimits));
limits_length = limits_lengthT;
for( uint32_t i = 0; i < limits_length; i++){
offset += this->st_limits.deserialize(inbuffer + offset);
memcpy( &(this->limits[i]), &(this->st_limits), sizeof(moveit_msgs::JointLimits));
}
uint32_t link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->link_names_length);
if(link_names_lengthT > link_names_length)
this->link_names = (char**)realloc(this->link_names, link_names_lengthT * sizeof(char*));
link_names_length = link_names_lengthT;
for( uint32_t i = 0; i < link_names_length; i++){
uint32_t length_st_link_names;
arrToVar(length_st_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_link_names-1]=0;
this->st_link_names = (char *)(inbuffer + offset-1);
offset += length_st_link_names;
memcpy( &(this->link_names[i]), &(this->st_link_names), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/KinematicSolverInfo"; };
const char * getMD5(){ return "cc048557c0f9795c392dd80f8bb00489"; };
};
}
#endif
| 6,086 | C | 42.791367 | 123 | 0.589057 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PositionIKRequest.h | #ifndef _ROS_moveit_msgs_PositionIKRequest_h
#define _ROS_moveit_msgs_PositionIKRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/Constraints.h"
#include "geometry_msgs/PoseStamped.h"
#include "ros/duration.h"
namespace moveit_msgs
{
class PositionIKRequest : public ros::Msg
{
public:
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
typedef moveit_msgs::Constraints _constraints_type;
_constraints_type constraints;
typedef bool _avoid_collisions_type;
_avoid_collisions_type avoid_collisions;
typedef const char* _ik_link_name_type;
_ik_link_name_type ik_link_name;
typedef geometry_msgs::PoseStamped _pose_stamped_type;
_pose_stamped_type pose_stamped;
uint32_t ik_link_names_length;
typedef char* _ik_link_names_type;
_ik_link_names_type st_ik_link_names;
_ik_link_names_type * ik_link_names;
uint32_t pose_stamped_vector_length;
typedef geometry_msgs::PoseStamped _pose_stamped_vector_type;
_pose_stamped_vector_type st_pose_stamped_vector;
_pose_stamped_vector_type * pose_stamped_vector;
typedef ros::Duration _timeout_type;
_timeout_type timeout;
typedef int32_t _attempts_type;
_attempts_type attempts;
PositionIKRequest():
group_name(""),
robot_state(),
constraints(),
avoid_collisions(0),
ik_link_name(""),
pose_stamped(),
ik_link_names_length(0), ik_link_names(NULL),
pose_stamped_vector_length(0), pose_stamped_vector(NULL),
timeout(),
attempts(0)
{
}
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->robot_state.serialize(outbuffer + offset);
offset += this->constraints.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.real = this->avoid_collisions;
*(outbuffer + offset + 0) = (u_avoid_collisions.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->avoid_collisions);
uint32_t length_ik_link_name = strlen(this->ik_link_name);
varToArr(outbuffer + offset, length_ik_link_name);
offset += 4;
memcpy(outbuffer + offset, this->ik_link_name, length_ik_link_name);
offset += length_ik_link_name;
offset += this->pose_stamped.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->ik_link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ik_link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ik_link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ik_link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ik_link_names_length);
for( uint32_t i = 0; i < ik_link_names_length; i++){
uint32_t length_ik_link_namesi = strlen(this->ik_link_names[i]);
varToArr(outbuffer + offset, length_ik_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->ik_link_names[i], length_ik_link_namesi);
offset += length_ik_link_namesi;
}
*(outbuffer + offset + 0) = (this->pose_stamped_vector_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_stamped_vector_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_stamped_vector_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_stamped_vector_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_stamped_vector_length);
for( uint32_t i = 0; i < pose_stamped_vector_length; i++){
offset += this->pose_stamped_vector[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->timeout.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.sec);
*(outbuffer + offset + 0) = (this->timeout.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.nsec);
union {
int32_t real;
uint32_t base;
} u_attempts;
u_attempts.real = this->attempts;
*(outbuffer + offset + 0) = (u_attempts.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attempts.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attempts.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attempts.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->attempts);
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->robot_state.deserialize(inbuffer + offset);
offset += this->constraints.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.base = 0;
u_avoid_collisions.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->avoid_collisions = u_avoid_collisions.real;
offset += sizeof(this->avoid_collisions);
uint32_t length_ik_link_name;
arrToVar(length_ik_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_ik_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_ik_link_name-1]=0;
this->ik_link_name = (char *)(inbuffer + offset-1);
offset += length_ik_link_name;
offset += this->pose_stamped.deserialize(inbuffer + offset);
uint32_t ik_link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ik_link_names_length);
if(ik_link_names_lengthT > ik_link_names_length)
this->ik_link_names = (char**)realloc(this->ik_link_names, ik_link_names_lengthT * sizeof(char*));
ik_link_names_length = ik_link_names_lengthT;
for( uint32_t i = 0; i < ik_link_names_length; i++){
uint32_t length_st_ik_link_names;
arrToVar(length_st_ik_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_ik_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_ik_link_names-1]=0;
this->st_ik_link_names = (char *)(inbuffer + offset-1);
offset += length_st_ik_link_names;
memcpy( &(this->ik_link_names[i]), &(this->st_ik_link_names), sizeof(char*));
}
uint32_t pose_stamped_vector_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_stamped_vector_length);
if(pose_stamped_vector_lengthT > pose_stamped_vector_length)
this->pose_stamped_vector = (geometry_msgs::PoseStamped*)realloc(this->pose_stamped_vector, pose_stamped_vector_lengthT * sizeof(geometry_msgs::PoseStamped));
pose_stamped_vector_length = pose_stamped_vector_lengthT;
for( uint32_t i = 0; i < pose_stamped_vector_length; i++){
offset += this->st_pose_stamped_vector.deserialize(inbuffer + offset);
memcpy( &(this->pose_stamped_vector[i]), &(this->st_pose_stamped_vector), sizeof(geometry_msgs::PoseStamped));
}
this->timeout.sec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.sec);
this->timeout.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.nsec);
union {
int32_t real;
uint32_t base;
} u_attempts;
u_attempts.base = 0;
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->attempts = u_attempts.real;
offset += sizeof(this->attempts);
return offset;
}
const char * getType(){ return "moveit_msgs/PositionIKRequest"; };
const char * getMD5(){ return "9936dc239c90af180ec94a51596c96f2"; };
};
}
#endif
| 10,071 | C | 44.990867 | 166 | 0.593685 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetMotionPlan.h | #ifndef _ROS_SERVICE_GetMotionPlan_h
#define _ROS_SERVICE_GetMotionPlan_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionPlanRequest.h"
#include "moveit_msgs/MotionPlanResponse.h"
namespace moveit_msgs
{
static const char GETMOTIONPLAN[] = "moveit_msgs/GetMotionPlan";
class GetMotionPlanRequest : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanRequest _motion_plan_request_type;
_motion_plan_request_type motion_plan_request;
GetMotionPlanRequest():
motion_plan_request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->motion_plan_request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->motion_plan_request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMOTIONPLAN; };
const char * getMD5(){ return "9dcb82c5daeb2ff8a7ab1a98b642871d"; };
};
class GetMotionPlanResponse : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanResponse _motion_plan_response_type;
_motion_plan_response_type motion_plan_response;
GetMotionPlanResponse():
motion_plan_response()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->motion_plan_response.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->motion_plan_response.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMOTIONPLAN; };
const char * getMD5(){ return "37fe7e8f0d4dfa55ccfa53d63c86ae15"; };
};
class GetMotionPlan {
public:
typedef GetMotionPlanRequest Request;
typedef GetMotionPlanResponse Response;
};
}
#endif
| 2,000 | C | 23.108433 | 74 | 0.6765 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/SaveMap.h | #ifndef _ROS_SERVICE_SaveMap_h
#define _ROS_SERVICE_SaveMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char SAVEMAP[] = "moveit_msgs/SaveMap";
class SaveMapRequest : public ros::Msg
{
public:
typedef const char* _filename_type;
_filename_type filename;
SaveMapRequest():
filename("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_filename = strlen(this->filename);
varToArr(outbuffer + offset, length_filename);
offset += 4;
memcpy(outbuffer + offset, this->filename, length_filename);
offset += length_filename;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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;
return offset;
}
const char * getType(){ return SAVEMAP; };
const char * getMD5(){ return "030824f52a0628ead956fb9d67e66ae9"; };
};
class SaveMapResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
SaveMapResponse():
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 SAVEMAP; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class SaveMap {
public:
typedef SaveMapRequest Request;
typedef SaveMapResponse Response;
};
}
#endif
| 2,450 | C | 22.122641 | 74 | 0.599184 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanResponse.h | #ifndef _ROS_moveit_msgs_MotionPlanResponse_h
#define _ROS_moveit_msgs_MotionPlanResponse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/MoveItErrorCodes.h"
namespace moveit_msgs
{
class MotionPlanResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type trajectory;
typedef double _planning_time_type;
_planning_time_type planning_time;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
MotionPlanResponse():
trajectory_start(),
group_name(""),
trajectory(),
planning_time(0),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory_start.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->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);
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory_start.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->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);
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionPlanResponse"; };
const char * getMD5(){ return "e493d20ab41424c48f671e152c70fc74"; };
};
}
#endif
| 4,030 | C | 37.028302 | 81 | 0.602233 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanDetailedResponse.h | #ifndef _ROS_moveit_msgs_MotionPlanDetailedResponse_h
#define _ROS_moveit_msgs_MotionPlanDetailedResponse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/MoveItErrorCodes.h"
namespace moveit_msgs
{
class MotionPlanDetailedResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
typedef const char* _group_name_type;
_group_name_type group_name;
uint32_t trajectory_length;
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type st_trajectory;
_trajectory_type * trajectory;
uint32_t description_length;
typedef char* _description_type;
_description_type st_description;
_description_type * description;
uint32_t processing_time_length;
typedef double _processing_time_type;
_processing_time_type st_processing_time;
_processing_time_type * processing_time;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
MotionPlanDetailedResponse():
trajectory_start(),
group_name(""),
trajectory_length(0), trajectory(NULL),
description_length(0), description(NULL),
processing_time_length(0), processing_time(NULL),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory_start.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;
*(outbuffer + offset + 0) = (this->trajectory_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_length);
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->trajectory[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->description_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->description_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->description_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->description_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->description_length);
for( uint32_t i = 0; i < description_length; i++){
uint32_t length_descriptioni = strlen(this->description[i]);
varToArr(outbuffer + offset, length_descriptioni);
offset += 4;
memcpy(outbuffer + offset, this->description[i], length_descriptioni);
offset += length_descriptioni;
}
*(outbuffer + offset + 0) = (this->processing_time_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->processing_time_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->processing_time_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->processing_time_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->processing_time_length);
for( uint32_t i = 0; i < processing_time_length; i++){
union {
double real;
uint64_t base;
} u_processing_timei;
u_processing_timei.real = this->processing_time[i];
*(outbuffer + offset + 0) = (u_processing_timei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_processing_timei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_processing_timei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_processing_timei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_processing_timei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_processing_timei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_processing_timei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_processing_timei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->processing_time[i]);
}
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory_start.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;
uint32_t trajectory_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_length);
if(trajectory_lengthT > trajectory_length)
this->trajectory = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory, trajectory_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_length = trajectory_lengthT;
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->st_trajectory.deserialize(inbuffer + offset);
memcpy( &(this->trajectory[i]), &(this->st_trajectory), sizeof(moveit_msgs::RobotTrajectory));
}
uint32_t description_lengthT = ((uint32_t) (*(inbuffer + offset)));
description_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
description_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
description_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->description_length);
if(description_lengthT > description_length)
this->description = (char**)realloc(this->description, description_lengthT * sizeof(char*));
description_length = description_lengthT;
for( uint32_t i = 0; i < description_length; i++){
uint32_t length_st_description;
arrToVar(length_st_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_description-1]=0;
this->st_description = (char *)(inbuffer + offset-1);
offset += length_st_description;
memcpy( &(this->description[i]), &(this->st_description), sizeof(char*));
}
uint32_t processing_time_lengthT = ((uint32_t) (*(inbuffer + offset)));
processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->processing_time_length);
if(processing_time_lengthT > processing_time_length)
this->processing_time = (double*)realloc(this->processing_time, processing_time_lengthT * sizeof(double));
processing_time_length = processing_time_lengthT;
for( uint32_t i = 0; i < processing_time_length; i++){
union {
double real;
uint64_t base;
} u_st_processing_time;
u_st_processing_time.base = 0;
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_processing_time = u_st_processing_time.real;
offset += sizeof(this->st_processing_time);
memcpy( &(this->processing_time[i]), &(this->st_processing_time), sizeof(double));
}
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionPlanDetailedResponse"; };
const char * getMD5(){ return "7b84c374bb2e37bdc0eba664f7636a8f"; };
};
}
#endif
| 8,844 | C | 47.333333 | 143 | 0.606739 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/TrajectoryConstraints.h | #ifndef _ROS_moveit_msgs_TrajectoryConstraints_h
#define _ROS_moveit_msgs_TrajectoryConstraints_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/Constraints.h"
namespace moveit_msgs
{
class TrajectoryConstraints : public ros::Msg
{
public:
uint32_t constraints_length;
typedef moveit_msgs::Constraints _constraints_type;
_constraints_type st_constraints;
_constraints_type * constraints;
TrajectoryConstraints():
constraints_length(0), constraints(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->constraints_length);
for( uint32_t i = 0; i < constraints_length; i++){
offset += this->constraints[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->constraints_length);
if(constraints_lengthT > constraints_length)
this->constraints = (moveit_msgs::Constraints*)realloc(this->constraints, constraints_lengthT * sizeof(moveit_msgs::Constraints));
constraints_length = constraints_lengthT;
for( uint32_t i = 0; i < constraints_length; i++){
offset += this->st_constraints.deserialize(inbuffer + offset);
memcpy( &(this->constraints[i]), &(this->st_constraints), sizeof(moveit_msgs::Constraints));
}
return offset;
}
const char * getType(){ return "moveit_msgs/TrajectoryConstraints"; };
const char * getMD5(){ return "461e1a732dfebb01e7d6c75d51a51eac"; };
};
}
#endif
| 2,302 | C | 34.430769 | 138 | 0.63119 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupAction.h | #ifndef _ROS_moveit_msgs_PickupAction_h
#define _ROS_moveit_msgs_PickupAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PickupActionGoal.h"
#include "moveit_msgs/PickupActionResult.h"
#include "moveit_msgs/PickupActionFeedback.h"
namespace moveit_msgs
{
class PickupAction : public ros::Msg
{
public:
typedef moveit_msgs::PickupActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::PickupActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::PickupActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
PickupAction():
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/PickupAction"; };
const char * getMD5(){ return "966c9238fcaad4ba8d20e116b676ccc1"; };
};
}
#endif
| 1,583 | C | 26.789473 | 72 | 0.680985 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlannerInterfaceDescription.h | #ifndef _ROS_moveit_msgs_PlannerInterfaceDescription_h
#define _ROS_moveit_msgs_PlannerInterfaceDescription_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PlannerInterfaceDescription : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
uint32_t planner_ids_length;
typedef char* _planner_ids_type;
_planner_ids_type st_planner_ids;
_planner_ids_type * planner_ids;
PlannerInterfaceDescription():
name(""),
planner_ids_length(0), planner_ids(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->planner_ids_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planner_ids_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planner_ids_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planner_ids_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planner_ids_length);
for( uint32_t i = 0; i < planner_ids_length; i++){
uint32_t length_planner_idsi = strlen(this->planner_ids[i]);
varToArr(outbuffer + offset, length_planner_idsi);
offset += 4;
memcpy(outbuffer + offset, this->planner_ids[i], length_planner_idsi);
offset += length_planner_idsi;
}
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 planner_ids_lengthT = ((uint32_t) (*(inbuffer + offset)));
planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planner_ids_length);
if(planner_ids_lengthT > planner_ids_length)
this->planner_ids = (char**)realloc(this->planner_ids, planner_ids_lengthT * sizeof(char*));
planner_ids_length = planner_ids_lengthT;
for( uint32_t i = 0; i < planner_ids_length; i++){
uint32_t length_st_planner_ids;
arrToVar(length_st_planner_ids, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_planner_ids; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_planner_ids-1]=0;
this->st_planner_ids = (char *)(inbuffer + offset-1);
offset += length_st_planner_ids;
memcpy( &(this->planner_ids[i]), &(this->st_planner_ids), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/PlannerInterfaceDescription"; };
const char * getMD5(){ return "ea5f6e6129aa1b110ccda9900d2bf25e"; };
};
}
#endif
| 3,329 | C | 34.806451 | 100 | 0.604085 |